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->output_section_,
 560                          this->relobj_, 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->output_section_,
 572                          this->relobj_, this->shndx_, this->address_,
 573                          this->addend_);
 574 }
 575
 576 // Copy_relocs methods.
 577
 578 // Return whether we need a COPY reloc for a relocation against GSYM.
 579 // The relocation is being applied to section SHNDX in OBJECT.
 580
 581 template<int size, bool big_endian>
 582 bool
 583 Copy_relocs<size, big_endian>::need_copy_reloc(
 584     const General_options*,
 585     Relobj* object,
 586     unsigned int shndx,
 587     Sized_symbol<size>* sym)
 588 {
 589   // FIXME: Handle -z nocopyrelocs.
 590
 591   if (sym->symsize() == 0)
 592     return false;
 593
 594   // If this is a readonly section, then we need a COPY reloc.
 595   // Otherwise we can use a dynamic reloc.
 596   if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
 597     return true;
 598
 599   return false;
 600 }
 601
 602 // Save a Rel reloc.
 603
 604 template<int size, bool big_endian>
 605 void
 606 Copy_relocs<size, big_endian>::save(
 607     Symbol* sym,
 608     Relobj* relobj,
 609     unsigned int shndx,
 610     Output_section* output_section,
 611     const elfcpp::Rel<size, big_endian>& rel)
 612 {
 613   unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info());
 614   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx,
 615                                             output_section,
 616                                             rel.get_r_offset(), 0));
 617 }
 618
 619 // Save a Rela reloc.
 620
 621 template<int size, bool big_endian>
 622 void
 623 Copy_relocs<size, big_endian>::save(
 624     Symbol* sym,
 625     Relobj* relobj,
 626     unsigned int shndx,
 627     Output_section* output_section,
 628     const elfcpp::Rela<size, big_endian>& rela)
 629 {
 630   unsigned int reloc_type = elfcpp::elf_r_type<size>(rela.get_r_info());
 631   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx,
 632                                             output_section,
 633                                             rela.get_r_offset(),
 634                                             rela.get_r_addend()));
 635 }
 636
 637 // Return whether there are any relocs to emit.  We don't want to emit
 638 // a reloc if the symbol is no longer defined in a dynamic object.
 639
 640 template<int size, bool big_endian>
 641 bool
 642 Copy_relocs<size, big_endian>::any_to_emit()
 643 {
 644   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 645        p != this->entries_.end();
 646        ++p)
 647     {
 648       if (p->should_emit())
 649         return true;
 650     }
 651   return false;
 652 }
 653
 654 // Emit relocs.
 655
 656 template<int size, bool big_endian>
 657 template<int sh_type>
 658 void
 659 Copy_relocs<size, big_endian>::emit(
 660     Output_data_reloc<sh_type, true, size, big_endian>* reloc_data)
 661 {
 662   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 663        p != this->entries_.end();
 664        ++p)
 665     {
 666       if (p->should_emit())
 667         p->emit(reloc_data);
 668     }
 669 }
 670
 671 // Track_relocs methods.
 672
 673 // Initialize the class to track the relocs.  This gets the object,
 674 // the reloc section index, and the type of the relocs.  This returns
 675 // false if something goes wrong.
 676
 677 template<int size, bool big_endian>
 678 bool
 679 Track_relocs<size, big_endian>::initialize(
 680     Object* object,
 681     unsigned int reloc_shndx,
 682     unsigned int reloc_type)
 683 {
 684   // If RELOC_SHNDX is -1U, it means there is more than one reloc
 685   // section for the .eh_frame section.  We can't handle that case.
 686   if (reloc_shndx == -1U)
 687     return false;
 688
 689   // If RELOC_SHNDX is 0, there is no reloc section.
 690   if (reloc_shndx == 0)
 691     return true;
 692
 693   // Get the contents of the reloc section.
 694   this->prelocs_ = object->section_contents(reloc_shndx, &this->len_, false);
 695
 696   if (reloc_type == elfcpp::SHT_REL)
 697     this->reloc_size_ = elfcpp::Elf_sizes<size>::rel_size;
 698   else if (reloc_type == elfcpp::SHT_RELA)
 699     this->reloc_size_ = elfcpp::Elf_sizes<size>::rela_size;
 700   else
 701     gold_unreachable();
 702
 703   if (this->len_ % this->reloc_size_ != 0)
 704     {
 705       object->error(_("reloc section size %zu is not a multiple of "
 706                       "reloc size %d\n"),
 707                     static_cast<size_t>(this->len_),
 708                     this->reloc_size_);
 709       return false;
 710     }
 711
 712   return true;
 713 }
 714
 715 // Return the offset of the next reloc, or -1 if there isn't one.
 716
 717 template<int size, bool big_endian>
 718 off_t
 719 Track_relocs<size, big_endian>::next_offset() const
 720 {
 721   if (this->pos_ >= this->len_)
 722     return -1;
 723
 724   // Rel and Rela start out the same, so we can always use Rel to find
 725   // the r_offset value.
 726   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
 727   return rel.get_r_offset();
 728 }
 729
 730 // Return the index of the symbol referenced by the next reloc, or -1U
 731 // if there aren't any more relocs.
 732
 733 template<int size, bool big_endian>
 734 unsigned int
 735 Track_relocs<size, big_endian>::next_symndx() const
 736 {
 737   if (this->pos_ >= this->len_)
 738     return -1U;
 739
 740   // Rel and Rela start out the same, so we can use Rel to find the
 741   // symbol index.
 742   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
 743   return elfcpp::elf_r_sym<size>(rel.get_r_info());
 744 }
 745
 746 // Advance to the next reloc whose r_offset is greater than or equal
 747 // to OFFSET.  Return the number of relocs we skip.
 748
 749 template<int size, bool big_endian>
 750 int
 751 Track_relocs<size, big_endian>::advance(off_t offset)
 752 {
 753   int ret = 0;
 754   while (this->pos_ < this->len_)
 755     {
 756       // Rel and Rela start out the same, so we can always use Rel to
 757       // find the r_offset value.
 758       elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
 759       if (static_cast<off_t>(rel.get_r_offset()) >= offset)
 760         break;
 761       ++ret;
 762       this->pos_ += this->reloc_size_;
 763     }
 764   return ret;
 765 }
 766
 767 // Instantiate the templates we need.  We could use the configure
 768 // script to restrict this to only the ones for implemented targets.
 769
 770 #ifdef HAVE_TARGET_32_LITTLE
 771 template
 772 void
 773 Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
 774 #endif
 775
 776 #ifdef HAVE_TARGET_32_BIG
 777 template
 778 void
 779 Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
 780 #endif
 781
 782 #ifdef HAVE_TARGET_64_LITTLE
 783 template
 784 void
 785 Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
 786 #endif
 787
 788 #ifdef HAVE_TARGET_64_BIG
 789 template
 790 void
 791 Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
 792 #endif
 793
 794 #ifdef HAVE_TARGET_32_LITTLE
 795 template
 796 void
 797 Sized_relobj<32, false>::do_scan_relocs(const General_options& options,
 798                                         Symbol_table* symtab,
 799                                         Layout* layout,
 800                                         Read_relocs_data* rd);
 801 #endif
 802
 803 #ifdef HAVE_TARGET_32_BIG
 804 template
 805 void
 806 Sized_relobj<32, true>::do_scan_relocs(const General_options& options,
 807                                        Symbol_table* symtab,
 808                                        Layout* layout,
 809                                        Read_relocs_data* rd);
 810 #endif
 811
 812 #ifdef HAVE_TARGET_64_LITTLE
 813 template
 814 void
 815 Sized_relobj<64, false>::do_scan_relocs(const General_options& options,
 816                                         Symbol_table* symtab,
 817                                         Layout* layout,
 818                                         Read_relocs_data* rd);
 819 #endif
 820
 821 #ifdef HAVE_TARGET_64_BIG
 822 template
 823 void
 824 Sized_relobj<64, true>::do_scan_relocs(const General_options& options,
 825                                        Symbol_table* symtab,
 826                                        Layout* layout,
 827                                        Read_relocs_data* rd);
 828 #endif
 829
 830 #ifdef HAVE_TARGET_32_LITTLE
 831 template
 832 void
 833 Sized_relobj<32, false>::do_relocate(const General_options& options,
 834                                      const Symbol_table* symtab,
 835                                      const Layout* layout,
 836                                      Output_file* of);
 837 #endif
 838
 839 #ifdef HAVE_TARGET_32_BIG
 840 template
 841 void
 842 Sized_relobj<32, true>::do_relocate(const General_options& options,
 843                                     const Symbol_table* symtab,
 844                                     const Layout* layout,
 845                                     Output_file* of);
 846 #endif
 847
 848 #ifdef HAVE_TARGET_64_LITTLE
 849 template
 850 void
 851 Sized_relobj<64, false>::do_relocate(const General_options& options,
 852                                      const Symbol_table* symtab,
 853                                      const Layout* layout,
 854                                      Output_file* of);
 855 #endif
 856
 857 #ifdef HAVE_TARGET_64_BIG
 858 template
 859 void
 860 Sized_relobj<64, true>::do_relocate(const General_options& options,
 861                                     const Symbol_table* symtab,
 862                                     const Layout* layout,
 863                                     Output_file* of);
 864 #endif
 865
 866 #ifdef HAVE_TARGET_32_LITTLE
 867 template
 868 class Copy_relocs<32, false>;
 869 #endif
 870
 871 #ifdef HAVE_TARGET_32_BIG
 872 template
 873 class Copy_relocs<32, true>;
 874 #endif
 875
 876 #ifdef HAVE_TARGET_64_LITTLE
 877 template
 878 class Copy_relocs<64, false>;
 879 #endif
 880
 881 #ifdef HAVE_TARGET_64_BIG
 882 template
 883 class Copy_relocs<64, true>;
 884 #endif
 885
 886 #ifdef HAVE_TARGET_32_LITTLE
 887 template
 888 void
 889 Copy_relocs<32, false>::emit<elfcpp::SHT_REL>(
 890     Output_data_reloc<elfcpp::SHT_REL, true, 32, false>*);
 891 #endif
 892
 893 #ifdef HAVE_TARGET_32_BIG
 894 template
 895 void
 896 Copy_relocs<32, true>::emit<elfcpp::SHT_REL>(
 897     Output_data_reloc<elfcpp::SHT_REL, true, 32, true>*);
 898 #endif
 899
 900 #ifdef HAVE_TARGET_64_LITTLE
 901 template
 902 void
 903 Copy_relocs<64, false>::emit<elfcpp::SHT_REL>(
 904     Output_data_reloc<elfcpp::SHT_REL, true, 64, false>*);
 905 #endif
 906
 907 #ifdef HAVE_TARGET_64_BIG
 908 template
 909 void
 910 Copy_relocs<64, true>::emit<elfcpp::SHT_REL>(
 911     Output_data_reloc<elfcpp::SHT_REL, true, 64, true>*);
 912 #endif
 913
 914 #ifdef HAVE_TARGET_32_LITTLE
 915 template
 916 void
 917 Copy_relocs<32, false>::emit<elfcpp::SHT_RELA>(
 918     Output_data_reloc<elfcpp::SHT_RELA , true, 32, false>*);
 919 #endif
 920
 921 #ifdef HAVE_TARGET_32_BIG
 922 template
 923 void
 924 Copy_relocs<32, true>::emit<elfcpp::SHT_RELA>(
 925     Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>*);
 926 #endif
 927
 928 #ifdef HAVE_TARGET_64_LITTLE
 929 template
 930 void
 931 Copy_relocs<64, false>::emit<elfcpp::SHT_RELA>(
 932     Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>*);
 933 #endif
 934
 935 #ifdef HAVE_TARGET_64_BIG
 936 template
 937 void
 938 Copy_relocs<64, true>::emit<elfcpp::SHT_RELA>(
 939     Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>*);
 940 #endif
 941
 942 #ifdef HAVE_TARGET_32_LITTLE
 943 template
 944 class Track_relocs<32, false>;
 945 #endif
 946
 947 #ifdef HAVE_TARGET_32_BIG
 948 template
 949 class Track_relocs<32, true>;
 950 #endif
 951
 952 #ifdef HAVE_TARGET_64_LITTLE
 953 template
 954 class Track_relocs<64, false>;
 955 #endif
 956
 957 #ifdef HAVE_TARGET_64_BIG
 958 template
 959 class Track_relocs<64, true>;
 960 #endif
 961
 962 } // End namespace gold.