gold/reloc.cc

   1 // reloc.cc -- relocate input files for gold.
   2
   3 // Copyright 2006, 2007 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 #include "gold.h"
  24
  25 #include "workqueue.h"
  26 #include "object.h"
  27 #include "symtab.h"
  28 #include "output.h"
  29 #include "reloc.h"
  30
  31 namespace gold
  32 {
  33
  34 // Read_relocs methods.
  35
  36 // These tasks just read the relocation information from the file.
  37 // After reading it, the start another task to process the
  38 // information.  These tasks requires access to the file.
  39
  40 Task::Is_runnable_type
  41 Read_relocs::is_runnable(Workqueue*)
  42 {
  43   return this->object_->is_locked() ? IS_LOCKED : IS_RUNNABLE;
  44 }
  45
  46 // Lock the file.
  47
  48 Task_locker*
  49 Read_relocs::locks(Workqueue*)
  50 {
  51   return new Task_locker_obj<Object>(*this->object_);
  52 }
  53
  54 // Read the relocations and then start a Scan_relocs_task.
  55
  56 void
  57 Read_relocs::run(Workqueue* workqueue)
  58 {
  59   Read_relocs_data *rd = new Read_relocs_data;
  60   this->object_->read_relocs(rd);
  61   workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_,
  62                                          this->layout_, this->object_, rd,
  63                                          this->symtab_lock_, this->blocker_));
  64 }
  65
  66 // Scan_relocs methods.
  67
  68 // These tasks scan the relocations read by Read_relocs and mark up
  69 // the symbol table to indicate which relocations are required.  We
  70 // use a lock on the symbol table to keep them from interfering with
  71 // each other.
  72
  73 Task::Is_runnable_type
  74 Scan_relocs::is_runnable(Workqueue*)
  75 {
  76   if (!this->symtab_lock_->is_writable() || this->object_->is_locked())
  77     return IS_LOCKED;
  78   return IS_RUNNABLE;
  79 }
  80
  81 // Return the locks we hold: one on the file, one on the symbol table
  82 // and one blocker.
  83
  84 class Scan_relocs::Scan_relocs_locker : public Task_locker
  85 {
  86  public:
  87   Scan_relocs_locker(Object* object, Task_token& symtab_lock, Task* task,
  88                      Task_token& blocker, Workqueue* workqueue)
  89     : objlock_(*object), symtab_locker_(symtab_lock, task),
  90       blocker_(blocker, workqueue)
  91   { }
  92
  93  private:
  94   Task_locker_obj<Object> objlock_;
  95   Task_locker_write symtab_locker_;
  96   Task_locker_block blocker_;
  97 };
  98
  99 Task_locker*
 100 Scan_relocs::locks(Workqueue* workqueue)
 101 {
 102   return new Scan_relocs_locker(this->object_, *this->symtab_lock_, this,
 103                                 *this->blocker_, workqueue);
 104 }
 105
 106 // Scan the relocs.
 107
 108 void
 109 Scan_relocs::run(Workqueue*)
 110 {
 111   this->object_->scan_relocs(this->options_, this->symtab_, this->layout_,
 112                              this->rd_);
 113   delete this->rd_;
 114   this->rd_ = NULL;
 115 }
 116
 117 // Relocate_task methods.
 118
 119 // We may have to wait for the output sections to be written.
 120
 121 Task::Is_runnable_type
 122 Relocate_task::is_runnable(Workqueue*)
 123 {
 124   if (this->object_->relocs_must_follow_section_writes()
 125       && this->output_sections_blocker_->is_blocked())
 126     return IS_BLOCKED;
 127
 128   return IS_RUNNABLE;
 129 }
 130
 131 // We want to lock the file while we run.  We want to unblock
 132 // INPUT_SECTIONS_BLOCKER and FINAL_BLOCKER when we are done.
 133
 134 class Relocate_task::Relocate_locker : public Task_locker
 135 {
 136  public:
 137   Relocate_locker(Task_token& input_sections_blocker,
 138                   Task_token& final_blocker, Workqueue* workqueue,
 139                   Object* object)
 140     : input_sections_blocker_(input_sections_blocker, workqueue),
 141       final_blocker_(final_blocker, workqueue),
 142       objlock_(*object)
 143   { }
 144
 145  private:
 146   Task_block_token input_sections_blocker_;
 147   Task_block_token final_blocker_;
 148   Task_locker_obj<Object> objlock_;
 149 };
 150
 151 Task_locker*
 152 Relocate_task::locks(Workqueue* workqueue)
 153 {
 154   return new Relocate_locker(*this->input_sections_blocker_,
 155                              *this->final_blocker_,
 156                              workqueue,
 157                              this->object_);
 158 }
 159
 160 // Run the task.
 161
 162 void
 163 Relocate_task::run(Workqueue*)
 164 {
 165   this->object_->relocate(this->options_, this->symtab_, this->layout_,
 166                           this->of_);
 167 }
 168
 169 // Read the relocs and local symbols from the object file and store
 170 // the information in RD.
 171
 172 template<int size, bool big_endian>
 173 void
 174 Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
 175 {
 176   rd->relocs.clear();
 177
 178   unsigned int shnum = this->shnum();
 179   if (shnum == 0)
 180     return;
 181
 182   rd->relocs.reserve(shnum / 2);
 183
 184   std::vector<Map_to_output>& map_sections(this->map_to_output());
 185
 186   const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(),
 187                                                shnum * This::shdr_size,
 188                                                true);
 189   // Skip the first, dummy, section.
 190   const unsigned char *ps = pshdrs + This::shdr_size;
 191   for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size)
 192     {
 193       typename This::Shdr shdr(ps);
 194
 195       unsigned int sh_type = shdr.get_sh_type();
 196       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 197         continue;
 198
 199       unsigned int shndx = shdr.get_sh_info();
 200       if (shndx >= shnum)
 201         {
 202           this->error(_("relocation section %u has bad info %u"),
 203                       i, shndx);
 204           continue;
 205         }
 206
 207       Output_section* os = map_sections[shndx].output_section;
 208       if (os == NULL)
 209         continue;
 210
 211       // We are scanning relocations in order to fill out the GOT and
 212       // PLT sections.  Relocations for sections which are not
 213       // allocated (typically debugging sections) should not add new
 214       // GOT and PLT entries.  So we skip them.
 215       typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size);
 216       if ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
 217         continue;
 218
 219       if (shdr.get_sh_link() != this->symtab_shndx_)
 220         {
 221           this->error(_("relocation section %u uses unexpected "
 222                         "symbol table %u"),
 223                       i, shdr.get_sh_link());
 224           continue;
 225         }
 226
 227       off_t sh_size = shdr.get_sh_size();
 228
 229       unsigned int reloc_size;
 230       if (sh_type == elfcpp::SHT_REL)
 231         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 232       else
 233         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 234       if (reloc_size != shdr.get_sh_entsize())
 235         {
 236           this->error(_("unexpected entsize for reloc section %u: %lu != %u"),
 237                       i, static_cast<unsigned long>(shdr.get_sh_entsize()),
 238                       reloc_size);
 239           continue;
 240         }
 241
 242       size_t reloc_count = sh_size / reloc_size;
 243       if (static_cast<off_t>(reloc_count * reloc_size) != sh_size)
 244         {
 245           this->error(_("reloc section %u size %lu uneven"),
 246                       i, static_cast<unsigned long>(sh_size));
 247           continue;
 248         }
 249
 250       rd->relocs.push_back(Section_relocs());
 251       Section_relocs& sr(rd->relocs.back());
 252       sr.reloc_shndx = i;
 253       sr.data_shndx = shndx;
 254       sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size,
 255                                            true);
 256       sr.sh_type = sh_type;
 257       sr.reloc_count = reloc_count;
 258       sr.output_section = os;
 259       sr.needs_special_offset_handling = map_sections[shndx].offset == -1;
 260     }
 261
 262   // Read the local symbols.
 263   gold_assert(this->symtab_shndx_ != -1U);
 264   if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0)
 265     rd->local_symbols = NULL;
 266   else
 267     {
 268       typename This::Shdr symtabshdr(pshdrs
 269                                      + this->symtab_shndx_ * This::shdr_size);
 270       gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 271       const int sym_size = This::sym_size;
 272       const unsigned int loccount = this->local_symbol_count_;
 273       gold_assert(loccount == symtabshdr.get_sh_info());
 274       off_t locsize = loccount * sym_size;
 275       rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(),
 276                                                  locsize, true);
 277     }
 278 }
 279
 280 // Scan the relocs and adjust the symbol table.  This looks for
 281 // relocations which require GOT/PLT/COPY relocations.
 282
 283 template<int size, bool big_endian>
 284 void
 285 Sized_relobj<size, big_endian>::do_scan_relocs(const General_options& options,
 286                                                Symbol_table* symtab,
 287                                                Layout* layout,
 288                                                Read_relocs_data* rd)
 289 {
 290   Sized_target<size, big_endian>* target = this->sized_target();
 291
 292   const unsigned char* local_symbols;
 293   if (rd->local_symbols == NULL)
 294     local_symbols = NULL;
 295   else
 296     local_symbols = rd->local_symbols->data();
 297
 298   for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();
 299        p != rd->relocs.end();
 300        ++p)
 301     {
 302       target->scan_relocs(options, symtab, layout, this, p->data_shndx,
 303                           p->sh_type, p->contents->data(), p->reloc_count,
 304                           p->output_section, p->needs_special_offset_handling,
 305                           this->local_symbol_count_,
 306                           local_symbols);
 307       delete p->contents;
 308       p->contents = NULL;
 309     }
 310
 311   if (rd->local_symbols != NULL)
 312     {
 313       delete rd->local_symbols;
 314       rd->local_symbols = NULL;
 315     }
 316 }
 317
 318 // Relocate the input sections and write out the local symbols.
 319
 320 template<int size, bool big_endian>
 321 void
 322 Sized_relobj<size, big_endian>::do_relocate(const General_options& options,
 323                                             const Symbol_table* symtab,
 324                                             const Layout* layout,
 325                                             Output_file* of)
 326 {
 327   unsigned int shnum = this->shnum();
 328
 329   // Read the section headers.
 330   const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),
 331                                                shnum * This::shdr_size,
 332                                                true);
 333
 334   Views views;
 335   views.resize(shnum);
 336
 337   // Make two passes over the sections.  The first one copies the
 338   // section data to the output file.  The second one applies
 339   // relocations.
 340
 341   this->write_sections(pshdrs, of, &views);
 342
 343   // Apply relocations.
 344
 345   this->relocate_sections(options, symtab, layout, pshdrs, &views);
 346
 347   // Write out the accumulated views.
 348   for (unsigned int i = 1; i < shnum; ++i)
 349     {
 350       if (views[i].view != NULL)
 351         {
 352           if (views[i].is_input_output_view)
 353             of->write_input_output_view(views[i].offset, views[i].view_size,
 354                                         views[i].view);
 355           else
 356             of->write_output_view(views[i].offset, views[i].view_size,
 357                                   views[i].view);
 358         }
 359     }
 360
 361   // Write out the local symbols.
 362   this->write_local_symbols(of, layout->sympool());
 363 }
 364
 365 // Write section data to the output file.  PSHDRS points to the
 366 // section headers.  Record the views in *PVIEWS for use when
 367 // relocating.
 368
 369 template<int size, bool big_endian>
 370 void
 371 Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
 372                                                Output_file* of,
 373                                                Views* pviews)
 374 {
 375   unsigned int shnum = this->shnum();
 376   std::vector<Map_to_output>& map_sections(this->map_to_output());
 377
 378   const unsigned char* p = pshdrs + This::shdr_size;
 379   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 380     {
 381       View_size* pvs = &(*pviews)[i];
 382
 383       pvs->view = NULL;
 384
 385       const Output_section* os = map_sections[i].output_section;
 386       if (os == NULL)
 387         continue;
 388       off_t output_offset = map_sections[i].offset;
 389
 390       typename This::Shdr shdr(p);
 391
 392       if (shdr.get_sh_type() == elfcpp::SHT_NOBITS)
 393         continue;
 394
 395       off_t view_start;
 396       off_t view_size;
 397       if (output_offset != -1)
 398         {
 399           view_start = os->offset() + output_offset;
 400           view_size = shdr.get_sh_size();
 401         }
 402       else
 403         {
 404           view_start = os->offset();
 405           view_size = os->data_size();
 406         }
 407
 408       if (view_size == 0)
 409         continue;
 410
 411       gold_assert(output_offset == -1
 412                   || (output_offset >= 0
 413                       && output_offset + view_size <= os->data_size()));
 414
 415       unsigned char* view;
 416       if (output_offset == -1)
 417         view = of->get_input_output_view(view_start, view_size);
 418       else
 419         {
 420           view = of->get_output_view(view_start, view_size);
 421           this->read(shdr.get_sh_offset(), view_size, view);
 422         }
 423
 424       pvs->view = view;
 425       pvs->address = os->address();
 426       if (output_offset != -1)
 427         pvs->address += output_offset;
 428       pvs->offset = view_start;
 429       pvs->view_size = view_size;
 430       pvs->is_input_output_view = output_offset == -1;
 431     }
 432 }
 433
 434 // Relocate section data.  VIEWS points to the section data as views
 435 // in the output file.
 436
 437 template<int size, bool big_endian>
 438 void
 439 Sized_relobj<size, big_endian>::relocate_sections(
 440     const General_options& options,
 441     const Symbol_table* symtab,
 442     const Layout* layout,
 443     const unsigned char* pshdrs,
 444     Views* pviews)
 445 {
 446   unsigned int shnum = this->shnum();
 447   Sized_target<size, big_endian>* target = this->sized_target();
 448
 449   std::vector<Map_to_output>& map_sections(this->map_to_output());
 450
 451   Relocate_info<size, big_endian> relinfo;
 452   relinfo.options = &options;
 453   relinfo.symtab = symtab;
 454   relinfo.layout = layout;
 455   relinfo.object = this;
 456
 457   const unsigned char* p = pshdrs + This::shdr_size;
 458   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 459     {
 460       typename This::Shdr shdr(p);
 461
 462       unsigned int sh_type = shdr.get_sh_type();
 463       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 464         continue;
 465
 466       unsigned int index = shdr.get_sh_info();
 467       if (index >= this->shnum())
 468         {
 469           this->error(_("relocation section %u has bad info %u"),
 470                       i, index);
 471           continue;
 472         }
 473
 474       Output_section* os = map_sections[index].output_section;
 475       if (os == NULL)
 476         {
 477           // This relocation section is against a section which we
 478           // discarded.
 479           continue;
 480         }
 481       off_t output_offset = map_sections[index].offset;
 482
 483       gold_assert((*pviews)[index].view != NULL);
 484
 485       if (shdr.get_sh_link() != this->symtab_shndx_)
 486         {
 487           gold_error(_("relocation section %u uses unexpected "
 488                        "symbol table %u"),
 489                      i, shdr.get_sh_link());
 490           continue;
 491         }
 492
 493       off_t sh_size = shdr.get_sh_size();
 494       const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(),
 495                                                     sh_size, false);
 496
 497       unsigned int reloc_size;
 498       if (sh_type == elfcpp::SHT_REL)
 499         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 500       else
 501         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 502
 503       if (reloc_size != shdr.get_sh_entsize())
 504         {
 505           gold_error(_("unexpected entsize for reloc section %u: %lu != %u"),
 506                      i, static_cast<unsigned long>(shdr.get_sh_entsize()),
 507                      reloc_size);
 508           continue;
 509         }
 510
 511       size_t reloc_count = sh_size / reloc_size;
 512       if (static_cast<off_t>(reloc_count * reloc_size) != sh_size)
 513         {
 514           gold_error(_("reloc section %u size %lu uneven"),
 515                      i, static_cast<unsigned long>(sh_size));
 516           continue;
 517         }
 518
 519       relinfo.reloc_shndx = i;
 520       relinfo.data_shndx = index;
 521       target->relocate_section(&relinfo,
 522                                sh_type,
 523                                prelocs,
 524                                reloc_count,
 525                                os,
 526                                output_offset == -1,
 527                                (*pviews)[index].view,
 528                                (*pviews)[index].address,
 529                                (*pviews)[index].view_size);
 530     }
 531 }
 532
 533 // Copy_relocs::Copy_reloc_entry methods.
 534
 535 // Return whether we should emit this reloc.  We should emit it if the
 536 // symbol is still defined in a dynamic object.  If we should not emit
 537 // it, we clear it, to save ourselves the test next time.
 538
 539 template<int size, bool big_endian>
 540 bool
 541 Copy_relocs<size, big_endian>::Copy_reloc_entry::should_emit()
 542 {
 543   if (this->sym_ == NULL)
 544     return false;
 545   if (this->sym_->is_from_dynobj())
 546     return true;
 547   this->sym_ = NULL;
 548   return false;
 549 }
 550
 551 // Emit a reloc into a SHT_REL section.
 552
 553 template<int size, bool big_endian>
 554 void
 555 Copy_relocs<size, big_endian>::Copy_reloc_entry::emit(
 556     Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>* reloc_data)
 557 {
 558   this->sym_->set_needs_dynsym_entry();
 559   reloc_data->add_global(this->sym_, this->reloc_type_, this->relobj_,
 560                          this->shndx_, this->address_);
 561 }
 562
 563 // Emit a reloc into a SHT_RELA section.
 564
 565 template<int size, bool big_endian>
 566 void
 567 Copy_relocs<size, big_endian>::Copy_reloc_entry::emit(
 568     Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>* reloc_data)
 569 {
 570   this->sym_->set_needs_dynsym_entry();
 571   reloc_data->add_global(this->sym_, this->reloc_type_, this->relobj_,
 572                          this->shndx_, this->address_, this->addend_);
 573 }
 574
 575 // Copy_relocs methods.
 576
 577 // Return whether we need a COPY reloc for a relocation against GSYM.
 578 // The relocation is being applied to section SHNDX in OBJECT.
 579
 580 template<int size, bool big_endian>
 581 bool
 582 Copy_relocs<size, big_endian>::need_copy_reloc(
 583     const General_options*,
 584     Relobj* object,
 585     unsigned int shndx,
 586     Sized_symbol<size>* sym)
 587 {
 588   // FIXME: Handle -z nocopyrelocs.
 589
 590   if (sym->symsize() == 0)
 591     return false;
 592
 593   // If this is a readonly section, then we need a COPY reloc.
 594   // Otherwise we can use a dynamic reloc.
 595   if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
 596     return true;
 597
 598   return false;
 599 }
 600
 601 // Save a Rel reloc.
 602
 603 template<int size, bool big_endian>
 604 void
 605 Copy_relocs<size, big_endian>::save(
 606     Symbol* sym,
 607     Relobj* relobj,
 608     unsigned int shndx,
 609     const elfcpp::Rel<size, big_endian>& rel)
 610 {
 611   unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info());
 612   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx,
 613                                             rel.get_r_offset(), 0));
 614 }
 615
 616 // Save a Rela reloc.
 617
 618 template<int size, bool big_endian>
 619 void
 620 Copy_relocs<size, big_endian>::save(
 621     Symbol* sym,
 622     Relobj* relobj,
 623     unsigned int shndx,
 624     const elfcpp::Rela<size, big_endian>& rela)
 625 {
 626   unsigned int reloc_type = elfcpp::elf_r_type<size>(rela.get_r_info());
 627   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx,
 628                                             rela.get_r_offset(),
 629                                             rela.get_r_addend()));
 630 }
 631
 632 // Return whether there are any relocs to emit.  We don't want to emit
 633 // a reloc if the symbol is no longer defined in a dynamic object.
 634
 635 template<int size, bool big_endian>
 636 bool
 637 Copy_relocs<size, big_endian>::any_to_emit()
 638 {
 639   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 640        p != this->entries_.end();
 641        ++p)
 642     {
 643       if (p->should_emit())
 644         return true;
 645     }
 646   return false;
 647 }
 648
 649 // Emit relocs.
 650
 651 template<int size, bool big_endian>
 652 template<int sh_type>
 653 void
 654 Copy_relocs<size, big_endian>::emit(
 655     Output_data_reloc<sh_type, true, size, big_endian>* reloc_data)
 656 {
 657   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 658        p != this->entries_.end();
 659        ++p)
 660     {
 661       if (p->should_emit())
 662         p->emit(reloc_data);
 663     }
 664 }
 665
 666 // Track_relocs methods.
 667
 668 // Initialize the class to track the relocs.  This gets the object,
 669 // the reloc section index, and the type of the relocs.  This returns
 670 // false if something goes wrong.
 671
 672 template<int size, bool big_endian>
 673 bool
 674 Track_relocs<size, big_endian>::initialize(
 675     Sized_relobj<size, big_endian>* object,
 676     unsigned int reloc_shndx,
 677     unsigned int reloc_type)
 678 {
 679   this->object_ = object;
 680
 681   // If RELOC_SHNDX is -1U, it means there is more than one reloc
 682   // section for the .eh_frame section.  We can't handle that case.
 683   if (reloc_shndx == -1U)
 684     return false;
 685
 686   // If RELOC_SHNDX is 0, there is no reloc section.
 687   if (reloc_shndx == 0)
 688     return true;
 689
 690   // Get the contents of the reloc section.
 691   this->prelocs_ = object->section_contents(reloc_shndx, &this->len_, false);
 692
 693   if (reloc_type == elfcpp::SHT_REL)
 694     this->reloc_size_ = elfcpp::Elf_sizes<size>::rel_size;
 695   else if (reloc_type == elfcpp::SHT_RELA)
 696     this->reloc_size_ = elfcpp::Elf_sizes<size>::rela_size;
 697   else
 698     gold_unreachable();
 699
 700   if (this->len_ % this->reloc_size_ != 0)
 701     {
 702       object->error(_("reloc section size %zu is not a multiple of "
 703                       "reloc size %d\n"),
 704                     static_cast<size_t>(this->len_),
 705                     this->reloc_size_);
 706       return false;
 707     }
 708
 709   return true;
 710 }
 711
 712 // Return the offset of the next reloc, or -1 if there isn't one.
 713
 714 template<int size, bool big_endian>
 715 off_t
 716 Track_relocs<size, big_endian>::next_offset() const
 717 {
 718   if (this->pos_ >= this->len_)
 719     return -1;
 720
 721   // Rel and Rela start out the same, so we can always use Rel to find
 722   // the r_offset value.
 723   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
 724   return rel.get_r_offset();
 725 }
 726
 727 // Return the index of the symbol referenced by the next reloc, or -1U
 728 // if there aren't any more relocs.
 729
 730 template<int size, bool big_endian>
 731 unsigned int
 732 Track_relocs<size, big_endian>::next_symndx() const
 733 {
 734   if (this->pos_ >= this->len_)
 735     return -1U;
 736
 737   // Rel and Rela start out the same, so we can use Rel to find the
 738   // symbol index.
 739   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
 740   return elfcpp::elf_r_sym<size>(rel.get_r_info());
 741 }
 742
 743 // Advance to the next reloc whose r_offset is greater than or equal
 744 // to OFFSET.  Return the number of relocs we skip.
 745
 746 template<int size, bool big_endian>
 747 int
 748 Track_relocs<size, big_endian>::advance(off_t offset)
 749 {
 750   int ret = 0;
 751   while (this->pos_ < this->len_)
 752     {
 753       // Rel and Rela start out the same, so we can always use Rel to
 754       // find the r_offset value.
 755       elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
 756       if (static_cast<off_t>(rel.get_r_offset()) >= offset)
 757         break;
 758       ++ret;
 759       this->pos_ += this->reloc_size_;
 760     }
 761   return ret;
 762 }
 763
 764 // Instantiate the templates we need.  We could use the configure
 765 // script to restrict this to only the ones for implemented targets.
 766
 767 #ifdef HAVE_TARGET_32_LITTLE
 768 template
 769 void
 770 Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
 771 #endif
 772
 773 #ifdef HAVE_TARGET_32_BIG
 774 template
 775 void
 776 Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
 777 #endif
 778
 779 #ifdef HAVE_TARGET_64_LITTLE
 780 template
 781 void
 782 Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
 783 #endif
 784
 785 #ifdef HAVE_TARGET_64_BIG
 786 template
 787 void
 788 Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
 789 #endif
 790
 791 #ifdef HAVE_TARGET_32_LITTLE
 792 template
 793 void
 794 Sized_relobj<32, false>::do_scan_relocs(const General_options& options,
 795                                         Symbol_table* symtab,
 796                                         Layout* layout,
 797                                         Read_relocs_data* rd);
 798 #endif
 799
 800 #ifdef HAVE_TARGET_32_BIG
 801 template
 802 void
 803 Sized_relobj<32, true>::do_scan_relocs(const General_options& options,
 804                                        Symbol_table* symtab,
 805                                        Layout* layout,
 806                                        Read_relocs_data* rd);
 807 #endif
 808
 809 #ifdef HAVE_TARGET_64_LITTLE
 810 template
 811 void
 812 Sized_relobj<64, false>::do_scan_relocs(const General_options& options,
 813                                         Symbol_table* symtab,
 814                                         Layout* layout,
 815                                         Read_relocs_data* rd);
 816 #endif
 817
 818 #ifdef HAVE_TARGET_64_BIG
 819 template
 820 void
 821 Sized_relobj<64, true>::do_scan_relocs(const General_options& options,
 822                                        Symbol_table* symtab,
 823                                        Layout* layout,
 824                                        Read_relocs_data* rd);
 825 #endif
 826
 827 #ifdef HAVE_TARGET_32_LITTLE
 828 template
 829 void
 830 Sized_relobj<32, false>::do_relocate(const General_options& options,
 831                                      const Symbol_table* symtab,
 832                                      const Layout* layout,
 833                                      Output_file* of);
 834 #endif
 835
 836 #ifdef HAVE_TARGET_32_BIG
 837 template
 838 void
 839 Sized_relobj<32, true>::do_relocate(const General_options& options,
 840                                     const Symbol_table* symtab,
 841                                     const Layout* layout,
 842                                     Output_file* of);
 843 #endif
 844
 845 #ifdef HAVE_TARGET_64_LITTLE
 846 template
 847 void
 848 Sized_relobj<64, false>::do_relocate(const General_options& options,
 849                                      const Symbol_table* symtab,
 850                                      const Layout* layout,
 851                                      Output_file* of);
 852 #endif
 853
 854 #ifdef HAVE_TARGET_64_BIG
 855 template
 856 void
 857 Sized_relobj<64, true>::do_relocate(const General_options& options,
 858                                     const Symbol_table* symtab,
 859                                     const Layout* layout,
 860                                     Output_file* of);
 861 #endif
 862
 863 #ifdef HAVE_TARGET_32_LITTLE
 864 template
 865 class Copy_relocs<32, false>;
 866 #endif
 867
 868 #ifdef HAVE_TARGET_32_BIG
 869 template
 870 class Copy_relocs<32, true>;
 871 #endif
 872
 873 #ifdef HAVE_TARGET_64_LITTLE
 874 template
 875 class Copy_relocs<64, false>;
 876 #endif
 877
 878 #ifdef HAVE_TARGET_64_BIG
 879 template
 880 class Copy_relocs<64, true>;
 881 #endif
 882
 883 #ifdef HAVE_TARGET_32_LITTLE
 884 template
 885 void
 886 Copy_relocs<32, false>::emit<elfcpp::SHT_REL>(
 887     Output_data_reloc<elfcpp::SHT_REL, true, 32, false>*);
 888 #endif
 889
 890 #ifdef HAVE_TARGET_32_BIG
 891 template
 892 void
 893 Copy_relocs<32, true>::emit<elfcpp::SHT_REL>(
 894     Output_data_reloc<elfcpp::SHT_REL, true, 32, true>*);
 895 #endif
 896
 897 #ifdef HAVE_TARGET_64_LITTLE
 898 template
 899 void
 900 Copy_relocs<64, false>::emit<elfcpp::SHT_REL>(
 901     Output_data_reloc<elfcpp::SHT_REL, true, 64, false>*);
 902 #endif
 903
 904 #ifdef HAVE_TARGET_64_BIG
 905 template
 906 void
 907 Copy_relocs<64, true>::emit<elfcpp::SHT_REL>(
 908     Output_data_reloc<elfcpp::SHT_REL, true, 64, true>*);
 909 #endif
 910
 911 #ifdef HAVE_TARGET_32_LITTLE
 912 template
 913 void
 914 Copy_relocs<32, false>::emit<elfcpp::SHT_RELA>(
 915     Output_data_reloc<elfcpp::SHT_RELA , true, 32, false>*);
 916 #endif
 917
 918 #ifdef HAVE_TARGET_32_BIG
 919 template
 920 void
 921 Copy_relocs<32, true>::emit<elfcpp::SHT_RELA>(
 922     Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>*);
 923 #endif
 924
 925 #ifdef HAVE_TARGET_64_LITTLE
 926 template
 927 void
 928 Copy_relocs<64, false>::emit<elfcpp::SHT_RELA>(
 929     Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>*);
 930 #endif
 931
 932 #ifdef HAVE_TARGET_64_BIG
 933 template
 934 void
 935 Copy_relocs<64, true>::emit<elfcpp::SHT_RELA>(
 936     Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>*);
 937 #endif
 938
 939 #ifdef HAVE_TARGET_32_LITTLE
 940 template
 941 class Track_relocs<32, false>;
 942 #endif
 943
 944 #ifdef HAVE_TARGET_32_BIG
 945 template
 946 class Track_relocs<32, true>;
 947 #endif
 948
 949 #ifdef HAVE_TARGET_64_LITTLE
 950 template
 951 class Track_relocs<64, false>;
 952 #endif
 953
 954 #ifdef HAVE_TARGET_64_BIG
 955 template
 956 class Track_relocs<64, true>;
 957 #endif
 958
 959 } // End namespace gold.