Import binutils-2.20
[dragonfly.git] / contrib / binutils-2.20 / gold / reloc.h
1 // reloc.h -- relocate input files for gold   -*- C++ -*-
2
3 // Copyright 2006, 2007, 2008, 2009 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 class 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;
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   // SYMTAB_LOCK is used to lock the symbol table.  BLOCKER should be
66   // unblocked when the Scan_relocs task completes.
67   Read_relocs(const General_options& options, Symbol_table* symtab,
68               Layout* layout, Relobj* object, Task_token* symtab_lock,
69               Task_token* blocker)
70     : options_(options), symtab_(symtab), layout_(layout), object_(object),
71       symtab_lock_(symtab_lock), blocker_(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   const General_options& options_;
90   Symbol_table* symtab_;
91   Layout* layout_;
92   Relobj* object_;
93   Task_token* symtab_lock_;
94   Task_token* blocker_;
95 };
96
97 // Process the relocs to figure out which sections are garbage.
98 // Very similar to scan relocs.
99
100 class Gc_process_relocs : public Task
101 {
102  public:
103   // SYMTAB_LOCK is used to lock the symbol table.  BLOCKER should be
104   // unblocked when the task completes.
105   Gc_process_relocs(const General_options& options, Symbol_table* symtab,
106               Layout* layout, Relobj* object, Read_relocs_data* rd,
107               Task_token* symtab_lock, Task_token* blocker)
108     : options_(options), symtab_(symtab), layout_(layout), object_(object),
109       rd_(rd), symtab_lock_(symtab_lock), blocker_(blocker)
110   { }
111
112   // The standard Task methods.
113
114   Task_token*
115   is_runnable();
116
117   void
118   locks(Task_locker*);
119
120   void
121   run(Workqueue*);
122
123   std::string
124   get_name() const;
125
126  private:
127   const General_options& options_;
128   Symbol_table* symtab_;
129   Layout* layout_;
130   Relobj* object_;
131   Read_relocs_data* rd_;
132   Task_token* symtab_lock_;
133   Task_token* blocker_;
134 };
135
136 // Scan the relocations for an object to see if they require any
137 // GOT/PLT/COPY relocations.
138
139 class Scan_relocs : public Task
140 {
141  public:
142   // SYMTAB_LOCK is used to lock the symbol table.  BLOCKER should be
143   // unblocked when the task completes.
144   Scan_relocs(const General_options& options, Symbol_table* symtab,
145               Layout* layout, Relobj* object, Read_relocs_data* rd,
146               Task_token* symtab_lock, Task_token* blocker)
147     : options_(options), symtab_(symtab), layout_(layout), object_(object),
148       rd_(rd), symtab_lock_(symtab_lock), blocker_(blocker)
149   { }
150
151   // The standard Task methods.
152
153   Task_token*
154   is_runnable();
155
156   void
157   locks(Task_locker*);
158
159   void
160   run(Workqueue*);
161
162   std::string
163   get_name() const;
164
165  private:
166   const General_options& options_;
167   Symbol_table* symtab_;
168   Layout* layout_;
169   Relobj* object_;
170   Read_relocs_data* rd_;
171   Task_token* symtab_lock_;
172   Task_token* blocker_;
173 };
174
175 // A class to perform all the relocations for an object file.
176
177 class Relocate_task : public Task
178 {
179  public:
180   Relocate_task(const General_options& options, const Symbol_table* symtab,
181                 const Layout* layout, Relobj* object, Output_file* of,
182                 Task_token* input_sections_blocker,
183                 Task_token* output_sections_blocker, Task_token* final_blocker)
184     : options_(options), symtab_(symtab), layout_(layout), object_(object),
185       of_(of), input_sections_blocker_(input_sections_blocker),
186       output_sections_blocker_(output_sections_blocker),
187       final_blocker_(final_blocker)
188   { }
189
190   // The standard Task methods.
191
192   Task_token*
193   is_runnable();
194
195   void
196   locks(Task_locker*);
197
198   void
199   run(Workqueue*);
200
201   std::string
202   get_name() const;
203
204  private:
205   const General_options& options_;
206   const Symbol_table* symtab_;
207   const Layout* layout_;
208   Relobj* object_;
209   Output_file* of_;
210   Task_token* input_sections_blocker_;
211   Task_token* output_sections_blocker_;
212   Task_token* final_blocker_;
213 };
214
215 // During a relocatable link, this class records how relocations
216 // should be handled for a single input reloc section.  An instance of
217 // this class is created while scanning relocs, and it is used while
218 // processing relocs.
219
220 class Relocatable_relocs
221 {
222  public:
223   // We use a vector of unsigned char to indicate how the input relocs
224   // should be handled.  Each element is one of the following values.
225   // We create this vector when we initially scan the relocations.
226   enum Reloc_strategy
227   {
228     // Copy the input reloc.  Don't modify it other than updating the
229     // r_offset field and the r_sym part of the r_info field.
230     RELOC_COPY,
231     // Copy the input reloc which is against an STT_SECTION symbol.
232     // Update the r_offset and r_sym part of the r_info field.  Adjust
233     // the addend by subtracting the value of the old local symbol and
234     // adding the value of the new local symbol.  The addend is in the
235     // SHT_RELA reloc and the contents of the data section do not need
236     // to be changed.
237     RELOC_ADJUST_FOR_SECTION_RELA,
238     // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
239     // adjusted.
240     RELOC_ADJUST_FOR_SECTION_0,
241     // Like RELOC_ADJUST_FOR_SECTION_RELA but the contents of the
242     // section need to be changed.  The number indicates the number of
243     // bytes in the addend in the section contents.
244     RELOC_ADJUST_FOR_SECTION_1,
245     RELOC_ADJUST_FOR_SECTION_2,
246     RELOC_ADJUST_FOR_SECTION_4,
247     RELOC_ADJUST_FOR_SECTION_8,
248     // Discard the input reloc--process it completely when relocating
249     // the data section contents.
250     RELOC_DISCARD,
251     // An input reloc which is not discarded, but which requires
252     // target specific processing in order to update it.
253     RELOC_SPECIAL
254   };
255
256   Relocatable_relocs()
257     : reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
258   { }
259
260   // Record the number of relocs.
261   void
262   set_reloc_count(size_t reloc_count)
263   { this->reloc_strategies_.reserve(reloc_count); }
264
265   // Record what to do for the next reloc.
266   void
267   set_next_reloc_strategy(Reloc_strategy strategy)
268   {
269     this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
270     if (strategy != RELOC_DISCARD)
271       ++this->output_reloc_count_;
272   }
273
274   // Record the Output_data associated with this reloc section.
275   void
276   set_output_data(Output_data* posd)
277   {
278     gold_assert(this->posd_ == NULL);
279     this->posd_ = posd;
280   }
281
282   // Return the Output_data associated with this reloc section.
283   Output_data*
284   output_data() const
285   { return this->posd_; }
286
287   // Return what to do for reloc I.
288   Reloc_strategy
289   strategy(unsigned int i) const
290   {
291     gold_assert(i < this->reloc_strategies_.size());
292     return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
293   }
294
295   // Return the number of relocations to create in the output file.
296   size_t
297   output_reloc_count() const
298   { return this->output_reloc_count_; }
299
300  private:
301   typedef std::vector<unsigned char> Reloc_strategies;
302
303   // The strategies for the input reloc.  There is one entry in this
304   // vector for each relocation in the input section.
305   Reloc_strategies reloc_strategies_;
306   // The number of relocations to be created in the output file.
307   size_t output_reloc_count_;
308   // The output data structure associated with this relocation.
309   Output_data* posd_;
310 };
311
312 // Standard relocation routines which are used on many targets.  Here
313 // SIZE and BIG_ENDIAN refer to the target, not the relocation type.
314
315 template<int size, bool big_endian>
316 class Relocate_functions
317 {
318 private:
319   // Do a simple relocation with the addend in the section contents.
320   // VALSIZE is the size of the value.
321   template<int valsize>
322   static inline void
323   rel(unsigned char* view,
324       typename elfcpp::Swap<valsize, big_endian>::Valtype value)
325   {
326     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
327     Valtype* wv = reinterpret_cast<Valtype*>(view);
328     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
329     elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value);
330   }
331
332   // Do a simple relocation using a Symbol_value with the addend in
333   // the section contents.  VALSIZE is the size of the value to
334   // relocate.
335   template<int valsize>
336   static inline void
337   rel(unsigned char* view,
338       const Sized_relobj<size, big_endian>* object,
339       const Symbol_value<size>* psymval)
340   {
341     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
342     Valtype* wv = reinterpret_cast<Valtype*>(view);
343     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
344     x = psymval->value(object, x);
345     elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
346   }
347
348   // Do a simple relocation with the addend in the relocation.
349   // VALSIZE is the size of the value.
350   template<int valsize>
351   static inline void
352   rela(unsigned char* view,
353        typename elfcpp::Swap<valsize, big_endian>::Valtype value,
354        typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
355   {
356     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
357     Valtype* wv = reinterpret_cast<Valtype*>(view);
358     elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend);
359   }
360
361   // Do a simple relocation using a symbol value with the addend in
362   // the relocation.  VALSIZE is the size of the value.
363   template<int valsize>
364   static inline void
365   rela(unsigned char* view,
366        const Sized_relobj<size, big_endian>* object,
367        const Symbol_value<size>* psymval,
368        typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
369   {
370     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
371     Valtype* wv = reinterpret_cast<Valtype*>(view);
372     Valtype x = psymval->value(object, addend);
373     elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
374   }
375
376   // Do a simple PC relative relocation with the addend in the section
377   // contents.  VALSIZE is the size of the value.
378   template<int valsize>
379   static inline void
380   pcrel(unsigned char* view,
381         typename elfcpp::Swap<valsize, big_endian>::Valtype value,
382         typename elfcpp::Elf_types<size>::Elf_Addr address)
383   {
384     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
385     Valtype* wv = reinterpret_cast<Valtype*>(view);
386     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
387     elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address);
388   }
389
390   // Do a simple PC relative relocation with a Symbol_value with the
391   // addend in the section contents.  VALSIZE is the size of the
392   // value.
393   template<int valsize>
394   static inline void
395   pcrel(unsigned char* view,
396         const Sized_relobj<size, big_endian>* object,
397         const Symbol_value<size>* psymval,
398         typename elfcpp::Elf_types<size>::Elf_Addr address)
399   {
400     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
401     Valtype* wv = reinterpret_cast<Valtype*>(view);
402     Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
403     x = psymval->value(object, x);
404     elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
405   }
406
407   // Do a simple PC relative relocation with the addend in the
408   // relocation.  VALSIZE is the size of the value.
409   template<int valsize>
410   static inline void
411   pcrela(unsigned char* view,
412          typename elfcpp::Swap<valsize, big_endian>::Valtype value,
413          typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
414          typename elfcpp::Elf_types<size>::Elf_Addr address)
415   {
416     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
417     Valtype* wv = reinterpret_cast<Valtype*>(view);
418     elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend - address);
419   }
420
421   // Do a simple PC relative relocation with a Symbol_value with the
422   // addend in the relocation.  VALSIZE is the size of the value.
423   template<int valsize>
424   static inline void
425   pcrela(unsigned char* view,
426          const Sized_relobj<size, big_endian>* object,
427          const Symbol_value<size>* psymval,
428          typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
429          typename elfcpp::Elf_types<size>::Elf_Addr address)
430   {
431     typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
432     Valtype* wv = reinterpret_cast<Valtype*>(view);
433     Valtype x = psymval->value(object, addend);
434     elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
435   }
436
437   typedef Relocate_functions<size, big_endian> This;
438
439 public:
440   // Do a simple 8-bit REL relocation with the addend in the section
441   // contents.
442   static inline void
443   rel8(unsigned char* view, unsigned char value)
444   { This::template rel<8>(view, value); }
445
446   static inline void
447   rel8(unsigned char* view,
448        const Sized_relobj<size, big_endian>* object,
449        const Symbol_value<size>* psymval)
450   { This::template rel<8>(view, object, psymval); }
451
452   // Do an 8-bit RELA relocation with the addend in the relocation.
453   static inline void
454   rela8(unsigned char* view, unsigned char value, unsigned char addend)
455   { This::template rela<8>(view, value, addend); }
456
457   static inline void
458   rela8(unsigned char* view,
459         const Sized_relobj<size, big_endian>* object,
460         const Symbol_value<size>* psymval,
461         unsigned char addend)
462   { This::template rela<8>(view, object, psymval, addend); }
463
464   // Do a simple 8-bit PC relative relocation with the addend in the
465   // section contents.
466   static inline void
467   pcrel8(unsigned char* view, unsigned char value,
468          typename elfcpp::Elf_types<size>::Elf_Addr address)
469   { This::template pcrel<8>(view, value, address); }
470
471   static inline void
472   pcrel8(unsigned char* view,
473          const Sized_relobj<size, big_endian>* object,
474          const Symbol_value<size>* psymval,
475          typename elfcpp::Elf_types<size>::Elf_Addr address)
476   { This::template pcrel<8>(view, object, psymval, address); }
477
478   // Do a simple 8-bit PC relative RELA relocation with the addend in
479   // the reloc.
480   static inline void
481   pcrela8(unsigned char* view, unsigned char value, unsigned char addend,
482           typename elfcpp::Elf_types<size>::Elf_Addr address)
483   { This::template pcrela<8>(view, value, addend, address); }
484
485   static inline void
486   pcrela8(unsigned char* view,
487           const Sized_relobj<size, big_endian>* object,
488           const Symbol_value<size>* psymval,
489           unsigned char addend,
490           typename elfcpp::Elf_types<size>::Elf_Addr address)
491   { This::template pcrela<8>(view, object, psymval, addend, address); }
492
493   // Do a simple 16-bit REL relocation with the addend in the section
494   // contents.
495   static inline void
496   rel16(unsigned char* view, elfcpp::Elf_Half value)
497   { This::template rel<16>(view, value); }
498
499   static inline void
500   rel16(unsigned char* view,
501         const Sized_relobj<size, big_endian>* object,
502         const Symbol_value<size>* psymval)
503   { This::template rel<16>(view, object, psymval); }
504
505   // Do an 16-bit RELA relocation with the addend in the relocation.
506   static inline void
507   rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend)
508   { This::template rela<16>(view, value, addend); }
509
510   static inline void
511   rela16(unsigned char* view,
512          const Sized_relobj<size, big_endian>* object,
513          const Symbol_value<size>* psymval,
514          elfcpp::Elf_Half addend)
515   { This::template rela<16>(view, object, psymval, addend); }
516
517   // Do a simple 16-bit PC relative REL relocation with the addend in
518   // the section contents.
519   static inline void
520   pcrel16(unsigned char* view, elfcpp::Elf_Half value,
521           typename elfcpp::Elf_types<size>::Elf_Addr address)
522   { This::template pcrel<16>(view, value, address); }
523
524   static inline void
525   pcrel16(unsigned char* view,
526           const Sized_relobj<size, big_endian>* object,
527           const Symbol_value<size>* psymval,
528           typename elfcpp::Elf_types<size>::Elf_Addr address)
529   { This::template pcrel<16>(view, object, psymval, address); }
530
531   // Do a simple 16-bit PC relative RELA relocation with the addend in
532   // the reloc.
533   static inline void
534   pcrela16(unsigned char* view, elfcpp::Elf_Half value,
535            elfcpp::Elf_Half addend,
536            typename elfcpp::Elf_types<size>::Elf_Addr address)
537   { This::template pcrela<16>(view, value, addend, address); }
538
539   static inline void
540   pcrela16(unsigned char* view,
541            const Sized_relobj<size, big_endian>* object,
542            const Symbol_value<size>* psymval,
543            elfcpp::Elf_Half addend,
544            typename elfcpp::Elf_types<size>::Elf_Addr address)
545   { This::template pcrela<16>(view, object, psymval, addend, address); }
546
547   // Do a simple 32-bit REL relocation with the addend in the section
548   // contents.
549   static inline void
550   rel32(unsigned char* view, elfcpp::Elf_Word value)
551   { This::template rel<32>(view, value); }
552
553   static inline void
554   rel32(unsigned char* view,
555         const Sized_relobj<size, big_endian>* object,
556         const Symbol_value<size>* psymval)
557   { This::template rel<32>(view, object, psymval); }
558
559   // Do an 32-bit RELA relocation with the addend in the relocation.
560   static inline void
561   rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend)
562   { This::template rela<32>(view, value, addend); }
563
564   static inline void
565   rela32(unsigned char* view,
566          const Sized_relobj<size, big_endian>* object,
567          const Symbol_value<size>* psymval,
568          elfcpp::Elf_Word addend)
569   { This::template rela<32>(view, object, psymval, addend); }
570
571   // Do a simple 32-bit PC relative REL relocation with the addend in
572   // the section contents.
573   static inline void
574   pcrel32(unsigned char* view, elfcpp::Elf_Word value,
575           typename elfcpp::Elf_types<size>::Elf_Addr address)
576   { This::template pcrel<32>(view, value, address); }
577
578   static inline void
579   pcrel32(unsigned char* view,
580           const Sized_relobj<size, big_endian>* object,
581           const Symbol_value<size>* psymval,
582           typename elfcpp::Elf_types<size>::Elf_Addr address)
583   { This::template pcrel<32>(view, object, psymval, address); }
584
585   // Do a simple 32-bit PC relative RELA relocation with the addend in
586   // the relocation.
587   static inline void
588   pcrela32(unsigned char* view, elfcpp::Elf_Word value,
589            elfcpp::Elf_Word addend,
590            typename elfcpp::Elf_types<size>::Elf_Addr address)
591   { This::template pcrela<32>(view, value, addend, address); }
592
593   static inline void
594   pcrela32(unsigned char* view,
595            const Sized_relobj<size, big_endian>* object,
596            const Symbol_value<size>* psymval,
597            elfcpp::Elf_Word addend,
598            typename elfcpp::Elf_types<size>::Elf_Addr address)
599   { This::template pcrela<32>(view, object, psymval, addend, address); }
600
601   // Do a simple 64-bit REL relocation with the addend in the section
602   // contents.
603   static inline void
604   rel64(unsigned char* view, elfcpp::Elf_Xword value)
605   { This::template rel<64>(view, value); }
606
607   static inline void
608   rel64(unsigned char* view,
609         const Sized_relobj<size, big_endian>* object,
610         const Symbol_value<size>* psymval)
611   { This::template rel<64>(view, object, psymval); }
612
613   // Do a 64-bit RELA relocation with the addend in the relocation.
614   static inline void
615   rela64(unsigned char* view, elfcpp::Elf_Xword value,
616          elfcpp::Elf_Xword addend)
617   { This::template rela<64>(view, value, addend); }
618
619   static inline void
620   rela64(unsigned char* view,
621          const Sized_relobj<size, big_endian>* object,
622          const Symbol_value<size>* psymval,
623          elfcpp::Elf_Xword addend)
624   { This::template rela<64>(view, object, psymval, addend); }
625
626   // Do a simple 64-bit PC relative REL relocation with the addend in
627   // the section contents.
628   static inline void
629   pcrel64(unsigned char* view, elfcpp::Elf_Xword value,
630           typename elfcpp::Elf_types<size>::Elf_Addr address)
631   { This::template pcrel<64>(view, value, address); }
632
633   static inline void
634   pcrel64(unsigned char* view,
635           const Sized_relobj<size, big_endian>* object,
636           const Symbol_value<size>* psymval,
637           typename elfcpp::Elf_types<size>::Elf_Addr address)
638   { This::template pcrel<64>(view, object, psymval, address); }
639
640   // Do a simple 64-bit PC relative RELA relocation with the addend in
641   // the relocation.
642   static inline void
643   pcrela64(unsigned char* view, elfcpp::Elf_Xword value,
644            elfcpp::Elf_Xword addend,
645            typename elfcpp::Elf_types<size>::Elf_Addr address)
646   { This::template pcrela<64>(view, value, addend, address); }
647
648   static inline void
649   pcrela64(unsigned char* view,
650            const Sized_relobj<size, big_endian>* object,
651            const Symbol_value<size>* psymval,
652            elfcpp::Elf_Xword addend,
653            typename elfcpp::Elf_types<size>::Elf_Addr address)
654   { This::template pcrela<64>(view, object, psymval, addend, address); }
655 };
656
657 // Track relocations while reading a section.  This lets you ask for
658 // the relocation at a certain offset, and see how relocs occur
659 // between points of interest.
660
661 template<int size, bool big_endian>
662 class Track_relocs
663 {
664  public:
665   Track_relocs()
666     : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
667   { }
668
669   // Initialize the Track_relocs object.  OBJECT is the object holding
670   // the reloc section, RELOC_SHNDX is the section index of the reloc
671   // section, and RELOC_TYPE is the type of the reloc section
672   // (elfcpp::SHT_REL or elfcpp::SHT_RELA).  This returns false if
673   // something went wrong.
674   bool
675   initialize(Object* object, unsigned int reloc_shndx,
676              unsigned int reloc_type);
677
678   // Return the offset in the data section to which the next reloc
679   // applies.  THis returns -1 if there is no next reloc.
680   off_t
681   next_offset() const;
682
683   // Return the symbol index of the next reloc.  This returns -1U if
684   // there is no next reloc.
685   unsigned int
686   next_symndx() const;
687
688   // Advance to OFFSET within the data section, and return the number
689   // of relocs which would be skipped.
690   int
691   advance(off_t offset);
692
693  private:
694   // The contents of the input object's reloc section.
695   const unsigned char* prelocs_;
696   // The length of the reloc section.
697   section_size_type len_;
698   // Our current position in the reloc section.
699   section_size_type pos_;
700   // The size of the relocs in the section.
701   int reloc_size_;
702 };
703
704 } // End namespace gold.
705
706 #endif // !defined(GOLD_RELOC_H)