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)