gold/reloc.cc

   1 // reloc.cc -- relocate input files for gold.
   2
   3 #include "gold.h"
   4
   5 #include "workqueue.h"
   6 #include "object.h"
   7 #include "symtab.h"
   8 #include "output.h"
   9 #include "reloc.h"
  10
  11 namespace gold
  12 {
  13
  14 // Read_relocs methods.
  15
  16 // These tasks just read the relocation information from the file.
  17 // After reading it, the start another task to process the
  18 // information.  These tasks requires access to the file.
  19
  20 Task::Is_runnable_type
  21 Read_relocs::is_runnable(Workqueue*)
  22 {
  23   return this->object_->is_locked() ? IS_LOCKED : IS_RUNNABLE;
  24 }
  25
  26 // Lock the file.
  27
  28 Task_locker*
  29 Read_relocs::locks(Workqueue*)
  30 {
  31   return new Task_locker_obj<Object>(*this->object_);
  32 }
  33
  34 // Read the relocations and then start a Scan_relocs_task.
  35
  36 void
  37 Read_relocs::run(Workqueue* workqueue)
  38 {
  39   Read_relocs_data *rd = new Read_relocs_data;
  40   this->object_->read_relocs(rd);
  41   workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_,
  42                                          this->layout_, this->object_, rd,
  43                                          this->symtab_lock_, this->blocker_));
  44 }
  45
  46 // Scan_relocs methods.
  47
  48 // These tasks scan the relocations read by Read_relocs and mark up
  49 // the symbol table to indicate which relocations are required.  We
  50 // use a lock on the symbol table to keep them from interfering with
  51 // each other.
  52
  53 Task::Is_runnable_type
  54 Scan_relocs::is_runnable(Workqueue*)
  55 {
  56   if (!this->symtab_lock_->is_writable() || this->object_->is_locked())
  57     return IS_LOCKED;
  58   return IS_RUNNABLE;
  59 }
  60
  61 // Return the locks we hold: one on the file, one on the symbol table
  62 // and one blocker.
  63
  64 class Scan_relocs::Scan_relocs_locker : public Task_locker
  65 {
  66  public:
  67   Scan_relocs_locker(Object* object, Task_token& symtab_lock, Task* task,
  68                      Task_token& blocker, Workqueue* workqueue)
  69     : objlock_(*object), symtab_locker_(symtab_lock, task),
  70       blocker_(blocker, workqueue)
  71   { }
  72
  73  private:
  74   Task_locker_obj<Object> objlock_;
  75   Task_locker_write symtab_locker_;
  76   Task_locker_block blocker_;
  77 };
  78
  79 Task_locker*
  80 Scan_relocs::locks(Workqueue* workqueue)
  81 {
  82   return new Scan_relocs_locker(this->object_, *this->symtab_lock_, this,
  83                                 *this->blocker_, workqueue);
  84 }
  85
  86 // Scan the relocs.
  87
  88 void
  89 Scan_relocs::run(Workqueue*)
  90 {
  91   this->object_->scan_relocs(this->options_, this->symtab_, this->layout_,
  92                              this->rd_);
  93   delete this->rd_;
  94   this->rd_ = NULL;
  95 }
  96
  97 // Relocate_task methods.
  98
  99 // These tasks are always runnable.
 100
 101 Task::Is_runnable_type
 102 Relocate_task::is_runnable(Workqueue*)
 103 {
 104   return IS_RUNNABLE;
 105 }
 106
 107 // We want to lock the file while we run.  We want to unblock
 108 // FINAL_BLOCKER when we are done.
 109
 110 class Relocate_task::Relocate_locker : public Task_locker
 111 {
 112  public:
 113   Relocate_locker(Task_token& token, Workqueue* workqueue,
 114                   Object* object)
 115     : blocker_(token, workqueue), objlock_(*object)
 116   { }
 117
 118  private:
 119   Task_locker_block blocker_;
 120   Task_locker_obj<Object> objlock_;
 121 };
 122
 123 Task_locker*
 124 Relocate_task::locks(Workqueue* workqueue)
 125 {
 126   return new Relocate_locker(*this->final_blocker_, workqueue,
 127                              this->object_);
 128 }
 129
 130 // Run the task.
 131
 132 void
 133 Relocate_task::run(Workqueue*)
 134 {
 135   this->object_->relocate(this->options_, this->symtab_, this->layout_,
 136                           this->of_);
 137 }
 138
 139 // Read the relocs and local symbols from the object file and store
 140 // the information in RD.
 141
 142 template<int size, bool big_endian>
 143 void
 144 Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
 145 {
 146   rd->relocs.clear();
 147
 148   unsigned int shnum = this->shnum();
 149   if (shnum == 0)
 150     return;
 151
 152   rd->relocs.reserve(shnum / 2);
 153
 154   const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(),
 155                                                shnum * This::shdr_size);
 156   // Skip the first, dummy, section.
 157   const unsigned char *ps = pshdrs + This::shdr_size;
 158   for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size)
 159     {
 160       typename This::Shdr shdr(ps);
 161
 162       unsigned int sh_type = shdr.get_sh_type();
 163       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 164         continue;
 165
 166       unsigned int shndx = shdr.get_sh_info();
 167       if (shndx >= shnum)
 168         {
 169           fprintf(stderr, _("%s: %s: relocation section %u has bad info %u\n"),
 170                   program_name, this->name().c_str(), i, shndx);
 171           gold_exit(false);
 172         }
 173
 174       if (!this->is_section_included(shndx))
 175         continue;
 176
 177       // We are scanning relocations in order to fill out the GOT and
 178       // PLT sections.  Relocations for sections which are not
 179       // allocated (typically debugging sections) should not add new
 180       // GOT and PLT entries.  So we skip them.
 181       typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size);
 182       if ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
 183         continue;
 184
 185       if (shdr.get_sh_link() != this->symtab_shndx_)
 186         {
 187           fprintf(stderr,
 188                   _("%s: %s: relocation section %u uses unexpected "
 189                     "symbol table %u\n"),
 190                   program_name, this->name().c_str(), i, shdr.get_sh_link());
 191           gold_exit(false);
 192         }
 193
 194       off_t sh_size = shdr.get_sh_size();
 195
 196       unsigned int reloc_size;
 197       if (sh_type == elfcpp::SHT_REL)
 198         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 199       else
 200         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 201       if (reloc_size != shdr.get_sh_entsize())
 202         {
 203           fprintf(stderr,
 204                   _("%s: %s: unexpected entsize for reloc section %u: "
 205                     "%lu != %u"),
 206                   program_name, this->name().c_str(), i,
 207                   static_cast<unsigned long>(shdr.get_sh_entsize()),
 208                   reloc_size);
 209           gold_exit(false);
 210         }
 211
 212       size_t reloc_count = sh_size / reloc_size;
 213       if (reloc_count * reloc_size != sh_size)
 214         {
 215           fprintf(stderr, _("%s: %s: reloc section %u size %lu uneven"),
 216                   program_name, this->name().c_str(), i,
 217                   static_cast<unsigned long>(sh_size));
 218           gold_exit(false);
 219         }
 220
 221       rd->relocs.push_back(Section_relocs());
 222       Section_relocs& sr(rd->relocs.back());
 223       sr.reloc_shndx = i;
 224       sr.data_shndx = shndx;
 225       sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size);
 226       sr.sh_type = sh_type;
 227       sr.reloc_count = reloc_count;
 228     }
 229
 230   // Read the local symbols.
 231   gold_assert(this->symtab_shndx_ != -1U);
 232   if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0)
 233     rd->local_symbols = NULL;
 234   else
 235     {
 236       typename This::Shdr symtabshdr(pshdrs
 237                                      + this->symtab_shndx_ * This::shdr_size);
 238       gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 239       const int sym_size = This::sym_size;
 240       const unsigned int loccount = this->local_symbol_count_;
 241       gold_assert(loccount == symtabshdr.get_sh_info());
 242       off_t locsize = loccount * sym_size;
 243       rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(),
 244                                                  locsize);
 245     }
 246 }
 247
 248 // Scan the relocs and adjust the symbol table.  This looks for
 249 // relocations which require GOT/PLT/COPY relocations.
 250
 251 template<int size, bool big_endian>
 252 void
 253 Sized_relobj<size, big_endian>::do_scan_relocs(const General_options& options,
 254                                                Symbol_table* symtab,
 255                                                Layout* layout,
 256                                                Read_relocs_data* rd)
 257 {
 258   Sized_target<size, big_endian>* target = this->sized_target();
 259
 260   const unsigned char* local_symbols;
 261   if (rd->local_symbols == NULL)
 262     local_symbols = NULL;
 263   else
 264     local_symbols = rd->local_symbols->data();
 265
 266   for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();
 267        p != rd->relocs.end();
 268        ++p)
 269     {
 270       target->scan_relocs(options, symtab, layout, this, p->data_shndx,
 271                           p->sh_type, p->contents->data(), p->reloc_count,
 272                           this->local_symbol_count_,
 273                           local_symbols,
 274                           this->symbols_);
 275       delete p->contents;
 276       p->contents = NULL;
 277     }
 278
 279   if (rd->local_symbols != NULL)
 280     {
 281       delete rd->local_symbols;
 282       rd->local_symbols = NULL;
 283     }
 284 }
 285
 286 // Relocate the input sections and write out the local symbols.
 287
 288 template<int size, bool big_endian>
 289 void
 290 Sized_relobj<size, big_endian>::do_relocate(const General_options& options,
 291                                             const Symbol_table* symtab,
 292                                             const Layout* layout,
 293                                             Output_file* of)
 294 {
 295   unsigned int shnum = this->shnum();
 296
 297   // Read the section headers.
 298   const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),
 299                                                shnum * This::shdr_size);
 300
 301   Views views;
 302   views.resize(shnum);
 303
 304   // Make two passes over the sections.  The first one copies the
 305   // section data to the output file.  The second one applies
 306   // relocations.
 307
 308   this->write_sections(pshdrs, of, &views);
 309
 310   // Apply relocations.
 311
 312   this->relocate_sections(options, symtab, layout, pshdrs, &views);
 313
 314   // Write out the accumulated views.
 315   for (unsigned int i = 1; i < shnum; ++i)
 316     {
 317       if (views[i].view != NULL)
 318         of->write_output_view(views[i].offset, views[i].view_size,
 319                               views[i].view);
 320     }
 321
 322   // Write out the local symbols.
 323   this->write_local_symbols(of, layout->sympool());
 324 }
 325
 326 // Write section data to the output file.  PSHDRS points to the
 327 // section headers.  Record the views in *PVIEWS for use when
 328 // relocating.
 329
 330 template<int size, bool big_endian>
 331 void
 332 Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
 333                                                Output_file* of,
 334                                                Views* pviews)
 335 {
 336   unsigned int shnum = this->shnum();
 337   std::vector<Map_to_output>& map_sections(this->map_to_output());
 338
 339   const unsigned char* p = pshdrs + This::shdr_size;
 340   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 341     {
 342       View_size* pvs = &(*pviews)[i];
 343
 344       pvs->view = NULL;
 345
 346       const Output_section* os = map_sections[i].output_section;
 347       if (os == NULL)
 348         continue;
 349
 350       typename This::Shdr shdr(p);
 351
 352       if (shdr.get_sh_type() == elfcpp::SHT_NOBITS)
 353         continue;
 354
 355       off_t start = os->offset() + map_sections[i].offset;
 356       off_t sh_size = shdr.get_sh_size();
 357
 358       if (sh_size == 0)
 359         continue;
 360
 361       gold_assert(map_sections[i].offset >= 0
 362                   && map_sections[i].offset + sh_size <= os->data_size());
 363
 364       unsigned char* view = of->get_output_view(start, sh_size);
 365       this->read(shdr.get_sh_offset(), sh_size, view);
 366
 367       pvs->view = view;
 368       pvs->address = os->address() + map_sections[i].offset;
 369       pvs->offset = start;
 370       pvs->view_size = sh_size;
 371     }
 372 }
 373
 374 // Relocate section data.  VIEWS points to the section data as views
 375 // in the output file.
 376
 377 template<int size, bool big_endian>
 378 void
 379 Sized_relobj<size, big_endian>::relocate_sections(
 380     const General_options& options,
 381     const Symbol_table* symtab,
 382     const Layout* layout,
 383     const unsigned char* pshdrs,
 384     Views* pviews)
 385 {
 386   unsigned int shnum = this->shnum();
 387   Sized_target<size, big_endian>* target = this->sized_target();
 388
 389   Relocate_info<size, big_endian> relinfo;
 390   relinfo.options = &options;
 391   relinfo.symtab = symtab;
 392   relinfo.layout = layout;
 393   relinfo.object = this;
 394   relinfo.local_symbol_count = this->local_symbol_count_;
 395   relinfo.local_values = &this->local_values_;
 396   relinfo.symbols = this->symbols_;
 397
 398   const unsigned char* p = pshdrs + This::shdr_size;
 399   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 400     {
 401       typename This::Shdr shdr(p);
 402
 403       unsigned int sh_type = shdr.get_sh_type();
 404       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 405         continue;
 406
 407       unsigned int index = shdr.get_sh_info();
 408       if (index >= this->shnum())
 409         {
 410           fprintf(stderr, _("%s: %s: relocation section %u has bad info %u\n"),
 411                   program_name, this->name().c_str(), i, index);
 412           gold_exit(false);
 413         }
 414
 415       if (!this->is_section_included(index))
 416         {
 417           // This relocation section is against a section which we
 418           // discarded.
 419           continue;
 420         }
 421
 422       gold_assert((*pviews)[index].view != NULL);
 423
 424       if (shdr.get_sh_link() != this->symtab_shndx_)
 425         {
 426           fprintf(stderr,
 427                   _("%s: %s: relocation section %u uses unexpected "
 428                     "symbol table %u\n"),
 429                   program_name, this->name().c_str(), i, shdr.get_sh_link());
 430           gold_exit(false);
 431         }
 432
 433       off_t sh_size = shdr.get_sh_size();
 434       const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(),
 435                                                     sh_size);
 436
 437       unsigned int reloc_size;
 438       if (sh_type == elfcpp::SHT_REL)
 439         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 440       else
 441         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 442
 443       if (reloc_size != shdr.get_sh_entsize())
 444         {
 445           fprintf(stderr,
 446                   _("%s: %s: unexpected entsize for reloc section %u: "
 447                     "%lu != %u"),
 448                   program_name, this->name().c_str(), i,
 449                   static_cast<unsigned long>(shdr.get_sh_entsize()),
 450                   reloc_size);
 451           gold_exit(false);
 452         }
 453
 454       size_t reloc_count = sh_size / reloc_size;
 455       if (reloc_count * reloc_size != sh_size)
 456         {
 457           fprintf(stderr, _("%s: %s: reloc section %u size %lu uneven"),
 458                   program_name, this->name().c_str(), i,
 459                   static_cast<unsigned long>(sh_size));
 460           gold_exit(false);
 461         }
 462
 463       relinfo.reloc_shndx = i;
 464       relinfo.data_shndx = index;
 465       target->relocate_section(&relinfo,
 466                                sh_type,
 467                                prelocs,
 468                                reloc_count,
 469                                (*pviews)[index].view,
 470                                (*pviews)[index].address,
 471                                (*pviews)[index].view_size);
 472     }
 473 }
 474
 475 // Copy_relocs::Copy_reloc_entry methods.
 476
 477 // Return whether we should emit this reloc.  We should emit it if the
 478 // symbol is still defined in a dynamic object.  If we should not emit
 479 // it, we clear it, to save ourselves the test next time.
 480
 481 template<int size, bool big_endian>
 482 bool
 483 Copy_relocs<size, big_endian>::Copy_reloc_entry::should_emit()
 484 {
 485   if (this->sym_ == NULL)
 486     return false;
 487   if (this->sym_->is_from_dynobj())
 488     return true;
 489   this->sym_ = NULL;
 490   return false;
 491 }
 492
 493 // Emit a reloc into a SHT_REL section.
 494
 495 template<int size, bool big_endian>
 496 void
 497 Copy_relocs<size, big_endian>::Copy_reloc_entry::emit(
 498     Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>* reloc_data)
 499 {
 500   this->sym_->set_needs_dynsym_entry();
 501   reloc_data->add_global(this->sym_, this->reloc_type_, this->relobj_,
 502                          this->shndx_, this->address_);
 503 }
 504
 505 // Emit a reloc into a SHT_RELA section.
 506
 507 template<int size, bool big_endian>
 508 void
 509 Copy_relocs<size, big_endian>::Copy_reloc_entry::emit(
 510     Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>* reloc_data)
 511 {
 512   this->sym_->set_needs_dynsym_entry();
 513   reloc_data->add_global(this->sym_, this->reloc_type_, this->relobj_,
 514                          this->shndx_, this->address_, this->addend_);
 515 }
 516
 517 // Copy_relocs methods.
 518
 519 // Return whether we need a COPY reloc for a relocation against GSYM.
 520 // The relocation is being applied to section SHNDX in OBJECT.
 521
 522 template<int size, bool big_endian>
 523 bool
 524 Copy_relocs<size, big_endian>::need_copy_reloc(
 525     const General_options*,
 526     Relobj* object,
 527     unsigned int shndx,
 528     Sized_symbol<size>* sym)
 529 {
 530   // FIXME: Handle -z nocopyrelocs.
 531
 532   if (sym->symsize() == 0)
 533     return false;
 534
 535   // If this is a readonly section, then we need a COPY reloc.
 536   // Otherwise we can use a dynamic reloc.
 537   if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
 538     return true;
 539
 540   return false;
 541 }
 542
 543 // Save a Rel reloc.
 544
 545 template<int size, bool big_endian>
 546 void
 547 Copy_relocs<size, big_endian>::save(
 548     Symbol* sym,
 549     Relobj* relobj,
 550     unsigned int shndx,
 551     const elfcpp::Rel<size, big_endian>& rel)
 552 {
 553   unsigned int reloc_type = elfcpp::elf_r_type<size>(rel.get_r_info());
 554   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx,
 555                                             rel.get_r_offset(), 0));
 556 }
 557
 558 // Save a Rela reloc.
 559
 560 template<int size, bool big_endian>
 561 void
 562 Copy_relocs<size, big_endian>::save(
 563     Symbol* sym,
 564     Relobj* relobj,
 565     unsigned int shndx,
 566     const elfcpp::Rela<size, big_endian>& rela)
 567 {
 568   unsigned int reloc_type = elfcpp::elf_r_type<size>(rela.get_r_info());
 569   this->entries_.push_back(Copy_reloc_entry(sym, reloc_type, relobj, shndx,
 570                                             rela.get_r_offset(),
 571                                             rela.get_r_addend()));
 572 }
 573
 574 // Return whether there are any relocs to emit.  We don't want to emit
 575 // a reloc if the symbol is no longer defined in a dynamic object.
 576
 577 template<int size, bool big_endian>
 578 bool
 579 Copy_relocs<size, big_endian>::any_to_emit()
 580 {
 581   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 582        p != this->entries_.end();
 583        ++p)
 584     {
 585       if (p->should_emit())
 586         return true;
 587     }
 588   return false;
 589 }
 590
 591 // Emit relocs.
 592
 593 template<int size, bool big_endian>
 594 template<int sh_type>
 595 void
 596 Copy_relocs<size, big_endian>::emit(
 597     Output_data_reloc<sh_type, true, size, big_endian>* reloc_data)
 598 {
 599   for (typename Copy_reloc_entries::iterator p = this->entries_.begin();
 600        p != this->entries_.end();
 601        ++p)
 602     {
 603       if (p->should_emit())
 604         p->emit(reloc_data);
 605     }
 606 }
 607
 608 // Instantiate the templates we need.  We could use the configure
 609 // script to restrict this to only the ones for implemented targets.
 610
 611 template
 612 void
 613 Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
 614
 615 template
 616 void
 617 Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
 618
 619 template
 620 void
 621 Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
 622
 623 template
 624 void
 625 Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
 626
 627 template
 628 void
 629 Sized_relobj<32, false>::do_scan_relocs(const General_options& options,
 630                                         Symbol_table* symtab,
 631                                         Layout* layout,
 632                                         Read_relocs_data* rd);
 633
 634 template
 635 void
 636 Sized_relobj<32, true>::do_scan_relocs(const General_options& options,
 637                                        Symbol_table* symtab,
 638                                        Layout* layout,
 639                                        Read_relocs_data* rd);
 640
 641 template
 642 void
 643 Sized_relobj<64, false>::do_scan_relocs(const General_options& options,
 644                                         Symbol_table* symtab,
 645                                         Layout* layout,
 646                                         Read_relocs_data* rd);
 647
 648 template
 649 void
 650 Sized_relobj<64, true>::do_scan_relocs(const General_options& options,
 651                                        Symbol_table* symtab,
 652                                        Layout* layout,
 653                                        Read_relocs_data* rd);
 654
 655 template
 656 void
 657 Sized_relobj<32, false>::do_relocate(const General_options& options,
 658                                      const Symbol_table* symtab,
 659                                      const Layout* layout,
 660                                      Output_file* of);
 661
 662 template
 663 void
 664 Sized_relobj<32, true>::do_relocate(const General_options& options,
 665                                     const Symbol_table* symtab,
 666                                     const Layout* layout,
 667                                     Output_file* of);
 668
 669 template
 670 void
 671 Sized_relobj<64, false>::do_relocate(const General_options& options,
 672                                      const Symbol_table* symtab,
 673                                      const Layout* layout,
 674                                      Output_file* of);
 675
 676 template
 677 void
 678 Sized_relobj<64, true>::do_relocate(const General_options& options,
 679                                     const Symbol_table* symtab,
 680                                     const Layout* layout,
 681                                     Output_file* of);
 682
 683 template
 684 class Copy_relocs<32, false>;
 685
 686 template
 687 class Copy_relocs<32, true>;
 688
 689 template
 690 class Copy_relocs<64, false>;
 691
 692 template
 693 class Copy_relocs<64, true>;
 694
 695 template
 696 void
 697 Copy_relocs<32, false>::emit<elfcpp::SHT_REL>(
 698     Output_data_reloc<elfcpp::SHT_REL, true, 32, false>*);
 699
 700 template
 701 void
 702 Copy_relocs<32, true>::emit<elfcpp::SHT_REL>(
 703     Output_data_reloc<elfcpp::SHT_REL, true, 32, true>*);
 704
 705 template
 706 void
 707 Copy_relocs<64, false>::emit<elfcpp::SHT_REL>(
 708     Output_data_reloc<elfcpp::SHT_REL, true, 64, false>*);
 709
 710 template
 711 void
 712 Copy_relocs<64, true>::emit<elfcpp::SHT_REL>(
 713     Output_data_reloc<elfcpp::SHT_REL, true, 64, true>*);
 714
 715 template
 716 void
 717 Copy_relocs<32, false>::emit<elfcpp::SHT_RELA>(
 718     Output_data_reloc<elfcpp::SHT_RELA , true, 32, false>*);
 719
 720 template
 721 void
 722 Copy_relocs<32, true>::emit<elfcpp::SHT_RELA>(
 723     Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>*);
 724
 725 template
 726 void
 727 Copy_relocs<64, false>::emit<elfcpp::SHT_RELA>(
 728     Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>*);
 729
 730 template
 731 void
 732 Copy_relocs<64, true>::emit<elfcpp::SHT_RELA>(
 733     Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>*);
 734
 735 } // End namespace gold.