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 = this->adjust_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 (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_)
 237         {
 238           this->error(_("relocation section %u uses unexpected "
 239                         "symbol table %u"),
 240                       i, this->adjust_shndx(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                             layout->symtab_xindex(), layout->dynsym_xindex());
 512
 513   // We should no longer need the local symbol values.
 514   this->clear_local_symbols();
 515 }
 516
 517 // Sort a Read_multiple vector by file offset.
 518 struct Read_multiple_compare
 519 {
 520   inline bool
 521   operator()(const File_read::Read_multiple_entry& rme1,
 522              const File_read::Read_multiple_entry& rme2) const
 523   { return rme1.file_offset < rme2.file_offset; }
 524 };
 525
 526 // Write section data to the output file.  PSHDRS points to the
 527 // section headers.  Record the views in *PVIEWS for use when
 528 // relocating.
 529
 530 template<int size, bool big_endian>
 531 void
 532 Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
 533                                                Output_file* of,
 534                                                Views* pviews)
 535 {
 536   unsigned int shnum = this->shnum();
 537   const std::vector<Map_to_output>& map_sections(this->map_to_output());
 538
 539   File_read::Read_multiple rm;
 540   bool is_sorted = true;
 541
 542   const unsigned char* p = pshdrs + This::shdr_size;
 543   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 544     {
 545       View_size* pvs = &(*pviews)[i];
 546
 547       pvs->view = NULL;
 548
 549       const Output_section* os = map_sections[i].output_section;
 550       if (os == NULL)
 551         continue;
 552       off_t output_offset = map_sections[i].offset;
 553
 554       typename This::Shdr shdr(p);
 555
 556       if (shdr.get_sh_type() == elfcpp::SHT_NOBITS)
 557         continue;
 558
 559       if ((parameters->options().relocatable()
 560            || parameters->options().emit_relocs())
 561           && (shdr.get_sh_type() == elfcpp::SHT_REL
 562               || shdr.get_sh_type() == elfcpp::SHT_RELA)
 563           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
 564         {
 565           // This is a reloc section in a relocatable link or when
 566           // emitting relocs.  We don't need to read the input file.
 567           // The size and file offset are stored in the
 568           // Relocatable_relocs structure.
 569           Relocatable_relocs* rr = this->relocatable_relocs(i);
 570           gold_assert(rr != NULL);
 571           Output_data* posd = rr->output_data();
 572           gold_assert(posd != NULL);
 573
 574           pvs->offset = posd->offset();
 575           pvs->view_size = posd->data_size();
 576           pvs->view = of->get_output_view(pvs->offset, pvs->view_size);
 577           pvs->address = posd->address();
 578           pvs->is_input_output_view = false;
 579           pvs->is_postprocessing_view = false;
 580
 581           continue;
 582         }
 583
 584       // In the normal case, this input section is simply mapped to
 585       // the output section at offset OUTPUT_OFFSET.
 586
 587       // However, if OUTPUT_OFFSET == -1, then input data is handled
 588       // specially--e.g., a .eh_frame section.  The relocation
 589       // routines need to check for each reloc where it should be
 590       // applied.  For this case, we need an input/output view for the
 591       // entire contents of the section in the output file.  We don't
 592       // want to copy the contents of the input section to the output
 593       // section; the output section contents were already written,
 594       // and we waited for them in Relocate_task::is_runnable because
 595       // relocs_must_follow_section_writes is set for the object.
 596
 597       // Regardless of which of the above cases is true, we have to
 598       // check requires_postprocessing of the output section.  If that
 599       // is false, then we work with views of the output file
 600       // directly.  If it is true, then we work with a separate
 601       // buffer, and the output section is responsible for writing the
 602       // final data to the output file.
 603
 604       off_t output_section_offset;
 605       off_t output_section_size;
 606       if (!os->requires_postprocessing())
 607         {
 608           output_section_offset = os->offset();
 609           output_section_size = os->data_size();
 610         }
 611       else
 612         {
 613           output_section_offset = 0;
 614           output_section_size = os->postprocessing_buffer_size();
 615         }
 616
 617       off_t view_start;
 618       section_size_type view_size;
 619       if (output_offset != -1)
 620         {
 621           view_start = output_section_offset + output_offset;
 622           view_size = convert_to_section_size_type(shdr.get_sh_size());
 623         }
 624       else
 625         {
 626           view_start = output_section_offset;
 627           view_size = convert_to_section_size_type(output_section_size);
 628         }
 629
 630       if (view_size == 0)
 631         continue;
 632
 633       gold_assert(output_offset == -1
 634                   || (output_offset >= 0
 635                       && (output_offset + static_cast<off_t>(view_size)
 636                           <= output_section_size)));
 637
 638       unsigned char* view;
 639       if (os->requires_postprocessing())
 640         {
 641           unsigned char* buffer = os->postprocessing_buffer();
 642           view = buffer + view_start;
 643           if (output_offset != -1)
 644             {
 645               off_t sh_offset = shdr.get_sh_offset();
 646               if (!rm.empty() && rm.back().file_offset > sh_offset)
 647                 is_sorted = false;
 648               rm.push_back(File_read::Read_multiple_entry(sh_offset,
 649                                                           view_size, view));
 650             }
 651         }
 652       else
 653         {
 654           if (output_offset == -1)
 655             view = of->get_input_output_view(view_start, view_size);
 656           else
 657             {
 658               view = of->get_output_view(view_start, view_size);
 659               off_t sh_offset = shdr.get_sh_offset();
 660               if (!rm.empty() && rm.back().file_offset > sh_offset)
 661                 is_sorted = false;
 662               rm.push_back(File_read::Read_multiple_entry(sh_offset,
 663                                                           view_size, view));
 664             }
 665         }
 666
 667       pvs->view = view;
 668       pvs->address = os->address();
 669       if (output_offset != -1)
 670         pvs->address += output_offset;
 671       pvs->offset = view_start;
 672       pvs->view_size = view_size;
 673       pvs->is_input_output_view = output_offset == -1;
 674       pvs->is_postprocessing_view = os->requires_postprocessing();
 675     }
 676
 677   // Actually read the data.
 678   if (!rm.empty())
 679     {
 680       if (!is_sorted)
 681         std::sort(rm.begin(), rm.end(), Read_multiple_compare());
 682       this->read_multiple(rm);
 683     }
 684 }
 685
 686 // Relocate section data.  VIEWS points to the section data as views
 687 // in the output file.
 688
 689 template<int size, bool big_endian>
 690 void
 691 Sized_relobj<size, big_endian>::relocate_sections(
 692     const General_options& options,
 693     const Symbol_table* symtab,
 694     const Layout* layout,
 695     const unsigned char* pshdrs,
 696     Views* pviews)
 697 {
 698   unsigned int shnum = this->shnum();
 699   Sized_target<size, big_endian>* target = this->sized_target();
 700
 701   const std::vector<Map_to_output>& map_sections(this->map_to_output());
 702
 703   Relocate_info<size, big_endian> relinfo;
 704   relinfo.options = &options;
 705   relinfo.symtab = symtab;
 706   relinfo.layout = layout;
 707   relinfo.object = this;
 708
 709   const unsigned char* p = pshdrs + This::shdr_size;
 710   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
 711     {
 712       typename This::Shdr shdr(p);
 713
 714       unsigned int sh_type = shdr.get_sh_type();
 715       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
 716         continue;
 717
 718       unsigned int index = this->adjust_shndx(shdr.get_sh_info());
 719       if (index >= this->shnum())
 720         {
 721           this->error(_("relocation section %u has bad info %u"),
 722                       i, index);
 723           continue;
 724         }
 725
 726       Output_section* os = map_sections[index].output_section;
 727       if (os == NULL)
 728         {
 729           // This relocation section is against a section which we
 730           // discarded.
 731           continue;
 732         }
 733       off_t output_offset = map_sections[index].offset;
 734
 735       gold_assert((*pviews)[index].view != NULL);
 736       if (parameters->options().relocatable())
 737         gold_assert((*pviews)[i].view != NULL);
 738
 739       if (this->adjust_shndx(shdr.get_sh_link()) != this->symtab_shndx_)
 740         {
 741           gold_error(_("relocation section %u uses unexpected "
 742                        "symbol table %u"),
 743                      i, this->adjust_shndx(shdr.get_sh_link()));
 744           continue;
 745         }
 746
 747       off_t sh_size = shdr.get_sh_size();
 748       const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(),
 749                                                     sh_size, true, false);
 750
 751       unsigned int reloc_size;
 752       if (sh_type == elfcpp::SHT_REL)
 753         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
 754       else
 755         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 756
 757       if (reloc_size != shdr.get_sh_entsize())
 758         {
 759           gold_error(_("unexpected entsize for reloc section %u: %lu != %u"),
 760                      i, static_cast<unsigned long>(shdr.get_sh_entsize()),
 761                      reloc_size);
 762           continue;
 763         }
 764
 765       size_t reloc_count = sh_size / reloc_size;
 766       if (static_cast<off_t>(reloc_count * reloc_size) != sh_size)
 767         {
 768           gold_error(_("reloc section %u size %lu uneven"),
 769                      i, static_cast<unsigned long>(sh_size));
 770           continue;
 771         }
 772
 773       gold_assert(output_offset != -1
 774                   || this->relocs_must_follow_section_writes());
 775
 776       relinfo.reloc_shndx = i;
 777       relinfo.data_shndx = index;
 778       if (!parameters->options().relocatable())
 779         {
 780           target->relocate_section(&relinfo,
 781                                    sh_type,
 782                                    prelocs,
 783                                    reloc_count,
 784                                    os,
 785                                    output_offset == -1,
 786                                    (*pviews)[index].view,
 787                                    (*pviews)[index].address,
 788                                    (*pviews)[index].view_size);
 789           if (parameters->options().emit_relocs())
 790             this->emit_relocs(&relinfo, i, sh_type, prelocs, reloc_count,
 791                               os, output_offset,
 792                               (*pviews)[index].view,
 793                               (*pviews)[index].address,
 794                               (*pviews)[index].view_size,
 795                               (*pviews)[i].view,
 796                               (*pviews)[i].view_size);
 797         }
 798       else
 799         {
 800           Relocatable_relocs* rr = this->relocatable_relocs(i);
 801           target->relocate_for_relocatable(&relinfo,
 802                                            sh_type,
 803                                            prelocs,
 804                                            reloc_count,
 805                                            os,
 806                                            output_offset,
 807                                            rr,
 808                                            (*pviews)[index].view,
 809                                            (*pviews)[index].address,
 810                                            (*pviews)[index].view_size,
 811                                            (*pviews)[i].view,
 812                                            (*pviews)[i].view_size);
 813         }
 814     }
 815 }
 816
 817 // Emit the relocs for --emit-relocs.
 818
 819 template<int size, bool big_endian>
 820 void
 821 Sized_relobj<size, big_endian>::emit_relocs(
 822     const Relocate_info<size, big_endian>* relinfo,
 823     unsigned int i,
 824     unsigned int sh_type,
 825     const unsigned char* prelocs,
 826     size_t reloc_count,
 827     Output_section* output_section,
 828     off_t offset_in_output_section,
 829     unsigned char* view,
 830     typename elfcpp::Elf_types<size>::Elf_Addr address,
 831     section_size_type view_size,
 832     unsigned char* reloc_view,
 833     section_size_type reloc_view_size)
 834 {
 835   if (sh_type == elfcpp::SHT_REL)
 836     this->emit_relocs_reltype<elfcpp::SHT_REL>(relinfo, i, prelocs,
 837                                                reloc_count, output_section,
 838                                                offset_in_output_section,
 839                                                view, address, view_size,
 840                                                reloc_view, reloc_view_size);
 841   else
 842     {
 843       gold_assert(sh_type == elfcpp::SHT_RELA);
 844       this->emit_relocs_reltype<elfcpp::SHT_RELA>(relinfo, i, prelocs,
 845                                                   reloc_count, output_section,
 846                                                   offset_in_output_section,
 847                                                   view, address, view_size,
 848                                                   reloc_view, reloc_view_size);
 849     }
 850 }
 851
 852 // Emit the relocs for --emit-relocs, templatized on the type of the
 853 // relocation section.
 854
 855 template<int size, bool big_endian>
 856 template<int sh_type>
 857 void
 858 Sized_relobj<size, big_endian>::emit_relocs_reltype(
 859     const Relocate_info<size, big_endian>* relinfo,
 860     unsigned int i,
 861     const unsigned char* prelocs,
 862     size_t reloc_count,
 863     Output_section* output_section,
 864     off_t offset_in_output_section,
 865     unsigned char* view,
 866     typename elfcpp::Elf_types<size>::Elf_Addr address,
 867     section_size_type view_size,
 868     unsigned char* reloc_view,
 869     section_size_type reloc_view_size)
 870 {
 871   const Relocatable_relocs* rr = this->relocatable_relocs(i);
 872   relocate_for_relocatable<size, big_endian, sh_type>(
 873     relinfo,
 874     prelocs,
 875     reloc_count,
 876     output_section,
 877     offset_in_output_section,
 878     rr,
 879     view,
 880     address,
 881     view_size,
 882     reloc_view,
 883     reloc_view_size);
 884 }
 885
 886 // Create merge hash tables for the local symbols.  These are used to
 887 // speed up relocations.
 888
 889 template<int size, bool big_endian>
 890 void
 891 Sized_relobj<size, big_endian>::initialize_input_to_output_maps()
 892 {
 893   const unsigned int loccount = this->local_symbol_count_;
 894   for (unsigned int i = 1; i < loccount; ++i)
 895     {
 896       Symbol_value<size>& lv(this->local_values_[i]);
 897       lv.initialize_input_to_output_map(this);
 898     }
 899 }
 900
 901 // Free merge hash tables for the local symbols.
 902
 903 template<int size, bool big_endian>
 904 void
 905 Sized_relobj<size, big_endian>::free_input_to_output_maps()
 906 {
 907   const unsigned int loccount = this->local_symbol_count_;
 908   for (unsigned int i = 1; i < loccount; ++i)
 909     {
 910       Symbol_value<size>& lv(this->local_values_[i]);
 911       lv.free_input_to_output_map();
 912     }
 913 }
 914
 915 // Class Merged_symbol_value.
 916
 917 template<int size>
 918 void
 919 Merged_symbol_value<size>::initialize_input_to_output_map(
 920     const Relobj* object,
 921     unsigned int input_shndx)
 922 {
 923   Object_merge_map* map = object->merge_map();
 924   map->initialize_input_to_output_map<size>(input_shndx,
 925                                             this->output_start_address_,
 926                                             &this->output_addresses_);
 927 }
 928
 929 // Get the output value corresponding to an input offset if we
 930 // couldn't find it in the hash table.
 931
 932 template<int size>
 933 typename elfcpp::Elf_types<size>::Elf_Addr
 934 Merged_symbol_value<size>::value_from_output_section(
 935     const Relobj* object,
 936     unsigned int input_shndx,
 937     typename elfcpp::Elf_types<size>::Elf_Addr input_offset) const
 938 {
 939   section_offset_type output_offset;
 940   bool found = object->merge_map()->get_output_offset(NULL, input_shndx,
 941                                                       input_offset,
 942                                                       &output_offset);
 943
 944   // If this assertion fails, it means that some relocation was
 945   // against a portion of an input merge section which we didn't map
 946   // to the output file and we didn't explicitly discard.  We should
 947   // always map all portions of input merge sections.
 948   gold_assert(found);
 949
 950   if (output_offset == -1)
 951     return 0;
 952   else
 953     return this->output_start_address_ + output_offset;
 954 }
 955
 956 // Track_relocs methods.
 957
 958 // Initialize the class to track the relocs.  This gets the object,
 959 // the reloc section index, and the type of the relocs.  This returns
 960 // false if something goes wrong.
 961
 962 template<int size, bool big_endian>
 963 bool
 964 Track_relocs<size, big_endian>::initialize(
 965     Object* object,
 966     unsigned int reloc_shndx,
 967     unsigned int reloc_type)
 968 {
 969   // If RELOC_SHNDX is -1U, it means there is more than one reloc
 970   // section for the .eh_frame section.  We can't handle that case.
 971   if (reloc_shndx == -1U)
 972     return false;
 973
 974   // If RELOC_SHNDX is 0, there is no reloc section.
 975   if (reloc_shndx == 0)
 976     return true;
 977
 978   // Get the contents of the reloc section.
 979   this->prelocs_ = object->section_contents(reloc_shndx, &this->len_, false);
 980
 981   if (reloc_type == elfcpp::SHT_REL)
 982     this->reloc_size_ = elfcpp::Elf_sizes<size>::rel_size;
 983   else if (reloc_type == elfcpp::SHT_RELA)
 984     this->reloc_size_ = elfcpp::Elf_sizes<size>::rela_size;
 985   else
 986     gold_unreachable();
 987
 988   if (this->len_ % this->reloc_size_ != 0)
 989     {
 990       object->error(_("reloc section size %zu is not a multiple of "
 991                       "reloc size %d\n"),
 992                     static_cast<size_t>(this->len_),
 993                     this->reloc_size_);
 994       return false;
 995     }
 996
 997   return true;
 998 }
 999
1000 // Return the offset of the next reloc, or -1 if there isn't one.
1001
1002 template<int size, bool big_endian>
1003 off_t
1004 Track_relocs<size, big_endian>::next_offset() const
1005 {
1006   if (this->pos_ >= this->len_)
1007     return -1;
1008
1009   // Rel and Rela start out the same, so we can always use Rel to find
1010   // the r_offset value.
1011   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
1012   return rel.get_r_offset();
1013 }
1014
1015 // Return the index of the symbol referenced by the next reloc, or -1U
1016 // if there aren't any more relocs.
1017
1018 template<int size, bool big_endian>
1019 unsigned int
1020 Track_relocs<size, big_endian>::next_symndx() const
1021 {
1022   if (this->pos_ >= this->len_)
1023     return -1U;
1024
1025   // Rel and Rela start out the same, so we can use Rel to find the
1026   // symbol index.
1027   elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
1028   return elfcpp::elf_r_sym<size>(rel.get_r_info());
1029 }
1030
1031 // Advance to the next reloc whose r_offset is greater than or equal
1032 // to OFFSET.  Return the number of relocs we skip.
1033
1034 template<int size, bool big_endian>
1035 int
1036 Track_relocs<size, big_endian>::advance(off_t offset)
1037 {
1038   int ret = 0;
1039   while (this->pos_ < this->len_)
1040     {
1041       // Rel and Rela start out the same, so we can always use Rel to
1042       // find the r_offset value.
1043       elfcpp::Rel<size, big_endian> rel(this->prelocs_ + this->pos_);
1044       if (static_cast<off_t>(rel.get_r_offset()) >= offset)
1045         break;
1046       ++ret;
1047       this->pos_ += this->reloc_size_;
1048     }
1049   return ret;
1050 }
1051
1052 // Instantiate the templates we need.
1053
1054 #ifdef HAVE_TARGET_32_LITTLE
1055 template
1056 void
1057 Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
1058 #endif
1059
1060 #ifdef HAVE_TARGET_32_BIG
1061 template
1062 void
1063 Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
1064 #endif
1065
1066 #ifdef HAVE_TARGET_64_LITTLE
1067 template
1068 void
1069 Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
1070 #endif
1071
1072 #ifdef HAVE_TARGET_64_BIG
1073 template
1074 void
1075 Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
1076 #endif
1077
1078 #ifdef HAVE_TARGET_32_LITTLE
1079 template
1080 void
1081 Sized_relobj<32, false>::do_scan_relocs(const General_options& options,
1082                                         Symbol_table* symtab,
1083                                         Layout* layout,
1084                                         Read_relocs_data* rd);
1085 #endif
1086
1087 #ifdef HAVE_TARGET_32_BIG
1088 template
1089 void
1090 Sized_relobj<32, true>::do_scan_relocs(const General_options& options,
1091                                        Symbol_table* symtab,
1092                                        Layout* layout,
1093                                        Read_relocs_data* rd);
1094 #endif
1095
1096 #ifdef HAVE_TARGET_64_LITTLE
1097 template
1098 void
1099 Sized_relobj<64, false>::do_scan_relocs(const General_options& options,
1100                                         Symbol_table* symtab,
1101                                         Layout* layout,
1102                                         Read_relocs_data* rd);
1103 #endif
1104
1105 #ifdef HAVE_TARGET_64_BIG
1106 template
1107 void
1108 Sized_relobj<64, true>::do_scan_relocs(const General_options& options,
1109                                        Symbol_table* symtab,
1110                                        Layout* layout,
1111                                        Read_relocs_data* rd);
1112 #endif
1113
1114 #ifdef HAVE_TARGET_32_LITTLE
1115 template
1116 void
1117 Sized_relobj<32, false>::do_relocate(const General_options& options,
1118                                      const Symbol_table* symtab,
1119                                      const Layout* layout,
1120                                      Output_file* of);
1121 #endif
1122
1123 #ifdef HAVE_TARGET_32_BIG
1124 template
1125 void
1126 Sized_relobj<32, true>::do_relocate(const General_options& options,
1127                                     const Symbol_table* symtab,
1128                                     const Layout* layout,
1129                                     Output_file* of);
1130 #endif
1131
1132 #ifdef HAVE_TARGET_64_LITTLE
1133 template
1134 void
1135 Sized_relobj<64, false>::do_relocate(const General_options& options,
1136                                      const Symbol_table* symtab,
1137                                      const Layout* layout,
1138                                      Output_file* of);
1139 #endif
1140
1141 #ifdef HAVE_TARGET_64_BIG
1142 template
1143 void
1144 Sized_relobj<64, true>::do_relocate(const General_options& options,
1145                                     const Symbol_table* symtab,
1146                                     const Layout* layout,
1147                                     Output_file* of);
1148 #endif
1149
1150 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1151 template
1152 class Merged_symbol_value<32>;
1153 #endif
1154
1155 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1156 template
1157 class Merged_symbol_value<64>;
1158 #endif
1159
1160 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1161 template
1162 class Symbol_value<32>;
1163 #endif
1164
1165 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1166 template
1167 class Symbol_value<64>;
1168 #endif
1169
1170 #ifdef HAVE_TARGET_32_LITTLE
1171 template
1172 class Track_relocs<32, false>;
1173 #endif
1174
1175 #ifdef HAVE_TARGET_32_BIG
1176 template
1177 class Track_relocs<32, true>;
1178 #endif
1179
1180 #ifdef HAVE_TARGET_64_LITTLE
1181 template
1182 class Track_relocs<64, false>;
1183 #endif
1184
1185 #ifdef HAVE_TARGET_64_BIG
1186 template
1187 class Track_relocs<64, true>;
1188 #endif
1189
1190 } // End namespace gold.