gold/reloc.cc

   1 // reloc.cc -- relocate input files for gold.
   2
   3 // Copyright 2006, 2007, 2008 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 <algorithm>
  26
  27 #include "workqueue.h"
  28 #include "symtab.h"
  29 #include "output.h"
  30 #include "merge.h"
  31 #include "object.h"
  32 #include "target-reloc.h"
  33 #include "reloc.h"
  34
  35 namespace gold
  36 {
  37
  38 // Read_relocs methods.
  39
  40 // These tasks just read the relocation information from the file.
  41 // After reading it, the start another task to process the
  42 // information.  These tasks requires access to the file.
  43
  44 Task_token*
  45 Read_relocs::is_runnable()
  46 {
  47   return this->object_->is_locked() ? this->object_->token() : NULL;
  48 }
  49
  50 // Lock the file.
  51
  52 void
  53 Read_relocs::locks(Task_locker* tl)
  54 {
  55   tl->add(this, this->object_->token());
  56 }
  57
  58 // Read the relocations and then start a Scan_relocs_task.
  59
  60 void
  61 Read_relocs::run(Workqueue* workqueue)
  62 {
  63   Read_relocs_data *rd = new Read_relocs_data;
  64   this->object_->read_relocs(rd);
  65   this->object_->release();
  66
  67   workqueue->queue_next(new Scan_relocs(this->options_, this->symtab_,
  68                                         this->layout_, this->object_, rd,
  69                                         this->symtab_lock_, this->blocker_));
  70 }
  71
  72 // Return a debugging name for the task.
  73
  74 std::string
  75 Read_relocs::get_name() const
  76 {
  77   return "Read_relocs " + this->object_->name();
  78 }
  79
  80 // Scan_relocs methods.
  81
  82 // These tasks scan the relocations read by Read_relocs and mark up
  83 // the symbol table to indicate which relocations are required.  We
  84 // use a lock on the symbol table to keep them from interfering with
  85 // each other.
  86
  87 Task_token*
  88 Scan_relocs::is_runnable()
  89 {
  90   if (!this->symtab_lock_->is_writable())
  91     return this->symtab_lock_;
  92   if (this->object_->is_locked())
  93     return this->object_->token();
  94   return NULL;
  95 }
  96
  97 // Return the locks we hold: one on the file, one on the symbol table
  98 // and one blocker.
  99
 100 void
 101 Scan_relocs::locks(Task_locker* tl)
 102 {
 103   tl->add(this, this->object_->token());
 104   tl->add(this, this->symtab_lock_);
 105   tl->add(this, this->blocker_);
 106 }
 107
 108 // Scan the relocs.
 109
 110 void
 111 Scan_relocs::run(Workqueue*)
 112 {
 113   this->object_->scan_relocs(this->options_, this->symtab_, this->layout_,
 114                              this->rd_);
 115   this->object_->release();
 116   delete this->rd_;
 117   this->rd_ = NULL;
 118 }
 119
 120 // Return a debugging name for the task.
 121
 122 std::string
 123 Scan_relocs::get_name() const
 124 {
 125   return "Scan_relocs " + this->object_->name();
 126 }
 127
 128 // Relocate_task methods.
 129
 130 // We may have to wait for the output sections to be written.
 131
 132 Task_token*
 133 Relocate_task::is_runnable()
 134 {
 135   if (this->object_->relocs_must_follow_section_writes()
 136       && this->output_sections_blocker_->is_blocked())
 137     return this->output_sections_blocker_;
 138
 139   if (this->object_->is_locked())
 140     return this->object_->token();
 141
 142   return NULL;
 143 }
 144
 145 // We want to lock the file while we run.  We want to unblock
 146 // INPUT_SECTIONS_BLOCKER and FINAL_BLOCKER when we are done.
 147 // INPUT_SECTIONS_BLOCKER may be NULL.
 148
 149 void
 150 Relocate_task::locks(Task_locker* tl)
 151 {
 152   if (this->input_sections_blocker_ != NULL)
 153     tl->add(this, this->input_sections_blocker_);
 154   tl->add(this, this->final_blocker_);
 155   tl->add(this, this->object_->token());
 156 }
 157
 158 // Run the task.
 159
 160 void
 161 Relocate_task::run(Workqueue*)
 162 {
 163   this->object_->relocate(this->options_, this->symtab_, this->layout_,
 164                           this->of_);
 165
 166   // This is normally the last thing we will do with an object, so
 167   // uncache all views.
 168   this->object_->clear_view_cache_marks();
 169
 170   this->object_->release();
 171 }
 172
 173 // Return a debugging name for the task.
 174
 175 std::string
 176 Relocate_task::get_name() const
 177 {
 178   return "Relocate_task " + this->object_->name();
 179 }
 180
 181 // Read the relocs and local symbols from the object file and store
 182 // the information in RD.
 183
 184 template<int size, bool big_endian>
 185 void
 186 Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
 187 {
 188   rd->relocs.clear();
 189
 190   unsigned int shnum = this->shnum();
 191   if (shnum == 0)
 192     return;
 193
 194   rd->relocs.reserve(shnum / 2);
 195
 196   std::vector<Map_to_output>& map_sections(this->map_to_output());
 197
 198   const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(),
 199                                                shnum * This::shdr_size,
 200                                                true, true);
 201   // Skip the first, dummy, section.
 202   const unsigned char *ps = pshdrs + This::shdr_size;
 203   for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size)
 204     {
 205       typename This::Shdr shdr(ps);
 206
 207       unsigned int sh_type = shdr.get_sh_type();
 208       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 209         continue;
 210
 211       unsigned int shndx = shdr.get_sh_info();
 212       if (shndx >= shnum)
 213         {
 214           this->error(_("relocation section %u has bad info %u"),
 215                       i, shndx);
 216           continue;
 217         }
 218
 219       Output_section* os = map_sections[shndx].output_section;
 220       if (os == NULL)
 221         continue;
 222
 223       // We are scanning relocations in order to fill out the GOT and
 224       // PLT sections.  Relocations for sections which are not
 225       // allocated (typically debugging sections) should not add new
 226       // GOT and PLT entries.  So we skip them unless this is a
 227       // relocatable link or we need to emit relocations.
 228       typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size);
 229       bool is_section_allocated = ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC)
 230                                    != 0);
 231       if (!is_section_allocated
 232           && !parameters->options().relocatable()
 233           && !parameters->options().emit_relocs())
 234         continue;
 235
 236       if (shdr.get_sh_link() != this->symtab_shndx_)
 237         {
 238           this->error(_("relocation section %u uses unexpected "
 239                         "symbol table %u"),
 240                       i, shdr.get_sh_link());
 241           continue;
 242         }
 243
 244       off_t sh_size = shdr.get_sh_size();
 245
 246       unsigned int reloc_size;
 247       if (sh_type == elfcpp::SHT_REL)
 248         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 249       else
 250         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 251       if (reloc_size != shdr.get_sh_entsize())
 252         {
 253           this->error(_("unexpected entsize for reloc section %u: %lu != %u"),
 254                       i, static_cast<unsigned long>(shdr.get_sh_entsize()),
 255                       reloc_size);
 256           continue;
 257         }
 258
 259       size_t reloc_count = sh_size / reloc_size;
 260       if (static_cast<off_t>(reloc_count * reloc_size) != sh_size)
 261         {
 262           this->error(_("reloc section %u size %lu uneven"),
 263                       i, static_cast<unsigned long>(sh_size));
 264           continue;
 265         }
 266
 267       rd->relocs.push_back(Section_relocs());
 268       Section_relocs& sr(rd->relocs.back());
 269       sr.reloc_shndx = i;
 270       sr.data_shndx = shndx;
 271       sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size,
 272                                            true, true);
 273       sr.sh_type = sh_type;
 274       sr.reloc_count = reloc_count;
 275       sr.output_section = os;
 276       sr.needs_special_offset_handling = map_sections[shndx].offset == -1;
 277       sr.is_data_section_allocated = is_section_allocated;
 278     }
 279
 280   // Read the local symbols.
 281   gold_assert(this->symtab_shndx_ != -1U);
 282   if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0)
 283     rd->local_symbols = NULL;
 284   else
 285     {
 286       typename This::Shdr symtabshdr(pshdrs
 287                                      + this->symtab_shndx_ * This::shdr_size);
 288       gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 289       const int sym_size = This::sym_size;
 290       const unsigned int loccount = this->local_symbol_count_;
 291       gold_assert(loccount == symtabshdr.get_sh_info());
 292       off_t locsize = loccount * sym_size;
 293       rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(),
 294                                                  locsize, true, true);
 295     }
 296 }
 297
 298 // Scan the relocs and adjust the symbol table.  This looks for
 299 // relocations which require GOT/PLT/COPY relocations.
 300
 301 template<int size, bool big_endian>
 302 void
 303 Sized_relobj<size, big_endian>::do_scan_relocs(const General_options& options,
 304                                                Symbol_table* symtab,
 305                                                Layout* layout,
 306                                                Read_relocs_data* rd)
 307 {
 308   Sized_target<size, big_endian>* target = this->sized_target();
 309
 310   const unsigned char* local_symbols;
 311   if (rd->local_symbols == NULL)
 312     local_symbols = NULL;
 313   else
 314     local_symbols = rd->local_symbols->data();
 315
 316   for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();
 317        p != rd->relocs.end();
 318        ++p)
 319     {
 320       if (!parameters->options().relocatable())
 321         {
 322           // As noted above, when not generating an object file, we
 323           // only scan allocated sections.  We may see a non-allocated
 324           // section here if we are emitting relocs.
 325           if (p->is_data_section_allocated)
 326             target->scan_relocs(options, symtab, layout, this, p->data_shndx,
 327                                 p->sh_type, p->contents->data(),
 328                                 p->reloc_count, p->output_section,
 329                                 p->needs_special_offset_handling,
 330                                 this->local_symbol_count_,
 331                                 local_symbols);
 332           if (parameters->options().emit_relocs())
 333             this->emit_relocs_scan(options, symtab, layout, local_symbols, p);
 334         }
 335       else
 336         {
 337           Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx);
 338           gold_assert(rr != NULL);
 339           rr->set_reloc_count(p->reloc_count);
 340           target->scan_relocatable_relocs(options, symtab, layout, this,
 341                                           p->data_shndx, p->sh_type,
 342                                           p->contents->data(),
 343                                           p->reloc_count,
 344                                           p->output_section,
 345                                           p->needs_special_offset_handling,
 346                                           this->local_symbol_count_,
 347                                           local_symbols,
 348                                           rr);
 349         }
 350
 351       delete p->contents;
 352       p->contents = NULL;
 353     }
 354
 355   if (rd->local_symbols != NULL)
 356     {
 357       delete rd->local_symbols;
 358       rd->local_symbols = NULL;
 359     }
 360 }
 361
 362 // This is a strategy class we use when scanning for --emit-relocs.
 363
 364 template<int sh_type>
 365 class Emit_relocs_strategy
 366 {
 367  public:
 368   // A local non-section symbol.
 369   inline Relocatable_relocs::Reloc_strategy
 370   local_non_section_strategy(unsigned int, Relobj*)
 371   { return Relocatable_relocs::RELOC_COPY; }
 372
 373   // A local section symbol.
 374   inline Relocatable_relocs::Reloc_strategy
 375   local_section_strategy(unsigned int, Relobj*)
 376   {
 377     if (sh_type == elfcpp::SHT_RELA)
 378       return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
 379     else
 380       {
 381         // The addend is stored in the section contents.  Since this
 382         // is not a relocatable link, we are going to apply the
 383         // relocation contents to the section as usual.  This means
 384         // that we have no way to record the original addend.  If the
 385         // original addend is not zero, there is basically no way for
 386         // the user to handle this correctly.  Caveat emptor.
 387         return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_0;
 388       }
 389   }
 390
 391   // A global symbol.
 392   inline Relocatable_relocs::Reloc_strategy
 393   global_strategy(unsigned int, Relobj*, unsigned int)
 394   { return Relocatable_relocs::RELOC_COPY; }
 395 };
 396
 397 // Scan the input relocations for --emit-relocs.
 398
 399 template<int size, bool big_endian>
 400 void
 401 Sized_relobj<size, big_endian>::emit_relocs_scan(
 402     const General_options& options,
 403     Symbol_table* symtab,
 404     Layout* layout,
 405     const unsigned char* plocal_syms,
 406     const Read_relocs_data::Relocs_list::iterator& p)
 407 {
 408   Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx);
 409   gold_assert(rr != NULL);
 410   rr->set_reloc_count(p->reloc_count);
 411
 412   if (p->sh_type == elfcpp::SHT_REL)
 413     this->emit_relocs_scan_reltype<elfcpp::SHT_REL>(options, symtab, layout,
 414                                                     plocal_syms, p, rr);
 415   else
 416     {
 417       gold_assert(p->sh_type == elfcpp::SHT_RELA);
 418       this->emit_relocs_scan_reltype<elfcpp::SHT_RELA>(options, symtab,
 419                                                        layout, plocal_syms, p,
 420                                                        rr);
 421     }
 422 }
 423
 424 // Scan the input relocation for --emit-relocs, templatized on the
 425 // type of the relocation section.
 426
 427 template<int size, bool big_endian>
 428 template<int sh_type>
 429 void
 430 Sized_relobj<size, big_endian>::emit_relocs_scan_reltype(
 431     const General_options& options,
 432     Symbol_table* symtab,
 433     Layout* layout,
 434     const unsigned char* plocal_syms,
 435     const Read_relocs_data::Relocs_list::iterator& p,
 436     Relocatable_relocs* rr)
 437 {
 438   scan_relocatable_relocs<size, big_endian, sh_type,
 439                           Emit_relocs_strategy<sh_type> >(
 440     options,
 441     symtab,
 442     layout,
 443     this,
 444     p->data_shndx,
 445     p->contents->data(),
 446     p->reloc_count,
 447     p->output_section,
 448     p->needs_special_offset_handling,
 449     this->local_symbol_count_,
 450     plocal_syms,
 451     rr);
 452 }
 453
 454 // Relocate the input sections and write out the local symbols.
 455
 456 template<int size, bool big_endian>
 457 void
 458 Sized_relobj<size, big_endian>::do_relocate(const General_options& options,
 459                                             const Symbol_table* symtab,
 460                                             const Layout* layout,
 461                                             Output_file* of)
 462 {
 463   unsigned int shnum = this->shnum();
 464
 465   // Read the section headers.
 466   const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),
 467                                                shnum * This::shdr_size,
 468                                                true, true);
 469
 470   Views views;
 471   views.resize(shnum);
 472
 473   // Make two passes over the sections.  The first one copies the
 474   // section data to the output file.  The second one applies
 475   // relocations.
 476
 477   this->write_sections(pshdrs, of, &views);
 478
 479   // To speed up relocations, we set up hash tables for fast lookup of
 480   // input offsets to output addresses.
 481   this->initialize_input_to_output_maps();
 482
 483   // Apply relocations.
 484
 485   this->relocate_sections(options, symtab, layout, pshdrs, &views);
 486
 487   // After we've done the relocations, we release the hash tables,
 488   // since we no longer need them.
 489   this->free_input_to_output_maps();
 490
 491   // Write out the accumulated views.
 492   for (unsigned int i = 1; i < shnum; ++i)
 493     {
 494       if (views[i].view != NULL)
 495         {
 496           if (!views[i].is_postprocessing_view)
 497             {
 498               if (views[i].is_input_output_view)
 499                 of->write_input_output_view(views[i].offset,
 500                                             views[i].view_size,
 501                                             views[i].view);
 502               else
 503                 of->write_output_view(views[i].offset, views[i].view_size,
 504                                       views[i].view);
 505             }
 506         }
 507     }
 508
 509   // Write out the local symbols.
 510   this->write_local_symbols(of, layout->sympool(), layout->dynpool());
 511
 512   // We should no longer need the local symbol values.
 513   this->clear_local_symbols();
 514 }
 515
 516 // Sort a Read_multiple vector by file offset.
 517 struct Read_multiple_compare
 518 {
 519   inline bool
 520   operator()(const File_read::Read_multiple_entry& rme1,
 521              const File_read::Read_multiple_entry& rme2) const
 522   { return rme1.file_offset < rme2.file_offset; }
 523 };
 524
 525 // Write section data to the output file.  PSHDRS points to the
 526 // section headers.  Record the views in *PVIEWS for use when
 527 // relocating.
 528
 529 template<int size, bool big_endian>
 530 void
 531 Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
 532                                                Output_file* of,
 533                                                Views* pviews)
 534 {
 535   unsigned int shnum = this->shnum();
 536   const std::vector<Map_to_output>& map_sections(this->map_to_output());
 537
 538   File_read::Read_multiple rm;
 539   bool is_sorted = true;
 540
 541   const unsigned char* p = pshdrs + This::shdr_size;
 542   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 543     {
 544       View_size* pvs = &(*pviews)[i];
 545
 546       pvs->view = NULL;
 547
 548       const Output_section* os = map_sections[i].output_section;
 549       if (os == NULL)
 550         continue;
 551       off_t output_offset = map_sections[i].offset;
 552
 553       typename This::Shdr shdr(p);
 554
 555       if (shdr.get_sh_type() == elfcpp::SHT_NOBITS)
 556         continue;
 557
 558       if ((parameters->options().relocatable()
 559            || parameters->options().emit_relocs())
 560           && (shdr.get_sh_type() == elfcpp::SHT_REL
 561               || shdr.get_sh_type() == elfcpp::SHT_RELA)
 562           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
 563         {
 564           // This is a reloc section in a relocatable link or when
 565           // emitting relocs.  We don't need to read the input file.
 566           // The size and file offset are stored in the
 567           // Relocatable_relocs structure.
 568           Relocatable_relocs* rr = this->relocatable_relocs(i);
 569           gold_assert(rr != NULL);
 570           Output_data* posd = rr->output_data();
 571           gold_assert(posd != NULL);
 572
 573           pvs->offset = posd->offset();
 574           pvs->view_size = posd->data_size();
 575           pvs->view = of->get_output_view(pvs->offset, pvs->view_size);
 576           pvs->address = posd->address();
 577           pvs->is_input_output_view = false;
 578           pvs->is_postprocessing_view = false;
 579
 580           continue;
 581         }
 582
 583       // In the normal case, this input section is simply mapped to
 584       // the output section at offset OUTPUT_OFFSET.
 585
 586       // However, if OUTPUT_OFFSET == -1, then input data is handled
 587       // specially--e.g., a .eh_frame section.  The relocation
 588       // routines need to check for each reloc where it should be
 589       // applied.  For this case, we need an input/output view for the
 590       // entire contents of the section in the output file.  We don't
 591       // want to copy the contents of the input section to the output
 592       // section; the output section contents were already written,
 593       // and we waited for them in Relocate_task::is_runnable because
 594       // relocs_must_follow_section_writes is set for the object.
 595
 596       // Regardless of which of the above cases is true, we have to
 597       // check requires_postprocessing of the output section.  If that
 598       // is false, then we work with views of the output file
 599       // directly.  If it is true, then we work with a separate
 600       // buffer, and the output section is responsible for writing the
 601       // final data to the output file.
 602
 603       off_t output_section_offset;
 604       off_t output_section_size;
 605       if (!os->requires_postprocessing())
 606         {
 607           output_section_offset = os->offset();
 608           output_section_size = os->data_size();
 609         }
 610       else
 611         {
 612           output_section_offset = 0;
 613           output_section_size = os->postprocessing_buffer_size();
 614         }
 615
 616       off_t view_start;
 617       section_size_type view_size;
 618       if (output_offset != -1)
 619         {
 620           view_start = output_section_offset + output_offset;
 621           view_size = convert_to_section_size_type(shdr.get_sh_size());
 622         }
 623       else
 624         {
 625           view_start = output_section_offset;
 626           view_size = convert_to_section_size_type(output_section_size);
 627         }
 628
 629       if (view_size == 0)
 630         continue;
 631
 632       gold_assert(output_offset == -1
 633                   || (output_offset >= 0
 634                       && (output_offset + static_cast<off_t>(view_size)
 635                           <= output_section_size)));
 636
 637       unsigned char* view;
 638       if (os->requires_postprocessing())
 639         {
 640           unsigned char* buffer = os->postprocessing_buffer();
 641           view = buffer + view_start;
 642           if (output_offset != -1)
 643             {
 644               off_t sh_offset = shdr.get_sh_offset();
 645               if (!rm.empty() && rm.back().file_offset > sh_offset)
 646                 is_sorted = false;
 647               rm.push_back(File_read::Read_multiple_entry(sh_offset,
 648                                                           view_size, view));
 649             }
 650         }
 651       else
 652         {
 653           if (output_offset == -1)
 654             view = of->get_input_output_view(view_start, view_size);
 655           else
 656             {
 657               view = of->get_output_view(view_start, view_size);
 658               off_t sh_offset = shdr.get_sh_offset();
 659               if (!rm.empty() && rm.back().file_offset > sh_offset)
 660                 is_sorted = false;
 661               rm.push_back(File_read::Read_multiple_entry(sh_offset,
 662                                                           view_size, view));
 663             }
 664         }
 665
 666       pvs->view = view;
 667       pvs->address = os->address();
 668       if (output_offset != -1)
 669         pvs->address += output_offset;
 670       pvs->offset = view_start;
 671       pvs->view_size = view_size;
 672       pvs->is_input_output_view = output_offset == -1;
 673       pvs->is_postprocessing_view = os->requires_postprocessing();
 674     }
 675
 676   // Actually read the data.
 677   if (!rm.empty())
 678     {
 679       if (!is_sorted)
 680         std::sort(rm.begin(), rm.end(), Read_multiple_compare());
 681       this->read_multiple(rm);
 682     }
 683 }
 684
 685 // Relocate section data.  VIEWS points to the section data as views
 686 // in the output file.
 687
 688 template<int size, bool big_endian>
 689 void
 690 Sized_relobj<size, big_endian>::relocate_sections(
 691     const General_options& options,
 692     const Symbol_table* symtab,
 693     const Layout* layout,
 694     const unsigned char* pshdrs,
 695     Views* pviews)
 696 {
 697   unsigned int shnum = this->shnum();
 698   Sized_target<size, big_endian>* target = this->sized_target();
 699
 700   const std::vector<Map_to_output>& map_sections(this->map_to_output());
 701
 702   Relocate_info<size, big_endian> relinfo;
 703   relinfo.options = &options;
 704   relinfo.symtab = symtab;
 705   relinfo.layout = layout;
 706   relinfo.object = this;
 707
 708   const unsigned char* p = pshdrs + This::shdr_size;
 709   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 710     {
 711       typename This::Shdr shdr(p);
 712
 713       unsigned int sh_type = shdr.get_sh_type();
 714       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 715         continue;
 716
 717       unsigned int index = shdr.get_sh_info();
 718       if (index >= this->shnum())
 719         {
 720           this->error(_("relocation section %u has bad info %u"),
 721                       i, index);
 722           continue;
 723         }
 724
 725       Output_section* os = map_sections[index].output_section;
 726       if (os == NULL)
 727         {
 728           // This relocation section is against a section which we
 729           // discarded.
 730           continue;
 731         }
 732       off_t output_offset = map_sections[index].offset;
 733
 734       gold_assert((*pviews)[index].view != NULL);
 735       if (parameters->options().relocatable())
 736         gold_assert((*pviews)[i].view != NULL);
 737
 738       if (shdr.get_sh_link() != this->symtab_shndx_)
 739         {
 740           gold_error(_("relocation section %u uses unexpected "
 741                        "symbol table %u"),
 742                      i, shdr.get_sh_link());
 743           continue;
 744         }
 745
 746       off_t sh_size = shdr.get_sh_size();
 747       const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(),
 748                                                     sh_size, true, false);
 749
 750       unsigned int reloc_size;
 751       if (sh_type == elfcpp::SHT_REL)
 752         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 753       else
 754         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 755
 756       if (reloc_size != shdr.get_sh_entsize())
 757         {
 758           gold_error(_("unexpected entsize for reloc section %u: %lu != %u"),
 759                      i, static_cast<unsigned long>(shdr.get_sh_entsize()),
 760                      reloc_size);
 761           continue;
 762         }
 763
 764       size_t reloc_count = sh_size / reloc_size;
 765       if (static_cast<off_t>(reloc_count * reloc_size) != sh_size)
 766         {
 767           gold_error(_("reloc section %u size %lu uneven"),
 768                      i, static_cast<unsigned long>(sh_size));
 769           continue;
 770         }
 771
 772       gold_assert(output_offset != -1
 773                   || this->relocs_must_follow_section_writes());
 774
 775       relinfo.reloc_shndx = i;
 776       relinfo.data_shndx = index;
 777       if (!parameters->options().relocatable())
 778         {
 779           target->relocate_section(&relinfo,
 780                                    sh_type,
 781                                    prelocs,
 782                                    reloc_count,
 783                                    os,
 784                                    output_offset == -1,
 785                                    (*pviews)[index].view,
 786                                    (*pviews)[index].address,
 787                                    (*pviews)[index].view_size);
 788           if (parameters->options().emit_relocs())
 789             this->emit_relocs(&relinfo, i, sh_type, prelocs, reloc_count,
 790                               os, output_offset,
 791                               (*pviews)[index].view,
 792                               (*pviews)[index].address,
 793                               (*pviews)[index].view_size,
 794                               (*pviews)[i].view,
 795                               (*pviews)[i].view_size);
 796         }
 797       else
 798         {
 799           Relocatable_relocs* rr = this->relocatable_relocs(i);
 800           target->relocate_for_relocatable(&relinfo,
 801                                            sh_type,
 802                                            prelocs,
 803                                            reloc_count,
 804                                            os,
 805                                            output_offset,
 806                                            rr,
 807                                            (*pviews)[index].view,
 808                                            (*pviews)[index].address,
 809                                            (*pviews)[index].view_size,
 810                                            (*pviews)[i].view,
 811                                            (*pviews)[i].view_size);
 812         }
 813     }
 814 }
 815
 816 // Emit the relocs for --emit-relocs.
 817
 818 template<int size, bool big_endian>
 819 void
 820 Sized_relobj<size, big_endian>::emit_relocs(
 821     const Relocate_info<size, big_endian>* relinfo,
 822     unsigned int i,
 823     unsigned int sh_type,
 824     const unsigned char* prelocs,
 825     size_t reloc_count,
 826     Output_section* output_section,
 827     off_t offset_in_output_section,
 828     unsigned char* view,
 829     typename elfcpp::Elf_types<size>::Elf_Addr address,
 830     section_size_type view_size,
 831     unsigned char* reloc_view,
 832     section_size_type reloc_view_size)
 833 {
 834   if (sh_type == elfcpp::SHT_REL)
 835     this->emit_relocs_reltype<elfcpp::SHT_REL>(relinfo, i, prelocs,
 836                                                reloc_count, output_section,
 837                                                offset_in_output_section,
 838                                                view, address, view_size,
 839                                                reloc_view, reloc_view_size);
 840   else
 841     {
 842       gold_assert(sh_type == elfcpp::SHT_RELA);
 843       this->emit_relocs_reltype<elfcpp::SHT_RELA>(relinfo, i, prelocs,
 844                                                   reloc_count, output_section,
 845                                                   offset_in_output_section,
 846                                                   view, address, view_size,
 847                                                   reloc_view, reloc_view_size);
 848     }
 849 }
 850
 851 // Emit the relocs for --emit-relocs, templatized on the type of the
 852 // relocation section.
 853
 854 template<int size, bool big_endian>
 855 template<int sh_type>
 856 void
 857 Sized_relobj<size, big_endian>::emit_relocs_reltype(
 858     const Relocate_info<size, big_endian>* relinfo,
 859     unsigned int i,
 860     const unsigned char* prelocs,
 861     size_t reloc_count,
 862     Output_section* output_section,
 863     off_t offset_in_output_section,
 864     unsigned char* view,
 865     typename elfcpp::Elf_types<size>::Elf_Addr address,
 866     section_size_type view_size,
 867     unsigned char* reloc_view,
 868     section_size_type reloc_view_size)
 869 {
 870   const Relocatable_relocs* rr = this->relocatable_relocs(i);
 871   relocate_for_relocatable<size, big_endian, sh_type>(
 872     relinfo,
 873     prelocs,
 874     reloc_count,
 875     output_section,
 876     offset_in_output_section,
 877     rr,
 878     view,
 879     address,
 880     view_size,
 881     reloc_view,
 882     reloc_view_size);
 883 }
 884
 885 // Create merge hash tables for the local symbols.  These are used to
 886 // speed up relocations.
 887
 888 template<int size, bool big_endian>
 889 void
 890 Sized_relobj<size, big_endian>::initialize_input_to_output_maps()
 891 {
 892   const unsigned int loccount = this->local_symbol_count_;
 893   for (unsigned int i = 1; i < loccount; ++i)
 894     {
 895       Symbol_value<size>& lv(this->local_values_[i]);
 896       lv.initialize_input_to_output_map(this);
 897     }
 898 }
 899
 900 // Free merge hash tables for the local symbols.
 901
 902 template<int size, bool big_endian>
 903 void
 904 Sized_relobj<size, big_endian>::free_input_to_output_maps()
 905 {
 906   const unsigned int loccount = this->local_symbol_count_;
 907   for (unsigned int i = 1; i < loccount; ++i)
 908     {
 909       Symbol_value<size>& lv(this->local_values_[i]);
 910       lv.free_input_to_output_map();
 911     }
 912 }
 913
 914 // Class Merged_symbol_value.
 915
 916 template<int size>
 917 void
 918 Merged_symbol_value<size>::initialize_input_to_output_map(
 919     const Relobj* object,
 920     unsigned int input_shndx)
 921 {
 922   Object_merge_map* map = object->merge_map();
 923   map->initialize_input_to_output_map<size>(input_shndx,
 924                                             this->output_start_address_,
 925                                             &this->output_addresses_);
 926 }
 927
 928 // Get the output value corresponding to an input offset if we
 929 // couldn't find it in the hash table.
 930
 931 template<int size>
 932 typename elfcpp::Elf_types<size>::Elf_Addr
 933 Merged_symbol_value<size>::value_from_output_section(
 934     const Relobj* object,
 935     unsigned int input_shndx,
 936     typename elfcpp::Elf_types<size>::Elf_Addr input_offset) const
 937 {
 938   section_offset_type output_offset;
 939   bool found = object->merge_map()->get_output_offset(NULL, input_shndx,
 940                                                       input_offset,
 941                                                       &output_offset);
 942
 943   // If this assertion fails, it means that some relocation was
 944   // against a portion of an input merge section which we didn't map
 945   // to the output file and we didn't explicitly discard.  We should
 946   // always map all portions of input merge sections.
 947   gold_assert(found);
 948
 949   if (output_offset == -1)
 950     return 0;
 951   else
 952     return this->output_start_address_ + output_offset;
 953 }
 954
 955 // Track_relocs methods.
 956
 957 // Initialize the class to track the relocs.  This gets the object,
 958 // the reloc section index, and the type of the relocs.  This returns
 959 // false if something goes wrong.
 960
 961 template<int size, bool big_endian>
 962 bool
 963 Track_relocs<size, big_endian>::initialize(
 964     Object* object,
 965     unsigned int reloc_shndx,
 966     unsigned int reloc_type)
 967 {
 968   // If RELOC_SHNDX is -1U, it means there is more than one reloc
 969   // section for the .eh_frame section.  We can't handle that case.
 970   if (reloc_shndx == -1U)
 971     return false;
 972
 973   // If RELOC_SHNDX is 0, there is no reloc section.
 974   if (reloc_shndx == 0)
 975     return true;
 976
 977   // Get the contents of the reloc section.
 978   this->prelocs_ = object->section_contents(reloc_shndx, &this->len_, false);
 979
 980   if (reloc_type == elfcpp::SHT_REL)
 981     this->reloc_size_ = elfcpp::Elf_sizes<size>::rel_size;
 982   else if (reloc_type == elfcpp::SHT_RELA)
 983     this->reloc_size_ = elfcpp::Elf_sizes<size>::rela_size;
 984   else
 985     gold_unreachable();
 986
 987   if (this->len_ % this->reloc_size_ != 0)
 988     {
 989       object->error(_("reloc section size %zu is not a multiple of "
 990                       "reloc size %d\n"),
 991                     static_cast<size_t>(this->len_),
 992                     this->reloc_size_);
 993       return false;
 994     }
 995
 996   return true;
 997 }
 998
 999 // Return the offset of the next reloc, or -1 if there isn't one.
1000
1001 template<int size, bool big_endian>
1002 off_t
1003 Track_relocs<size, big_endian>::next_offset() const
1004 {
1005   if (this->pos_ >= this->len_)
1006     return -1;
1007
1008   // Rel and Rela start out the same, so we can always use Rel to find
1009   // the r_offset value.
1010   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
1011   return rel.get_r_offset();
1012 }
1013
1014 // Return the index of the symbol referenced by the next reloc, or -1U
1015 // if there aren't any more relocs.
1016
1017 template<int size, bool big_endian>
1018 unsigned int
1019 Track_relocs<size, big_endian>::next_symndx() const
1020 {
1021   if (this->pos_ >= this->len_)
1022     return -1U;
1023
1024   // Rel and Rela start out the same, so we can use Rel to find the
1025   // symbol index.
1026   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
1027   return elfcpp::elf_r_sym<size>(rel.get_r_info());
1028 }
1029
1030 // Advance to the next reloc whose r_offset is greater than or equal
1031 // to OFFSET.  Return the number of relocs we skip.
1032
1033 template<int size, bool big_endian>
1034 int
1035 Track_relocs<size, big_endian>::advance(off_t offset)
1036 {
1037   int ret = 0;
1038   while (this->pos_ < this->len_)
1039     {
1040       // Rel and Rela start out the same, so we can always use Rel to
1041       // find the r_offset value.
1042       elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
1043       if (static_cast<off_t>(rel.get_r_offset()) >= offset)
1044         break;
1045       ++ret;
1046       this->pos_ += this->reloc_size_;
1047     }
1048   return ret;
1049 }
1050
1051 // Instantiate the templates we need.
1052
1053 #ifdef HAVE_TARGET_32_LITTLE
1054 template
1055 void
1056 Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
1057 #endif
1058
1059 #ifdef HAVE_TARGET_32_BIG
1060 template
1061 void
1062 Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
1063 #endif
1064
1065 #ifdef HAVE_TARGET_64_LITTLE
1066 template
1067 void
1068 Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
1069 #endif
1070
1071 #ifdef HAVE_TARGET_64_BIG
1072 template
1073 void
1074 Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
1075 #endif
1076
1077 #ifdef HAVE_TARGET_32_LITTLE
1078 template
1079 void
1080 Sized_relobj<32, false>::do_scan_relocs(const General_options& options,
1081                                         Symbol_table* symtab,
1082                                         Layout* layout,
1083                                         Read_relocs_data* rd);
1084 #endif
1085
1086 #ifdef HAVE_TARGET_32_BIG
1087 template
1088 void
1089 Sized_relobj<32, true>::do_scan_relocs(const General_options& options,
1090                                        Symbol_table* symtab,
1091                                        Layout* layout,
1092                                        Read_relocs_data* rd);
1093 #endif
1094
1095 #ifdef HAVE_TARGET_64_LITTLE
1096 template
1097 void
1098 Sized_relobj<64, false>::do_scan_relocs(const General_options& options,
1099                                         Symbol_table* symtab,
1100                                         Layout* layout,
1101                                         Read_relocs_data* rd);
1102 #endif
1103
1104 #ifdef HAVE_TARGET_64_BIG
1105 template
1106 void
1107 Sized_relobj<64, true>::do_scan_relocs(const General_options& options,
1108                                        Symbol_table* symtab,
1109                                        Layout* layout,
1110                                        Read_relocs_data* rd);
1111 #endif
1112
1113 #ifdef HAVE_TARGET_32_LITTLE
1114 template
1115 void
1116 Sized_relobj<32, false>::do_relocate(const General_options& options,
1117                                      const Symbol_table* symtab,
1118                                      const Layout* layout,
1119                                      Output_file* of);
1120 #endif
1121
1122 #ifdef HAVE_TARGET_32_BIG
1123 template
1124 void
1125 Sized_relobj<32, true>::do_relocate(const General_options& options,
1126                                     const Symbol_table* symtab,
1127                                     const Layout* layout,
1128                                     Output_file* of);
1129 #endif
1130
1131 #ifdef HAVE_TARGET_64_LITTLE
1132 template
1133 void
1134 Sized_relobj<64, false>::do_relocate(const General_options& options,
1135                                      const Symbol_table* symtab,
1136                                      const Layout* layout,
1137                                      Output_file* of);
1138 #endif
1139
1140 #ifdef HAVE_TARGET_64_BIG
1141 template
1142 void
1143 Sized_relobj<64, true>::do_relocate(const General_options& options,
1144                                     const Symbol_table* symtab,
1145                                     const Layout* layout,
1146                                     Output_file* of);
1147 #endif
1148
1149 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1150 template
1151 class Merged_symbol_value<32>;
1152 #endif
1153
1154 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1155 template
1156 class Merged_symbol_value<64>;
1157 #endif
1158
1159 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1160 template
1161 class Symbol_value<32>;
1162 #endif
1163
1164 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1165 template
1166 class Symbol_value<64>;
1167 #endif
1168
1169 #ifdef HAVE_TARGET_32_LITTLE
1170 template
1171 class Track_relocs<32, false>;
1172 #endif
1173
1174 #ifdef HAVE_TARGET_32_BIG
1175 template
1176 class Track_relocs<32, true>;
1177 #endif
1178
1179 #ifdef HAVE_TARGET_64_LITTLE
1180 template
1181 class Track_relocs<64, false>;
1182 #endif
1183
1184 #ifdef HAVE_TARGET_64_BIG
1185 template
1186 class Track_relocs<64, true>;
1187 #endif
1188
1189 } // End namespace gold.