Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.25 / gold / reloc.h
1 // reloc.h -- relocate input files for gold   -*- C++ -*-
2
3 // Copyright (C) 2006-2014 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   // Return the number of relocations to create in the output file.
300   size_t
301   output_reloc_count() const
302   { return this->output_reloc_count_; }
303
304  private:
305   typedef std::vector<unsigned char> Reloc_strategies;
306
307   // The strategies for the input reloc.  There is one entry in this
308   // vector for each relocation in the input section.
309   Reloc_strategies reloc_strategies_;
310   // The number of relocations to be created in the output file.
311   size_t output_reloc_count_;
312   // The output data structure associated with this relocation.
313   Output_data* posd_;
314 };
315
316 // Standard relocation routines which are used on many targets.  Here
317 // SIZE and BIG_ENDIAN refer to the target, not the relocation type.
318
319 template<int size, bool big_endian>
320 class Relocate_functions
321 {
322 private:
323   // Do a simple relocation with the addend in the section contents.
324   // VALSIZE is the size of the value.
325   template<int valsize>
326   static inline void
327   rel(unsigned char* view,
328       typename elfcpp::Swap<valsize, big_endian>::Valtype value)
329   {
330     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
331     Valtype* wv = reinterpret_cast<Valtype*>(view);
332     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
333     elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value);
334   }
335
336   // Like the above but for relocs at unaligned addresses.
337   template<int valsize>
338   static inline void
339   rel_unaligned(unsigned char* view,
340                 typename elfcpp::Swap<valsize, big_endian>::Valtype value)
341   {
342     typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
343         Valtype;
344     Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
345     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x + value);
346   }
347
348   // Do a simple relocation using a Symbol_value with the addend in
349   // the section contents.  VALSIZE is the size of the value to
350   // relocate.
351   template<int valsize>
352   static inline void
353   rel(unsigned char* view,
354       const Sized_relobj_file<size, big_endian>* object,
355       const Symbol_value<size>* psymval)
356   {
357     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
358     Valtype* wv = reinterpret_cast<Valtype*>(view);
359     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
360     x = psymval->value(object, x);
361     elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
362   }
363
364   // Like the above but for relocs at unaligned addresses.
365   template<int valsize>
366   static inline void
367   rel_unaligned(unsigned char* view,
368                 const Sized_relobj_file<size, big_endian>* object,
369                 const Symbol_value<size>* psymval)
370   {
371     typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
372         Valtype;
373     Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
374     x = psymval->value(object, x);
375     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x);
376   }
377
378   // Do a simple relocation with the addend in the relocation.
379   // VALSIZE is the size of the value.
380   template<int valsize>
381   static inline void
382   rela(unsigned char* view,
383        typename elfcpp::Swap<valsize, big_endian>::Valtype value,
384        typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
385   {
386     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
387     Valtype* wv = reinterpret_cast<Valtype*>(view);
388     elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend);
389   }
390
391   // Do a simple relocation using a symbol value with the addend in
392   // the relocation.  VALSIZE is the size of the value.
393   template<int valsize>
394   static inline void
395   rela(unsigned char* view,
396        const Sized_relobj_file<size, big_endian>* object,
397        const Symbol_value<size>* psymval,
398        typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
399   {
400     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
401     Valtype* wv = reinterpret_cast<Valtype*>(view);
402     Valtype x = psymval->value(object, addend);
403     elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
404   }
405
406   // Do a simple PC relative relocation with the addend in the section
407   // contents.  VALSIZE is the size of the value.
408   template<int valsize>
409   static inline void
410   pcrel(unsigned char* view,
411         typename elfcpp::Swap<valsize, big_endian>::Valtype value,
412         typename elfcpp::Elf_types<size>::Elf_Addr address)
413   {
414     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
415     Valtype* wv = reinterpret_cast<Valtype*>(view);
416     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
417     elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address);
418   }
419
420   // Like the above but for relocs at unaligned addresses.
421   template<int valsize>
422   static inline void
423   pcrel_unaligned(unsigned char* view,
424                   typename elfcpp::Swap<valsize, big_endian>::Valtype value,
425                   typename elfcpp::Elf_types<size>::Elf_Addr address)
426   {
427     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
428     Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
429     elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view,
430                                                           x + value - address);
431   }
432
433   // Do a simple PC relative relocation with a Symbol_value with the
434   // addend in the section contents.  VALSIZE is the size of the
435   // value.
436   template<int valsize>
437   static inline void
438   pcrel(unsigned char* view,
439         const Sized_relobj_file<size, big_endian>* object,
440         const Symbol_value<size>* psymval,
441         typename elfcpp::Elf_types<size>::Elf_Addr address)
442   {
443     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
444     Valtype* wv = reinterpret_cast<Valtype*>(view);
445     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
446     x = psymval->value(object, x);
447     elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
448   }
449
450   // Do a simple PC relative relocation with the addend in the
451   // relocation.  VALSIZE is the size of the value.
452   template<int valsize>
453   static inline void
454   pcrela(unsigned char* view,
455          typename elfcpp::Swap<valsize, big_endian>::Valtype value,
456          typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
457          typename elfcpp::Elf_types<size>::Elf_Addr address)
458   {
459     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
460     Valtype* wv = reinterpret_cast<Valtype*>(view);
461     elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend - address);
462   }
463
464   // Do a simple PC relative relocation with a Symbol_value with the
465   // addend in the relocation.  VALSIZE is the size of the value.
466   template<int valsize>
467   static inline void
468   pcrela(unsigned char* view,
469          const Sized_relobj_file<size, big_endian>* object,
470          const Symbol_value<size>* psymval,
471          typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
472          typename elfcpp::Elf_types<size>::Elf_Addr address)
473   {
474     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
475     Valtype* wv = reinterpret_cast<Valtype*>(view);
476     Valtype x = psymval->value(object, addend);
477     elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
478   }
479
480   typedef Relocate_functions<size, big_endian> This;
481
482 public:
483   // Do a simple 8-bit REL relocation with the addend in the section
484   // contents.
485   static inline void
486   rel8(unsigned char* view, unsigned char value)
487   { This::template rel<8>(view, value); }
488
489   static inline void
490   rel8(unsigned char* view,
491        const Sized_relobj_file<size, big_endian>* object,
492        const Symbol_value<size>* psymval)
493   { This::template rel<8>(view, object, psymval); }
494
495   // Do an 8-bit RELA relocation with the addend in the relocation.
496   static inline void
497   rela8(unsigned char* view, unsigned char value, unsigned char addend)
498   { This::template rela<8>(view, value, addend); }
499
500   static inline void
501   rela8(unsigned char* view,
502         const Sized_relobj_file<size, big_endian>* object,
503         const Symbol_value<size>* psymval,
504         unsigned char addend)
505   { This::template rela<8>(view, object, psymval, addend); }
506
507   // Do a simple 8-bit PC relative relocation with the addend in the
508   // section contents.
509   static inline void
510   pcrel8(unsigned char* view, unsigned char value,
511          typename elfcpp::Elf_types<size>::Elf_Addr address)
512   { This::template pcrel<8>(view, value, address); }
513
514   static inline void
515   pcrel8(unsigned char* view,
516          const Sized_relobj_file<size, big_endian>* object,
517          const Symbol_value<size>* psymval,
518          typename elfcpp::Elf_types<size>::Elf_Addr address)
519   { This::template pcrel<8>(view, object, psymval, address); }
520
521   // Do a simple 8-bit PC relative RELA relocation with the addend in
522   // the reloc.
523   static inline void
524   pcrela8(unsigned char* view, unsigned char value, unsigned char addend,
525           typename elfcpp::Elf_types<size>::Elf_Addr address)
526   { This::template pcrela<8>(view, value, addend, address); }
527
528   static inline void
529   pcrela8(unsigned char* view,
530           const Sized_relobj_file<size, big_endian>* object,
531           const Symbol_value<size>* psymval,
532           unsigned char addend,
533           typename elfcpp::Elf_types<size>::Elf_Addr address)
534   { This::template pcrela<8>(view, object, psymval, addend, address); }
535
536   // Do a simple 16-bit REL relocation with the addend in the section
537   // contents.
538   static inline void
539   rel16(unsigned char* view, elfcpp::Elf_Half value)
540   { This::template rel<16>(view, value); }
541
542   static inline void
543   rel16(unsigned char* view,
544         const Sized_relobj_file<size, big_endian>* object,
545         const Symbol_value<size>* psymval)
546   { This::template rel<16>(view, object, psymval); }
547
548   // Do an 16-bit RELA relocation with the addend in the relocation.
549   static inline void
550   rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend)
551   { This::template rela<16>(view, value, addend); }
552
553   static inline void
554   rela16(unsigned char* view,
555          const Sized_relobj_file<size, big_endian>* object,
556          const Symbol_value<size>* psymval,
557          elfcpp::Elf_Half addend)
558   { This::template rela<16>(view, object, psymval, addend); }
559
560   // Do a simple 16-bit PC relative REL relocation with the addend in
561   // the section contents.
562   static inline void
563   pcrel16(unsigned char* view, elfcpp::Elf_Half value,
564           typename elfcpp::Elf_types<size>::Elf_Addr address)
565   { This::template pcrel<16>(view, value, address); }
566
567   static inline void
568   pcrel16(unsigned char* view,
569           const Sized_relobj_file<size, big_endian>* object,
570           const Symbol_value<size>* psymval,
571           typename elfcpp::Elf_types<size>::Elf_Addr address)
572   { This::template pcrel<16>(view, object, psymval, address); }
573
574   // Do a simple 16-bit PC relative RELA relocation with the addend in
575   // the reloc.
576   static inline void
577   pcrela16(unsigned char* view, elfcpp::Elf_Half value,
578            elfcpp::Elf_Half addend,
579            typename elfcpp::Elf_types<size>::Elf_Addr address)
580   { This::template pcrela<16>(view, value, addend, address); }
581
582   static inline void
583   pcrela16(unsigned char* view,
584            const Sized_relobj_file<size, big_endian>* object,
585            const Symbol_value<size>* psymval,
586            elfcpp::Elf_Half addend,
587            typename elfcpp::Elf_types<size>::Elf_Addr address)
588   { This::template pcrela<16>(view, object, psymval, addend, address); }
589
590   // Do a simple 32-bit REL relocation with the addend in the section
591   // contents.
592   static inline void
593   rel32(unsigned char* view, elfcpp::Elf_Word value)
594   { This::template rel<32>(view, value); }
595
596   // Like above but for relocs at unaligned addresses.
597   static inline void
598   rel32_unaligned(unsigned char* view, elfcpp::Elf_Word value)
599   { This::template rel_unaligned<32>(view, value); }
600
601   static inline void
602   rel32(unsigned char* view,
603         const Sized_relobj_file<size, big_endian>* object,
604         const Symbol_value<size>* psymval)
605   { This::template rel<32>(view, object, psymval); }
606
607   // Like above but for relocs at unaligned addresses.
608   static inline void
609   rel32_unaligned(unsigned char* view,
610                   const Sized_relobj_file<size, big_endian>* object,
611                   const Symbol_value<size>* psymval)
612   { This::template rel_unaligned<32>(view, object, psymval); }
613
614   // Do an 32-bit RELA relocation with the addend in the relocation.
615   static inline void
616   rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend)
617   { This::template rela<32>(view, value, addend); }
618
619   static inline void
620   rela32(unsigned char* view,
621          const Sized_relobj_file<size, big_endian>* object,
622          const Symbol_value<size>* psymval,
623          elfcpp::Elf_Word addend)
624   { This::template rela<32>(view, object, psymval, addend); }
625
626   // Do a simple 32-bit PC relative REL relocation with the addend in
627   // the section contents.
628   static inline void
629   pcrel32(unsigned char* view, elfcpp::Elf_Word value,
630           typename elfcpp::Elf_types<size>::Elf_Addr address)
631   { This::template pcrel<32>(view, value, address); }
632
633   // Unaligned version of the above.
634   static inline void
635   pcrel32_unaligned(unsigned char* view, elfcpp::Elf_Word value,
636                     typename elfcpp::Elf_types<size>::Elf_Addr address)
637   { This::template pcrel_unaligned<32>(view, value, address); }
638
639   static inline void
640   pcrel32(unsigned char* view,
641           const Sized_relobj_file<size, big_endian>* object,
642           const Symbol_value<size>* psymval,
643           typename elfcpp::Elf_types<size>::Elf_Addr address)
644   { This::template pcrel<32>(view, object, psymval, address); }
645
646   // Do a simple 32-bit PC relative RELA relocation with the addend in
647   // the relocation.
648   static inline void
649   pcrela32(unsigned char* view, elfcpp::Elf_Word value,
650            elfcpp::Elf_Word addend,
651            typename elfcpp::Elf_types<size>::Elf_Addr address)
652   { This::template pcrela<32>(view, value, addend, address); }
653
654   static inline void
655   pcrela32(unsigned char* view,
656            const Sized_relobj_file<size, big_endian>* object,
657            const Symbol_value<size>* psymval,
658            elfcpp::Elf_Word addend,
659            typename elfcpp::Elf_types<size>::Elf_Addr address)
660   { This::template pcrela<32>(view, object, psymval, addend, address); }
661
662   // Do a simple 64-bit REL relocation with the addend in the section
663   // contents.
664   static inline void
665   rel64(unsigned char* view, elfcpp::Elf_Xword value)
666   { This::template rel<64>(view, value); }
667
668   static inline void
669   rel64(unsigned char* view,
670         const Sized_relobj_file<size, big_endian>* object,
671         const Symbol_value<size>* psymval)
672   { This::template rel<64>(view, object, psymval); }
673
674   // Do a 64-bit RELA relocation with the addend in the relocation.
675   static inline void
676   rela64(unsigned char* view, elfcpp::Elf_Xword value,
677          elfcpp::Elf_Xword addend)
678   { This::template rela<64>(view, value, addend); }
679
680   static inline void
681   rela64(unsigned char* view,
682          const Sized_relobj_file<size, big_endian>* object,
683          const Symbol_value<size>* psymval,
684          elfcpp::Elf_Xword addend)
685   { This::template rela<64>(view, object, psymval, addend); }
686
687   // Do a simple 64-bit PC relative REL relocation with the addend in
688   // the section contents.
689   static inline void
690   pcrel64(unsigned char* view, elfcpp::Elf_Xword value,
691           typename elfcpp::Elf_types<size>::Elf_Addr address)
692   { This::template pcrel<64>(view, value, address); }
693
694   static inline void
695   pcrel64(unsigned char* view,
696           const Sized_relobj_file<size, big_endian>* object,
697           const Symbol_value<size>* psymval,
698           typename elfcpp::Elf_types<size>::Elf_Addr address)
699   { This::template pcrel<64>(view, object, psymval, address); }
700
701   // Do a simple 64-bit PC relative RELA relocation with the addend in
702   // the relocation.
703   static inline void
704   pcrela64(unsigned char* view, elfcpp::Elf_Xword value,
705            elfcpp::Elf_Xword addend,
706            typename elfcpp::Elf_types<size>::Elf_Addr address)
707   { This::template pcrela<64>(view, value, addend, address); }
708
709   static inline void
710   pcrela64(unsigned char* view,
711            const Sized_relobj_file<size, big_endian>* object,
712            const Symbol_value<size>* psymval,
713            elfcpp::Elf_Xword addend,
714            typename elfcpp::Elf_types<size>::Elf_Addr address)
715   { This::template pcrela<64>(view, object, psymval, addend, address); }
716 };
717
718 // Integer manipulation functions used by various targets when
719 // performing relocations.
720
721 template<int bits>
722 class Bits
723 {
724  public:
725   // Sign extend an n-bit unsigned integer stored in a uint32_t into
726   // an int32_t.  BITS must be between 1 and 32.
727   static inline int32_t
728   sign_extend32(uint32_t val)
729   {
730     gold_assert(bits > 0 && bits <= 32);
731     if (bits == 32)
732       return static_cast<int32_t>(val);
733     uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
734     val &= mask;
735     uint32_t top_bit = 1U << (bits - 1);
736     int32_t as_signed = static_cast<int32_t>(val);
737     if ((val & top_bit) != 0)
738       as_signed -= static_cast<int32_t>(top_bit * 2);
739     return as_signed;    
740   }
741
742   // Return true if VAL (stored in a uint32_t) has overflowed a signed
743   // value with BITS bits.
744   static inline bool
745   has_overflow32(uint32_t val)
746   {
747     gold_assert(bits > 0 && bits <= 32);
748     if (bits == 32)
749       return false;
750     int32_t max = (1 << (bits - 1)) - 1;
751     int32_t min = -(1 << (bits - 1));
752     int32_t as_signed = static_cast<int32_t>(val);
753     return as_signed > max || as_signed < min;
754   }
755
756   // Return true if VAL (stored in a uint32_t) has overflowed both a
757   // signed and an unsigned value.  E.g.,
758   // Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
759   // 255.
760   static inline bool
761   has_signed_unsigned_overflow32(uint32_t val)
762   {
763     gold_assert(bits > 0 && bits <= 32);
764     if (bits == 32)
765       return false;
766     int32_t max = static_cast<int32_t>((1U << bits) - 1);
767     int32_t min = -(1 << (bits - 1));
768     int32_t as_signed = static_cast<int32_t>(val);
769     return as_signed > max || as_signed < min;
770   }
771
772   // Select bits from A and B using bits in MASK.  For each n in
773   // [0..31], the n-th bit in the result is chosen from the n-th bits
774   // of A and B.  A zero selects A and a one selects B.
775   static inline uint32_t
776   bit_select32(uint32_t a, uint32_t b, uint32_t mask)
777   { return (a & ~mask) | (b & mask); }
778
779   // Sign extend an n-bit unsigned integer stored in a uint64_t into
780   // an int64_t.  BITS must be between 1 and 64.
781   static inline int64_t
782   sign_extend(uint64_t val)
783   {
784     gold_assert(bits > 0 && bits <= 64);
785     if (bits == 64)
786       return static_cast<int64_t>(val);
787     uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
788     val &= mask;
789     uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
790     int64_t as_signed = static_cast<int64_t>(val);
791     if ((val & top_bit) != 0)
792       as_signed -= static_cast<int64_t>(top_bit * 2);
793     return as_signed;    
794   }
795
796   // Return true if VAL (stored in a uint64_t) has overflowed a signed
797   // value with BITS bits.
798   static inline bool
799   has_overflow(uint64_t val)
800   {
801     gold_assert(bits > 0 && bits <= 64);
802     if (bits == 64)
803       return false;
804     int64_t max = (static_cast<int64_t>(1) << (bits - 1)) - 1;
805     int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
806     int64_t as_signed = static_cast<int64_t>(val);
807     return as_signed > max || as_signed < min;
808   }
809
810   // Return true if VAL (stored in a uint64_t) has overflowed both a
811   // signed and an unsigned value.  E.g.,
812   // Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
813   // 255.
814   static inline bool
815   has_signed_unsigned_overflow64(uint64_t val)
816   {
817     gold_assert(bits > 0 && bits <= 64);
818     if (bits == 64)
819       return false;
820     int64_t max = static_cast<int64_t>((static_cast<uint64_t>(1) << bits) - 1);
821     int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
822     int64_t as_signed = static_cast<int64_t>(val);
823     return as_signed > max || as_signed < min;
824   }
825
826   // Select bits from A and B using bits in MASK.  For each n in
827   // [0..31], the n-th bit in the result is chosen from the n-th bits
828   // of A and B.  A zero selects A and a one selects B.
829   static inline uint64_t
830   bit_select64(uint64_t a, uint64_t b, uint64_t mask)
831   { return (a & ~mask) | (b & mask); }
832 };
833
834 // Track relocations while reading a section.  This lets you ask for
835 // the relocation at a certain offset, and see how relocs occur
836 // between points of interest.
837
838 template<int size, bool big_endian>
839 class Track_relocs
840 {
841  public:
842   Track_relocs()
843     : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
844   { }
845
846   // Initialize the Track_relocs object.  OBJECT is the object holding
847   // the reloc section, RELOC_SHNDX is the section index of the reloc
848   // section, and RELOC_TYPE is the type of the reloc section
849   // (elfcpp::SHT_REL or elfcpp::SHT_RELA).  This returns false if
850   // something went wrong.
851   bool
852   initialize(Object* object, unsigned int reloc_shndx,
853              unsigned int reloc_type);
854
855   // Return the offset in the data section to which the next reloc
856   // applies.  This returns -1 if there is no next reloc.
857   off_t
858   next_offset() const;
859
860   // Return the symbol index of the next reloc.  This returns -1U if
861   // there is no next reloc.
862   unsigned int
863   next_symndx() const;
864
865   // Return the addend of the next reloc.  This returns 0 if there is
866   // no next reloc.
867   uint64_t
868   next_addend() const;
869
870   // Advance to OFFSET within the data section, and return the number
871   // of relocs which would be skipped.
872   int
873   advance(off_t offset);
874
875   // Checkpoint the current position in the reloc section.
876   section_size_type
877   checkpoint() const
878   { return this->pos_; }
879
880   // Reset the position to CHECKPOINT.
881   void
882   reset(section_size_type checkpoint)
883   { this->pos_ = checkpoint; }
884
885  private:
886   // The contents of the input object's reloc section.
887   const unsigned char* prelocs_;
888   // The length of the reloc section.
889   section_size_type len_;
890   // Our current position in the reloc section.
891   section_size_type pos_;
892   // The size of the relocs in the section.
893   int reloc_size_;
894 };
895
896 } // End namespace gold.
897
898 #endif // !defined(GOLD_RELOC_H)