gold/output.cc

   1 // output.cc -- manage the output file for gold
   2
   3 // Copyright 2006, 2007, 2008, 2009 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 <cstdlib>
  26 #include <cstring>
  27 #include <cerrno>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <sys/mman.h>
  31 #include <sys/stat.h>
  32 #include <algorithm>
  33 #include "libiberty.h"
  34
  35 #include "parameters.h"
  36 #include "object.h"
  37 #include "symtab.h"
  38 #include "reloc.h"
  39 #include "merge.h"
  40 #include "descriptors.h"
  41 #include "output.h"
  42
  43 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
  44 #ifndef MAP_ANONYMOUS
  45 # define MAP_ANONYMOUS  MAP_ANON
  46 #endif
  47
  48 #ifndef HAVE_POSIX_FALLOCATE
  49 // A dummy, non general, version of posix_fallocate.  Here we just set
  50 // the file size and hope that there is enough disk space.  FIXME: We
  51 // could allocate disk space by walking block by block and writing a
  52 // zero byte into each block.
  53 static int
  54 posix_fallocate(int o, off_t offset, off_t len)
  55 {
  56   return ftruncate(o, offset + len);
  57 }
  58 #endif // !defined(HAVE_POSIX_FALLOCATE)
  59
  60 namespace gold
  61 {
  62
  63 // Output_data variables.
  64
  65 bool Output_data::allocated_sizes_are_fixed;
  66
  67 // Output_data methods.
  68
  69 Output_data::~Output_data()
  70 {
  71 }
  72
  73 // Return the default alignment for the target size.
  74
  75 uint64_t
  76 Output_data::default_alignment()
  77 {
  78   return Output_data::default_alignment_for_size(
  79       parameters->target().get_size());
  80 }
  81
  82 // Return the default alignment for a size--32 or 64.
  83
  84 uint64_t
  85 Output_data::default_alignment_for_size(int size)
  86 {
  87   if (size == 32)
  88     return 4;
  89   else if (size == 64)
  90     return 8;
  91   else
  92     gold_unreachable();
  93 }
  94
  95 // Output_section_header methods.  This currently assumes that the
  96 // segment and section lists are complete at construction time.
  97
  98 Output_section_headers::Output_section_headers(
  99     const Layout* layout,
 100     const Layout::Segment_list* segment_list,
 101     const Layout::Section_list* section_list,
 102     const Layout::Section_list* unattached_section_list,
 103     const Stringpool* secnamepool,
 104     const Output_section* shstrtab_section)
 105   : layout_(layout),
 106     segment_list_(segment_list),
 107     section_list_(section_list),
 108     unattached_section_list_(unattached_section_list),
 109     secnamepool_(secnamepool),
 110     shstrtab_section_(shstrtab_section)
 111 {
 112 }
 113
 114 // Compute the current data size.
 115
 116 off_t
 117 Output_section_headers::do_size() const
 118 {
 119   // Count all the sections.  Start with 1 for the null section.
 120   off_t count = 1;
 121   if (!parameters->options().relocatable())
 122     {
 123       for (Layout::Segment_list::const_iterator p =
 124              this->segment_list_->begin();
 125            p != this->segment_list_->end();
 126            ++p)
 127         if ((*p)->type() == elfcpp::PT_LOAD)
 128           count += (*p)->output_section_count();
 129     }
 130   else
 131     {
 132       for (Layout::Section_list::const_iterator p =
 133              this->section_list_->begin();
 134            p != this->section_list_->end();
 135            ++p)
 136         if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
 137           ++count;
 138     }
 139   count += this->unattached_section_list_->size();
 140
 141   const int size = parameters->target().get_size();
 142   int shdr_size;
 143   if (size == 32)
 144     shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
 145   else if (size == 64)
 146     shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
 147   else
 148     gold_unreachable();
 149
 150   return count * shdr_size;
 151 }
 152
 153 // Write out the section headers.
 154
 155 void
 156 Output_section_headers::do_write(Output_file* of)
 157 {
 158   switch (parameters->size_and_endianness())
 159     {
 160 #ifdef HAVE_TARGET_32_LITTLE
 161     case Parameters::TARGET_32_LITTLE:
 162       this->do_sized_write<32, false>(of);
 163       break;
 164 #endif
 165 #ifdef HAVE_TARGET_32_BIG
 166     case Parameters::TARGET_32_BIG:
 167       this->do_sized_write<32, true>(of);
 168       break;
 169 #endif
 170 #ifdef HAVE_TARGET_64_LITTLE
 171     case Parameters::TARGET_64_LITTLE:
 172       this->do_sized_write<64, false>(of);
 173       break;
 174 #endif
 175 #ifdef HAVE_TARGET_64_BIG
 176     case Parameters::TARGET_64_BIG:
 177       this->do_sized_write<64, true>(of);
 178       break;
 179 #endif
 180     default:
 181       gold_unreachable();
 182     }
 183 }
 184
 185 template<int size, bool big_endian>
 186 void
 187 Output_section_headers::do_sized_write(Output_file* of)
 188 {
 189   off_t all_shdrs_size = this->data_size();
 190   unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
 191
 192   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 193   unsigned char* v = view;
 194
 195   {
 196     typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
 197     oshdr.put_sh_name(0);
 198     oshdr.put_sh_type(elfcpp::SHT_NULL);
 199     oshdr.put_sh_flags(0);
 200     oshdr.put_sh_addr(0);
 201     oshdr.put_sh_offset(0);
 202
 203     size_t section_count = (this->data_size()
 204                             / elfcpp::Elf_sizes<size>::shdr_size);
 205     if (section_count < elfcpp::SHN_LORESERVE)
 206       oshdr.put_sh_size(0);
 207     else
 208       oshdr.put_sh_size(section_count);
 209
 210     unsigned int shstrndx = this->shstrtab_section_->out_shndx();
 211     if (shstrndx < elfcpp::SHN_LORESERVE)
 212       oshdr.put_sh_link(0);
 213     else
 214       oshdr.put_sh_link(shstrndx);
 215
 216     oshdr.put_sh_info(0);
 217     oshdr.put_sh_addralign(0);
 218     oshdr.put_sh_entsize(0);
 219   }
 220
 221   v += shdr_size;
 222
 223   unsigned int shndx = 1;
 224   if (!parameters->options().relocatable())
 225     {
 226       for (Layout::Segment_list::const_iterator p =
 227              this->segment_list_->begin();
 228            p != this->segment_list_->end();
 229            ++p)
 230         v = (*p)->write_section_headers<size, big_endian>(this->layout_,
 231                                                           this->secnamepool_,
 232                                                           v,
 233                                                           &shndx);
 234     }
 235   else
 236     {
 237       for (Layout::Section_list::const_iterator p =
 238              this->section_list_->begin();
 239            p != this->section_list_->end();
 240            ++p)
 241         {
 242           // We do unallocated sections below, except that group
 243           // sections have to come first.
 244           if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
 245               && (*p)->type() != elfcpp::SHT_GROUP)
 246             continue;
 247           gold_assert(shndx == (*p)->out_shndx());
 248           elfcpp::Shdr_write<size, big_endian> oshdr(v);
 249           (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
 250           v += shdr_size;
 251           ++shndx;
 252         }
 253     }
 254
 255   for (Layout::Section_list::const_iterator p =
 256          this->unattached_section_list_->begin();
 257        p != this->unattached_section_list_->end();
 258        ++p)
 259     {
 260       // For a relocatable link, we did unallocated group sections
 261       // above, since they have to come first.
 262       if ((*p)->type() == elfcpp::SHT_GROUP
 263           && parameters->options().relocatable())
 264         continue;
 265       gold_assert(shndx == (*p)->out_shndx());
 266       elfcpp::Shdr_write<size, big_endian> oshdr(v);
 267       (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
 268       v += shdr_size;
 269       ++shndx;
 270     }
 271
 272   of->write_output_view(this->offset(), all_shdrs_size, view);
 273 }
 274
 275 // Output_segment_header methods.
 276
 277 Output_segment_headers::Output_segment_headers(
 278     const Layout::Segment_list& segment_list)
 279   : segment_list_(segment_list)
 280 {
 281 }
 282
 283 void
 284 Output_segment_headers::do_write(Output_file* of)
 285 {
 286   switch (parameters->size_and_endianness())
 287     {
 288 #ifdef HAVE_TARGET_32_LITTLE
 289     case Parameters::TARGET_32_LITTLE:
 290       this->do_sized_write<32, false>(of);
 291       break;
 292 #endif
 293 #ifdef HAVE_TARGET_32_BIG
 294     case Parameters::TARGET_32_BIG:
 295       this->do_sized_write<32, true>(of);
 296       break;
 297 #endif
 298 #ifdef HAVE_TARGET_64_LITTLE
 299     case Parameters::TARGET_64_LITTLE:
 300       this->do_sized_write<64, false>(of);
 301       break;
 302 #endif
 303 #ifdef HAVE_TARGET_64_BIG
 304     case Parameters::TARGET_64_BIG:
 305       this->do_sized_write<64, true>(of);
 306       break;
 307 #endif
 308     default:
 309       gold_unreachable();
 310     }
 311 }
 312
 313 template<int size, bool big_endian>
 314 void
 315 Output_segment_headers::do_sized_write(Output_file* of)
 316 {
 317   const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
 318   off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
 319   gold_assert(all_phdrs_size == this->data_size());
 320   unsigned char* view = of->get_output_view(this->offset(),
 321                                             all_phdrs_size);
 322   unsigned char* v = view;
 323   for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
 324        p != this->segment_list_.end();
 325        ++p)
 326     {
 327       elfcpp::Phdr_write<size, big_endian> ophdr(v);
 328       (*p)->write_header(&ophdr);
 329       v += phdr_size;
 330     }
 331
 332   gold_assert(v - view == all_phdrs_size);
 333
 334   of->write_output_view(this->offset(), all_phdrs_size, view);
 335 }
 336
 337 off_t
 338 Output_segment_headers::do_size() const
 339 {
 340   const int size = parameters->target().get_size();
 341   int phdr_size;
 342   if (size == 32)
 343     phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
 344   else if (size == 64)
 345     phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
 346   else
 347     gold_unreachable();
 348
 349   return this->segment_list_.size() * phdr_size;
 350 }
 351
 352 // Output_file_header methods.
 353
 354 Output_file_header::Output_file_header(const Target* target,
 355                                        const Symbol_table* symtab,
 356                                        const Output_segment_headers* osh,
 357                                        const char* entry)
 358   : target_(target),
 359     symtab_(symtab),
 360     segment_header_(osh),
 361     section_header_(NULL),
 362     shstrtab_(NULL),
 363     entry_(entry)
 364 {
 365   this->set_data_size(this->do_size());
 366 }
 367
 368 // Set the section table information for a file header.
 369
 370 void
 371 Output_file_header::set_section_info(const Output_section_headers* shdrs,
 372                                      const Output_section* shstrtab)
 373 {
 374   this->section_header_ = shdrs;
 375   this->shstrtab_ = shstrtab;
 376 }
 377
 378 // Write out the file header.
 379
 380 void
 381 Output_file_header::do_write(Output_file* of)
 382 {
 383   gold_assert(this->offset() == 0);
 384
 385   switch (parameters->size_and_endianness())
 386     {
 387 #ifdef HAVE_TARGET_32_LITTLE
 388     case Parameters::TARGET_32_LITTLE:
 389       this->do_sized_write<32, false>(of);
 390       break;
 391 #endif
 392 #ifdef HAVE_TARGET_32_BIG
 393     case Parameters::TARGET_32_BIG:
 394       this->do_sized_write<32, true>(of);
 395       break;
 396 #endif
 397 #ifdef HAVE_TARGET_64_LITTLE
 398     case Parameters::TARGET_64_LITTLE:
 399       this->do_sized_write<64, false>(of);
 400       break;
 401 #endif
 402 #ifdef HAVE_TARGET_64_BIG
 403     case Parameters::TARGET_64_BIG:
 404       this->do_sized_write<64, true>(of);
 405       break;
 406 #endif
 407     default:
 408       gold_unreachable();
 409     }
 410 }
 411
 412 // Write out the file header with appropriate size and endianess.
 413
 414 template<int size, bool big_endian>
 415 void
 416 Output_file_header::do_sized_write(Output_file* of)
 417 {
 418   gold_assert(this->offset() == 0);
 419
 420   int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
 421   unsigned char* view = of->get_output_view(0, ehdr_size);
 422   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
 423
 424   unsigned char e_ident[elfcpp::EI_NIDENT];
 425   memset(e_ident, 0, elfcpp::EI_NIDENT);
 426   e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
 427   e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
 428   e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
 429   e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
 430   if (size == 32)
 431     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
 432   else if (size == 64)
 433     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
 434   else
 435     gold_unreachable();
 436   e_ident[elfcpp::EI_DATA] = (big_endian
 437                               ? elfcpp::ELFDATA2MSB
 438                               : elfcpp::ELFDATA2LSB);
 439   e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
 440   oehdr.put_e_ident(e_ident);
 441
 442   elfcpp::ET e_type;
 443   if (parameters->options().relocatable())
 444     e_type = elfcpp::ET_REL;
 445   else if (parameters->options().output_is_position_independent())
 446     e_type = elfcpp::ET_DYN;
 447   else
 448     e_type = elfcpp::ET_EXEC;
 449   oehdr.put_e_type(e_type);
 450
 451   oehdr.put_e_machine(this->target_->machine_code());
 452   oehdr.put_e_version(elfcpp::EV_CURRENT);
 453
 454   oehdr.put_e_entry(this->entry<size>());
 455
 456   if (this->segment_header_ == NULL)
 457     oehdr.put_e_phoff(0);
 458   else
 459     oehdr.put_e_phoff(this->segment_header_->offset());
 460
 461   oehdr.put_e_shoff(this->section_header_->offset());
 462   oehdr.put_e_flags(this->target_->processor_specific_flags());
 463   oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
 464
 465   if (this->segment_header_ == NULL)
 466     {
 467       oehdr.put_e_phentsize(0);
 468       oehdr.put_e_phnum(0);
 469     }
 470   else
 471     {
 472       oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
 473       oehdr.put_e_phnum(this->segment_header_->data_size()
 474                         / elfcpp::Elf_sizes<size>::phdr_size);
 475     }
 476
 477   oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
 478   size_t section_count = (this->section_header_->data_size()
 479                           / elfcpp::Elf_sizes<size>::shdr_size);
 480
 481   if (section_count < elfcpp::SHN_LORESERVE)
 482     oehdr.put_e_shnum(this->section_header_->data_size()
 483                       / elfcpp::Elf_sizes<size>::shdr_size);
 484   else
 485     oehdr.put_e_shnum(0);
 486
 487   unsigned int shstrndx = this->shstrtab_->out_shndx();
 488   if (shstrndx < elfcpp::SHN_LORESERVE)
 489     oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
 490   else
 491     oehdr.put_e_shstrndx(elfcpp::SHN_XINDEX);
 492
 493   // Let the target adjust the ELF header, e.g., to set EI_OSABI in
 494   // the e_ident field.
 495   parameters->target().adjust_elf_header(view, ehdr_size);
 496
 497   of->write_output_view(0, ehdr_size, view);
 498 }
 499
 500 // Return the value to use for the entry address.  THIS->ENTRY_ is the
 501 // symbol specified on the command line, if any.
 502
 503 template<int size>
 504 typename elfcpp::Elf_types<size>::Elf_Addr
 505 Output_file_header::entry()
 506 {
 507   const bool should_issue_warning = (this->entry_ != NULL
 508                                      && !parameters->options().relocatable()
 509                                      && !parameters->options().shared());
 510
 511   // FIXME: Need to support target specific entry symbol.
 512   const char* entry = this->entry_;
 513   if (entry == NULL)
 514     entry = "_start";
 515
 516   Symbol* sym = this->symtab_->lookup(entry);
 517
 518   typename Sized_symbol<size>::Value_type v;
 519   if (sym != NULL)
 520     {
 521       Sized_symbol<size>* ssym;
 522       ssym = this->symtab_->get_sized_symbol<size>(sym);
 523       if (!ssym->is_defined() && should_issue_warning)
 524         gold_warning("entry symbol '%s' exists but is not defined", entry);
 525       v = ssym->value();
 526     }
 527   else
 528     {
 529       // We couldn't find the entry symbol.  See if we can parse it as
 530       // a number.  This supports, e.g., -e 0x1000.
 531       char* endptr;
 532       v = strtoull(entry, &endptr, 0);
 533       if (*endptr != '\0')
 534         {
 535           if (should_issue_warning)
 536             gold_warning("cannot find entry symbol '%s'", entry);
 537           v = 0;
 538         }
 539     }
 540
 541   return v;
 542 }
 543
 544 // Compute the current data size.
 545
 546 off_t
 547 Output_file_header::do_size() const
 548 {
 549   const int size = parameters->target().get_size();
 550   if (size == 32)
 551     return elfcpp::Elf_sizes<32>::ehdr_size;
 552   else if (size == 64)
 553     return elfcpp::Elf_sizes<64>::ehdr_size;
 554   else
 555     gold_unreachable();
 556 }
 557
 558 // Output_data_const methods.
 559
 560 void
 561 Output_data_const::do_write(Output_file* of)
 562 {
 563   of->write(this->offset(), this->data_.data(), this->data_.size());
 564 }
 565
 566 // Output_data_const_buffer methods.
 567
 568 void
 569 Output_data_const_buffer::do_write(Output_file* of)
 570 {
 571   of->write(this->offset(), this->p_, this->data_size());
 572 }
 573
 574 // Output_section_data methods.
 575
 576 // Record the output section, and set the entry size and such.
 577
 578 void
 579 Output_section_data::set_output_section(Output_section* os)
 580 {
 581   gold_assert(this->output_section_ == NULL);
 582   this->output_section_ = os;
 583   this->do_adjust_output_section(os);
 584 }
 585
 586 // Return the section index of the output section.
 587
 588 unsigned int
 589 Output_section_data::do_out_shndx() const
 590 {
 591   gold_assert(this->output_section_ != NULL);
 592   return this->output_section_->out_shndx();
 593 }
 594
 595 // Set the alignment, which means we may need to update the alignment
 596 // of the output section.
 597
 598 void
 599 Output_section_data::set_addralign(uint64_t addralign)
 600 {
 601   this->addralign_ = addralign;
 602   if (this->output_section_ != NULL
 603       && this->output_section_->addralign() < addralign)
 604     this->output_section_->set_addralign(addralign);
 605 }
 606
 607 // Output_data_strtab methods.
 608
 609 // Set the final data size.
 610
 611 void
 612 Output_data_strtab::set_final_data_size()
 613 {
 614   this->strtab_->set_string_offsets();
 615   this->set_data_size(this->strtab_->get_strtab_size());
 616 }
 617
 618 // Write out a string table.
 619
 620 void
 621 Output_data_strtab::do_write(Output_file* of)
 622 {
 623   this->strtab_->write(of, this->offset());
 624 }
 625
 626 // Output_reloc methods.
 627
 628 // A reloc against a global symbol.
 629
 630 template<bool dynamic, int size, bool big_endian>
 631 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 632     Symbol* gsym,
 633     unsigned int type,
 634     Output_data* od,
 635     Address address,
 636     bool is_relative)
 637   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
 638     is_relative_(is_relative), is_section_symbol_(false), shndx_(INVALID_CODE)
 639 {
 640   // this->type_ is a bitfield; make sure TYPE fits.
 641   gold_assert(this->type_ == type);
 642   this->u1_.gsym = gsym;
 643   this->u2_.od = od;
 644   if (dynamic)
 645     this->set_needs_dynsym_index();
 646 }
 647
 648 template<bool dynamic, int size, bool big_endian>
 649 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 650     Symbol* gsym,
 651     unsigned int type,
 652     Sized_relobj<size, big_endian>* relobj,
 653     unsigned int shndx,
 654     Address address,
 655     bool is_relative)
 656   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
 657     is_relative_(is_relative), is_section_symbol_(false), shndx_(shndx)
 658 {
 659   gold_assert(shndx != INVALID_CODE);
 660   // this->type_ is a bitfield; make sure TYPE fits.
 661   gold_assert(this->type_ == type);
 662   this->u1_.gsym = gsym;
 663   this->u2_.relobj = relobj;
 664   if (dynamic)
 665     this->set_needs_dynsym_index();
 666 }
 667
 668 // A reloc against a local symbol.
 669
 670 template<bool dynamic, int size, bool big_endian>
 671 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 672     Sized_relobj<size, big_endian>* relobj,
 673     unsigned int local_sym_index,
 674     unsigned int type,
 675     Output_data* od,
 676     Address address,
 677     bool is_relative,
 678     bool is_section_symbol)
 679   : address_(address), local_sym_index_(local_sym_index), type_(type),
 680     is_relative_(is_relative), is_section_symbol_(is_section_symbol),
 681     shndx_(INVALID_CODE)
 682 {
 683   gold_assert(local_sym_index != GSYM_CODE
 684               && local_sym_index != INVALID_CODE);
 685   // this->type_ is a bitfield; make sure TYPE fits.
 686   gold_assert(this->type_ == type);
 687   this->u1_.relobj = relobj;
 688   this->u2_.od = od;
 689   if (dynamic)
 690     this->set_needs_dynsym_index();
 691 }
 692
 693 template<bool dynamic, int size, bool big_endian>
 694 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 695     Sized_relobj<size, big_endian>* relobj,
 696     unsigned int local_sym_index,
 697     unsigned int type,
 698     unsigned int shndx,
 699     Address address,
 700     bool is_relative,
 701     bool is_section_symbol)
 702   : address_(address), local_sym_index_(local_sym_index), type_(type),
 703     is_relative_(is_relative), is_section_symbol_(is_section_symbol),
 704     shndx_(shndx)
 705 {
 706   gold_assert(local_sym_index != GSYM_CODE
 707               && local_sym_index != INVALID_CODE);
 708   gold_assert(shndx != INVALID_CODE);
 709   // this->type_ is a bitfield; make sure TYPE fits.
 710   gold_assert(this->type_ == type);
 711   this->u1_.relobj = relobj;
 712   this->u2_.relobj = relobj;
 713   if (dynamic)
 714     this->set_needs_dynsym_index();
 715 }
 716
 717 // A reloc against the STT_SECTION symbol of an output section.
 718
 719 template<bool dynamic, int size, bool big_endian>
 720 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 721     Output_section* os,
 722     unsigned int type,
 723     Output_data* od,
 724     Address address)
 725   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
 726     is_relative_(false), is_section_symbol_(true), shndx_(INVALID_CODE)
 727 {
 728   // this->type_ is a bitfield; make sure TYPE fits.
 729   gold_assert(this->type_ == type);
 730   this->u1_.os = os;
 731   this->u2_.od = od;
 732   if (dynamic)
 733     this->set_needs_dynsym_index();
 734   else
 735     os->set_needs_symtab_index();
 736 }
 737
 738 template<bool dynamic, int size, bool big_endian>
 739 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 740     Output_section* os,
 741     unsigned int type,
 742     Sized_relobj<size, big_endian>* relobj,
 743     unsigned int shndx,
 744     Address address)
 745   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
 746     is_relative_(false), is_section_symbol_(true), shndx_(shndx)
 747 {
 748   gold_assert(shndx != INVALID_CODE);
 749   // this->type_ is a bitfield; make sure TYPE fits.
 750   gold_assert(this->type_ == type);
 751   this->u1_.os = os;
 752   this->u2_.relobj = relobj;
 753   if (dynamic)
 754     this->set_needs_dynsym_index();
 755   else
 756     os->set_needs_symtab_index();
 757 }
 758
 759 // Record that we need a dynamic symbol index for this relocation.
 760
 761 template<bool dynamic, int size, bool big_endian>
 762 void
 763 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
 764 set_needs_dynsym_index()
 765 {
 766   if (this->is_relative_)
 767     return;
 768   switch (this->local_sym_index_)
 769     {
 770     case INVALID_CODE:
 771       gold_unreachable();
 772
 773     case GSYM_CODE:
 774       this->u1_.gsym->set_needs_dynsym_entry();
 775       break;
 776
 777     case SECTION_CODE:
 778       this->u1_.os->set_needs_dynsym_index();
 779       break;
 780
 781     case 0:
 782       break;
 783
 784     default:
 785       {
 786         const unsigned int lsi = this->local_sym_index_;
 787         if (!this->is_section_symbol_)
 788           this->u1_.relobj->set_needs_output_dynsym_entry(lsi);
 789         else
 790           this->u1_.relobj->output_section(lsi)->set_needs_dynsym_index();
 791       }
 792       break;
 793     }
 794 }
 795
 796 // Get the symbol index of a relocation.
 797
 798 template<bool dynamic, int size, bool big_endian>
 799 unsigned int
 800 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 801   const
 802 {
 803   unsigned int index;
 804   switch (this->local_sym_index_)
 805     {
 806     case INVALID_CODE:
 807       gold_unreachable();
 808
 809     case GSYM_CODE:
 810       if (this->u1_.gsym == NULL)
 811         index = 0;
 812       else if (dynamic)
 813         index = this->u1_.gsym->dynsym_index();
 814       else
 815         index = this->u1_.gsym->symtab_index();
 816       break;
 817
 818     case SECTION_CODE:
 819       if (dynamic)
 820         index = this->u1_.os->dynsym_index();
 821       else
 822         index = this->u1_.os->symtab_index();
 823       break;
 824
 825     case 0:
 826       // Relocations without symbols use a symbol index of 0.
 827       index = 0;
 828       break;
 829
 830     default:
 831       {
 832         const unsigned int lsi = this->local_sym_index_;
 833         if (!this->is_section_symbol_)
 834           {
 835             if (dynamic)
 836               index = this->u1_.relobj->dynsym_index(lsi);
 837             else
 838               index = this->u1_.relobj->symtab_index(lsi);
 839           }
 840         else
 841           {
 842             Output_section* os = this->u1_.relobj->output_section(lsi);
 843             gold_assert(os != NULL);
 844             if (dynamic)
 845               index = os->dynsym_index();
 846             else
 847               index = os->symtab_index();
 848           }
 849       }
 850       break;
 851     }
 852   gold_assert(index != -1U);
 853   return index;
 854 }
 855
 856 // For a local section symbol, get the address of the offset ADDEND
 857 // within the input section.
 858
 859 template<bool dynamic, int size, bool big_endian>
 860 typename elfcpp::Elf_types<size>::Elf_Addr
 861 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
 862   local_section_offset(Addend addend) const
 863 {
 864   gold_assert(this->local_sym_index_ != GSYM_CODE
 865               && this->local_sym_index_ != SECTION_CODE
 866               && this->local_sym_index_ != INVALID_CODE
 867               && this->is_section_symbol_);
 868   const unsigned int lsi = this->local_sym_index_;
 869   Output_section* os = this->u1_.relobj->output_section(lsi);
 870   gold_assert(os != NULL);
 871   Address offset = this->u1_.relobj->get_output_section_offset(lsi);
 872   if (offset != invalid_address)
 873     return offset + addend;
 874   // This is a merge section.
 875   offset = os->output_address(this->u1_.relobj, lsi, addend);
 876   gold_assert(offset != invalid_address);
 877   return offset;
 878 }
 879
 880 // Get the output address of a relocation.
 881
 882 template<bool dynamic, int size, bool big_endian>
 883 typename elfcpp::Elf_types<size>::Elf_Addr
 884 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const
 885 {
 886   Address address = this->address_;
 887   if (this->shndx_ != INVALID_CODE)
 888     {
 889       Output_section* os = this->u2_.relobj->output_section(this->shndx_);
 890       gold_assert(os != NULL);
 891       Address off = this->u2_.relobj->get_output_section_offset(this->shndx_);
 892       if (off != invalid_address)
 893         address += os->address() + off;
 894       else
 895         {
 896           address = os->output_address(this->u2_.relobj, this->shndx_,
 897                                        address);
 898           gold_assert(address != invalid_address);
 899         }
 900     }
 901   else if (this->u2_.od != NULL)
 902     address += this->u2_.od->address();
 903   return address;
 904 }
 905
 906 // Write out the offset and info fields of a Rel or Rela relocation
 907 // entry.
 908
 909 template<bool dynamic, int size, bool big_endian>
 910 template<typename Write_rel>
 911 void
 912 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
 913     Write_rel* wr) const
 914 {
 915   wr->put_r_offset(this->get_address());
 916   unsigned int sym_index = this->is_relative_ ? 0 : this->get_symbol_index();
 917   wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
 918 }
 919
 920 // Write out a Rel relocation.
 921
 922 template<bool dynamic, int size, bool big_endian>
 923 void
 924 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
 925     unsigned char* pov) const
 926 {
 927   elfcpp::Rel_write<size, big_endian> orel(pov);
 928   this->write_rel(&orel);
 929 }
 930
 931 // Get the value of the symbol referred to by a Rel relocation.
 932
 933 template<bool dynamic, int size, bool big_endian>
 934 typename elfcpp::Elf_types<size>::Elf_Addr
 935 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
 936     Addend addend) const
 937 {
 938   if (this->local_sym_index_ == GSYM_CODE)
 939     {
 940       const Sized_symbol<size>* sym;
 941       sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
 942       return sym->value() + addend;
 943     }
 944   gold_assert(this->local_sym_index_ != SECTION_CODE
 945               && this->local_sym_index_ != INVALID_CODE
 946               && !this->is_section_symbol_);
 947   const unsigned int lsi = this->local_sym_index_;
 948   const Symbol_value<size>* symval = this->u1_.relobj->local_symbol(lsi);
 949   return symval->value(this->u1_.relobj, addend);
 950 }
 951
 952 // Reloc comparison.  This function sorts the dynamic relocs for the
 953 // benefit of the dynamic linker.  First we sort all relative relocs
 954 // to the front.  Among relative relocs, we sort by output address.
 955 // Among non-relative relocs, we sort by symbol index, then by output
 956 // address.
 957
 958 template<bool dynamic, int size, bool big_endian>
 959 int
 960 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
 961   compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
 962     const
 963 {
 964   if (this->is_relative_)
 965     {
 966       if (!r2.is_relative_)
 967         return -1;
 968       // Otherwise sort by reloc address below.
 969     }
 970   else if (r2.is_relative_)
 971     return 1;
 972   else
 973     {
 974       unsigned int sym1 = this->get_symbol_index();
 975       unsigned int sym2 = r2.get_symbol_index();
 976       if (sym1 < sym2)
 977         return -1;
 978       else if (sym1 > sym2)
 979         return 1;
 980       // Otherwise sort by reloc address.
 981     }
 982
 983   section_offset_type addr1 = this->get_address();
 984   section_offset_type addr2 = r2.get_address();
 985   if (addr1 < addr2)
 986     return -1;
 987   else if (addr1 > addr2)
 988     return 1;
 989
 990   // Final tie breaker, in order to generate the same output on any
 991   // host: reloc type.
 992   unsigned int type1 = this->type_;
 993   unsigned int type2 = r2.type_;
 994   if (type1 < type2)
 995     return -1;
 996   else if (type1 > type2)
 997     return 1;
 998
 999   // These relocs appear to be exactly the same.
1000   return 0;
1001 }
1002
1003 // Write out a Rela relocation.
1004
1005 template<bool dynamic, int size, bool big_endian>
1006 void
1007 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
1008     unsigned char* pov) const
1009 {
1010   elfcpp::Rela_write<size, big_endian> orel(pov);
1011   this->rel_.write_rel(&orel);
1012   Addend addend = this->addend_;
1013   if (this->rel_.is_relative())
1014     addend = this->rel_.symbol_value(addend);
1015   else if (this->rel_.is_local_section_symbol())
1016     addend = this->rel_.local_section_offset(addend);
1017   orel.put_r_addend(addend);
1018 }
1019
1020 // Output_data_reloc_base methods.
1021
1022 // Adjust the output section.
1023
1024 template<int sh_type, bool dynamic, int size, bool big_endian>
1025 void
1026 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
1027     ::do_adjust_output_section(Output_section* os)
1028 {
1029   if (sh_type == elfcpp::SHT_REL)
1030     os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1031   else if (sh_type == elfcpp::SHT_RELA)
1032     os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1033   else
1034     gold_unreachable();
1035   if (dynamic)
1036     os->set_should_link_to_dynsym();
1037   else
1038     os->set_should_link_to_symtab();
1039 }
1040
1041 // Write out relocation data.
1042
1043 template<int sh_type, bool dynamic, int size, bool big_endian>
1044 void
1045 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
1046     Output_file* of)
1047 {
1048   const off_t off = this->offset();
1049   const off_t oview_size = this->data_size();
1050   unsigned char* const oview = of->get_output_view(off, oview_size);
1051
1052   if (this->sort_relocs_)
1053     {
1054       gold_assert(dynamic);
1055       std::sort(this->relocs_.begin(), this->relocs_.end(),
1056                 Sort_relocs_comparison());
1057     }
1058
1059   unsigned char* pov = oview;
1060   for (typename Relocs::const_iterator p = this->relocs_.begin();
1061        p != this->relocs_.end();
1062        ++p)
1063     {
1064       p->write(pov);
1065       pov += reloc_size;
1066     }
1067
1068   gold_assert(pov - oview == oview_size);
1069
1070   of->write_output_view(off, oview_size, oview);
1071
1072   // We no longer need the relocation entries.
1073   this->relocs_.clear();
1074 }
1075
1076 // Class Output_relocatable_relocs.
1077
1078 template<int sh_type, int size, bool big_endian>
1079 void
1080 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size()
1081 {
1082   this->set_data_size(this->rr_->output_reloc_count()
1083                       * Reloc_types<sh_type, size, big_endian>::reloc_size);
1084 }
1085
1086 // class Output_data_group.
1087
1088 template<int size, bool big_endian>
1089 Output_data_group<size, big_endian>::Output_data_group(
1090     Sized_relobj<size, big_endian>* relobj,
1091     section_size_type entry_count,
1092     elfcpp::Elf_Word flags,
1093     std::vector<unsigned int>* input_shndxes)
1094   : Output_section_data(entry_count * 4, 4, false),
1095     relobj_(relobj),
1096     flags_(flags)
1097 {
1098   this->input_shndxes_.swap(*input_shndxes);
1099 }
1100
1101 // Write out the section group, which means translating the section
1102 // indexes to apply to the output file.
1103
1104 template<int size, bool big_endian>
1105 void
1106 Output_data_group<size, big_endian>::do_write(Output_file* of)
1107 {
1108   const off_t off = this->offset();
1109   const section_size_type oview_size =
1110     convert_to_section_size_type(this->data_size());
1111   unsigned char* const oview = of->get_output_view(off, oview_size);
1112
1113   elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview);
1114   elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_);
1115   ++contents;
1116
1117   for (std::vector<unsigned int>::const_iterator p =
1118          this->input_shndxes_.begin();
1119        p != this->input_shndxes_.end();
1120        ++p, ++contents)
1121     {
1122       Output_section* os = this->relobj_->output_section(*p);
1123
1124       unsigned int output_shndx;
1125       if (os != NULL)
1126         output_shndx = os->out_shndx();
1127       else
1128         {
1129           this->relobj_->error(_("section group retained but "
1130                                  "group element discarded"));
1131           output_shndx = 0;
1132         }
1133
1134       elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx);
1135     }
1136
1137   size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview;
1138   gold_assert(wrote == oview_size);
1139
1140   of->write_output_view(off, oview_size, oview);
1141
1142   // We no longer need this information.
1143   this->input_shndxes_.clear();
1144 }
1145
1146 // Output_data_got::Got_entry methods.
1147
1148 // Write out the entry.
1149
1150 template<int size, bool big_endian>
1151 void
1152 Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov) const
1153 {
1154   Valtype val = 0;
1155
1156   switch (this->local_sym_index_)
1157     {
1158     case GSYM_CODE:
1159       {
1160         // If the symbol is resolved locally, we need to write out the
1161         // link-time value, which will be relocated dynamically by a
1162         // RELATIVE relocation.
1163         Symbol* gsym = this->u_.gsym;
1164         Sized_symbol<size>* sgsym;
1165         // This cast is a bit ugly.  We don't want to put a
1166         // virtual method in Symbol, because we want Symbol to be
1167         // as small as possible.
1168         sgsym = static_cast<Sized_symbol<size>*>(gsym);
1169         val = sgsym->value();
1170       }
1171       break;
1172
1173     case CONSTANT_CODE:
1174       val = this->u_.constant;
1175       break;
1176
1177     default:
1178       {
1179         const unsigned int lsi = this->local_sym_index_;
1180         const Symbol_value<size>* symval = this->u_.object->local_symbol(lsi);
1181         val = symval->value(this->u_.object, 0);
1182       }
1183       break;
1184     }
1185
1186   elfcpp::Swap<size, big_endian>::writeval(pov, val);
1187 }
1188
1189 // Output_data_got methods.
1190
1191 // Add an entry for a global symbol to the GOT.  This returns true if
1192 // this is a new GOT entry, false if the symbol already had a GOT
1193 // entry.
1194
1195 template<int size, bool big_endian>
1196 bool
1197 Output_data_got<size, big_endian>::add_global(
1198     Symbol* gsym,
1199     unsigned int got_type)
1200 {
1201   if (gsym->has_got_offset(got_type))
1202     return false;
1203
1204   this->entries_.push_back(Got_entry(gsym));
1205   this->set_got_size();
1206   gsym->set_got_offset(got_type, this->last_got_offset());
1207   return true;
1208 }
1209
1210 // Add an entry for a global symbol to the GOT, and add a dynamic
1211 // relocation of type R_TYPE for the GOT entry.
1212 template<int size, bool big_endian>
1213 void
1214 Output_data_got<size, big_endian>::add_global_with_rel(
1215     Symbol* gsym,
1216     unsigned int got_type,
1217     Rel_dyn* rel_dyn,
1218     unsigned int r_type)
1219 {
1220   if (gsym->has_got_offset(got_type))
1221     return;
1222
1223   this->entries_.push_back(Got_entry());
1224   this->set_got_size();
1225   unsigned int got_offset = this->last_got_offset();
1226   gsym->set_got_offset(got_type, got_offset);
1227   rel_dyn->add_global(gsym, r_type, this, got_offset);
1228 }
1229
1230 template<int size, bool big_endian>
1231 void
1232 Output_data_got<size, big_endian>::add_global_with_rela(
1233     Symbol* gsym,
1234     unsigned int got_type,
1235     Rela_dyn* rela_dyn,
1236     unsigned int r_type)
1237 {
1238   if (gsym->has_got_offset(got_type))
1239     return;
1240
1241   this->entries_.push_back(Got_entry());
1242   this->set_got_size();
1243   unsigned int got_offset = this->last_got_offset();
1244   gsym->set_got_offset(got_type, got_offset);
1245   rela_dyn->add_global(gsym, r_type, this, got_offset, 0);
1246 }
1247
1248 // Add a pair of entries for a global symbol to the GOT, and add
1249 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1250 // If R_TYPE_2 == 0, add the second entry with no relocation.
1251 template<int size, bool big_endian>
1252 void
1253 Output_data_got<size, big_endian>::add_global_pair_with_rel(
1254     Symbol* gsym,
1255     unsigned int got_type,
1256     Rel_dyn* rel_dyn,
1257     unsigned int r_type_1,
1258     unsigned int r_type_2)
1259 {
1260   if (gsym->has_got_offset(got_type))
1261     return;
1262
1263   this->entries_.push_back(Got_entry());
1264   unsigned int got_offset = this->last_got_offset();
1265   gsym->set_got_offset(got_type, got_offset);
1266   rel_dyn->add_global(gsym, r_type_1, this, got_offset);
1267
1268   this->entries_.push_back(Got_entry());
1269   if (r_type_2 != 0)
1270     {
1271       got_offset = this->last_got_offset();
1272       rel_dyn->add_global(gsym, r_type_2, this, got_offset);
1273     }
1274
1275   this->set_got_size();
1276 }
1277
1278 template<int size, bool big_endian>
1279 void
1280 Output_data_got<size, big_endian>::add_global_pair_with_rela(
1281     Symbol* gsym,
1282     unsigned int got_type,
1283     Rela_dyn* rela_dyn,
1284     unsigned int r_type_1,
1285     unsigned int r_type_2)
1286 {
1287   if (gsym->has_got_offset(got_type))
1288     return;
1289
1290   this->entries_.push_back(Got_entry());
1291   unsigned int got_offset = this->last_got_offset();
1292   gsym->set_got_offset(got_type, got_offset);
1293   rela_dyn->add_global(gsym, r_type_1, this, got_offset, 0);
1294
1295   this->entries_.push_back(Got_entry());
1296   if (r_type_2 != 0)
1297     {
1298       got_offset = this->last_got_offset();
1299       rela_dyn->add_global(gsym, r_type_2, this, got_offset, 0);
1300     }
1301
1302   this->set_got_size();
1303 }
1304
1305 // Add an entry for a local symbol to the GOT.  This returns true if
1306 // this is a new GOT entry, false if the symbol already has a GOT
1307 // entry.
1308
1309 template<int size, bool big_endian>
1310 bool
1311 Output_data_got<size, big_endian>::add_local(
1312     Sized_relobj<size, big_endian>* object,
1313     unsigned int symndx,
1314     unsigned int got_type)
1315 {
1316   if (object->local_has_got_offset(symndx, got_type))
1317     return false;
1318
1319   this->entries_.push_back(Got_entry(object, symndx));
1320   this->set_got_size();
1321   object->set_local_got_offset(symndx, got_type, this->last_got_offset());
1322   return true;
1323 }
1324
1325 // Add an entry for a local symbol to the GOT, and add a dynamic
1326 // relocation of type R_TYPE for the GOT entry.
1327 template<int size, bool big_endian>
1328 void
1329 Output_data_got<size, big_endian>::add_local_with_rel(
1330     Sized_relobj<size, big_endian>* object,
1331     unsigned int symndx,
1332     unsigned int got_type,
1333     Rel_dyn* rel_dyn,
1334     unsigned int r_type)
1335 {
1336   if (object->local_has_got_offset(symndx, got_type))
1337     return;
1338
1339   this->entries_.push_back(Got_entry());
1340   this->set_got_size();
1341   unsigned int got_offset = this->last_got_offset();
1342   object->set_local_got_offset(symndx, got_type, got_offset);
1343   rel_dyn->add_local(object, symndx, r_type, this, got_offset);
1344 }
1345
1346 template<int size, bool big_endian>
1347 void
1348 Output_data_got<size, big_endian>::add_local_with_rela(
1349     Sized_relobj<size, big_endian>* object,
1350     unsigned int symndx,
1351     unsigned int got_type,
1352     Rela_dyn* rela_dyn,
1353     unsigned int r_type)
1354 {
1355   if (object->local_has_got_offset(symndx, got_type))
1356     return;
1357
1358   this->entries_.push_back(Got_entry());
1359   this->set_got_size();
1360   unsigned int got_offset = this->last_got_offset();
1361   object->set_local_got_offset(symndx, got_type, got_offset);
1362   rela_dyn->add_local(object, symndx, r_type, this, got_offset, 0);
1363 }
1364
1365 // Add a pair of entries for a local symbol to the GOT, and add
1366 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1367 // If R_TYPE_2 == 0, add the second entry with no relocation.
1368 template<int size, bool big_endian>
1369 void
1370 Output_data_got<size, big_endian>::add_local_pair_with_rel(
1371     Sized_relobj<size, big_endian>* object,
1372     unsigned int symndx,
1373     unsigned int shndx,
1374     unsigned int got_type,
1375     Rel_dyn* rel_dyn,
1376     unsigned int r_type_1,
1377     unsigned int r_type_2)
1378 {
1379   if (object->local_has_got_offset(symndx, got_type))
1380     return;
1381
1382   this->entries_.push_back(Got_entry());
1383   unsigned int got_offset = this->last_got_offset();
1384   object->set_local_got_offset(symndx, got_type, got_offset);
1385   Output_section* os = object->output_section(shndx);
1386   rel_dyn->add_output_section(os, r_type_1, this, got_offset);
1387
1388   this->entries_.push_back(Got_entry(object, symndx));
1389   if (r_type_2 != 0)
1390     {
1391       got_offset = this->last_got_offset();
1392       rel_dyn->add_output_section(os, r_type_2, this, got_offset);
1393     }
1394
1395   this->set_got_size();
1396 }
1397
1398 template<int size, bool big_endian>
1399 void
1400 Output_data_got<size, big_endian>::add_local_pair_with_rela(
1401     Sized_relobj<size, big_endian>* object,
1402     unsigned int symndx,
1403     unsigned int shndx,
1404     unsigned int got_type,
1405     Rela_dyn* rela_dyn,
1406     unsigned int r_type_1,
1407     unsigned int r_type_2)
1408 {
1409   if (object->local_has_got_offset(symndx, got_type))
1410     return;
1411
1412   this->entries_.push_back(Got_entry());
1413   unsigned int got_offset = this->last_got_offset();
1414   object->set_local_got_offset(symndx, got_type, got_offset);
1415   Output_section* os = object->output_section(shndx);
1416   rela_dyn->add_output_section(os, r_type_1, this, got_offset, 0);
1417
1418   this->entries_.push_back(Got_entry(object, symndx));
1419   if (r_type_2 != 0)
1420     {
1421       got_offset = this->last_got_offset();
1422       rela_dyn->add_output_section(os, r_type_2, this, got_offset, 0);
1423     }
1424
1425   this->set_got_size();
1426 }
1427
1428 // Write out the GOT.
1429
1430 template<int size, bool big_endian>
1431 void
1432 Output_data_got<size, big_endian>::do_write(Output_file* of)
1433 {
1434   const int add = size / 8;
1435
1436   const off_t off = this->offset();
1437   const off_t oview_size = this->data_size();
1438   unsigned char* const oview = of->get_output_view(off, oview_size);
1439
1440   unsigned char* pov = oview;
1441   for (typename Got_entries::const_iterator p = this->entries_.begin();
1442        p != this->entries_.end();
1443        ++p)
1444     {
1445       p->write(pov);
1446       pov += add;
1447     }
1448
1449   gold_assert(pov - oview == oview_size);
1450
1451   of->write_output_view(off, oview_size, oview);
1452
1453   // We no longer need the GOT entries.
1454   this->entries_.clear();
1455 }
1456
1457 // Output_data_dynamic::Dynamic_entry methods.
1458
1459 // Write out the entry.
1460
1461 template<int size, bool big_endian>
1462 void
1463 Output_data_dynamic::Dynamic_entry::write(
1464     unsigned char* pov,
1465     const Stringpool* pool) const
1466 {
1467   typename elfcpp::Elf_types<size>::Elf_WXword val;
1468   switch (this->offset_)
1469     {
1470     case DYNAMIC_NUMBER:
1471       val = this->u_.val;
1472       break;
1473
1474     case DYNAMIC_SECTION_SIZE:
1475       val = this->u_.od->data_size();
1476       break;
1477
1478     case DYNAMIC_SYMBOL:
1479       {
1480         const Sized_symbol<size>* s =
1481           static_cast<const Sized_symbol<size>*>(this->u_.sym);
1482         val = s->value();
1483       }
1484       break;
1485
1486     case DYNAMIC_STRING:
1487       val = pool->get_offset(this->u_.str);
1488       break;
1489
1490     default:
1491       val = this->u_.od->address() + this->offset_;
1492       break;
1493     }
1494
1495   elfcpp::Dyn_write<size, big_endian> dw(pov);
1496   dw.put_d_tag(this->tag_);
1497   dw.put_d_val(val);
1498 }
1499
1500 // Output_data_dynamic methods.
1501
1502 // Adjust the output section to set the entry size.
1503
1504 void
1505 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1506 {
1507   if (parameters->target().get_size() == 32)
1508     os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1509   else if (parameters->target().get_size() == 64)
1510     os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1511   else
1512     gold_unreachable();
1513 }
1514
1515 // Set the final data size.
1516
1517 void
1518 Output_data_dynamic::set_final_data_size()
1519 {
1520   // Add the terminating entry if it hasn't been added.
1521   // Because of relaxation, we can run this multiple times.
1522   if (this->entries_.empty()
1523       || this->entries_.rbegin()->tag() != elfcpp::DT_NULL)
1524     this->add_constant(elfcpp::DT_NULL, 0);
1525
1526   int dyn_size;
1527   if (parameters->target().get_size() == 32)
1528     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1529   else if (parameters->target().get_size() == 64)
1530     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1531   else
1532     gold_unreachable();
1533   this->set_data_size(this->entries_.size() * dyn_size);
1534 }
1535
1536 // Write out the dynamic entries.
1537
1538 void
1539 Output_data_dynamic::do_write(Output_file* of)
1540 {
1541   switch (parameters->size_and_endianness())
1542     {
1543 #ifdef HAVE_TARGET_32_LITTLE
1544     case Parameters::TARGET_32_LITTLE:
1545       this->sized_write<32, false>(of);
1546       break;
1547 #endif
1548 #ifdef HAVE_TARGET_32_BIG
1549     case Parameters::TARGET_32_BIG:
1550       this->sized_write<32, true>(of);
1551       break;
1552 #endif
1553 #ifdef HAVE_TARGET_64_LITTLE
1554     case Parameters::TARGET_64_LITTLE:
1555       this->sized_write<64, false>(of);
1556       break;
1557 #endif
1558 #ifdef HAVE_TARGET_64_BIG
1559     case Parameters::TARGET_64_BIG:
1560       this->sized_write<64, true>(of);
1561       break;
1562 #endif
1563     default:
1564       gold_unreachable();
1565     }
1566 }
1567
1568 template<int size, bool big_endian>
1569 void
1570 Output_data_dynamic::sized_write(Output_file* of)
1571 {
1572   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1573
1574   const off_t offset = this->offset();
1575   const off_t oview_size = this->data_size();
1576   unsigned char* const oview = of->get_output_view(offset, oview_size);
1577
1578   unsigned char* pov = oview;
1579   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
1580        p != this->entries_.end();
1581        ++p)
1582     {
1583       p->write<size, big_endian>(pov, this->pool_);
1584       pov += dyn_size;
1585     }
1586
1587   gold_assert(pov - oview == oview_size);
1588
1589   of->write_output_view(offset, oview_size, oview);
1590
1591   // We no longer need the dynamic entries.
1592   this->entries_.clear();
1593 }
1594
1595 // Class Output_symtab_xindex.
1596
1597 void
1598 Output_symtab_xindex::do_write(Output_file* of)
1599 {
1600   const off_t offset = this->offset();
1601   const off_t oview_size = this->data_size();
1602   unsigned char* const oview = of->get_output_view(offset, oview_size);
1603
1604   memset(oview, 0, oview_size);
1605
1606   if (parameters->target().is_big_endian())
1607     this->endian_do_write<true>(oview);
1608   else
1609     this->endian_do_write<false>(oview);
1610
1611   of->write_output_view(offset, oview_size, oview);
1612
1613   // We no longer need the data.
1614   this->entries_.clear();
1615 }
1616
1617 template<bool big_endian>
1618 void
1619 Output_symtab_xindex::endian_do_write(unsigned char* const oview)
1620 {
1621   for (Xindex_entries::const_iterator p = this->entries_.begin();
1622        p != this->entries_.end();
1623        ++p)
1624     {
1625       unsigned int symndx = p->first;
1626       gold_assert(symndx * 4 < this->data_size());
1627       elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
1628     }
1629 }
1630
1631 // Output_section::Input_section methods.
1632
1633 // Return the data size.  For an input section we store the size here.
1634 // For an Output_section_data, we have to ask it for the size.
1635
1636 off_t
1637 Output_section::Input_section::data_size() const
1638 {
1639   if (this->is_input_section())
1640     return this->u1_.data_size;
1641   else
1642     return this->u2_.posd->data_size();
1643 }
1644
1645 // Set the address and file offset.
1646
1647 void
1648 Output_section::Input_section::set_address_and_file_offset(
1649     uint64_t address,
1650     off_t file_offset,
1651     off_t section_file_offset)
1652 {
1653   if (this->is_input_section())
1654     this->u2_.object->set_section_offset(this->shndx_,
1655                                          file_offset - section_file_offset);
1656   else
1657     this->u2_.posd->set_address_and_file_offset(address, file_offset);
1658 }
1659
1660 // Reset the address and file offset.
1661
1662 void
1663 Output_section::Input_section::reset_address_and_file_offset()
1664 {
1665   if (!this->is_input_section())
1666     this->u2_.posd->reset_address_and_file_offset();
1667 }
1668
1669 // Finalize the data size.
1670
1671 void
1672 Output_section::Input_section::finalize_data_size()
1673 {
1674   if (!this->is_input_section())
1675     this->u2_.posd->finalize_data_size();
1676 }
1677
1678 // Try to turn an input offset into an output offset.  We want to
1679 // return the output offset relative to the start of this
1680 // Input_section in the output section.
1681
1682 inline bool
1683 Output_section::Input_section::output_offset(
1684     const Relobj* object,
1685     unsigned int shndx,
1686     section_offset_type offset,
1687     section_offset_type *poutput) const
1688 {
1689   if (!this->is_input_section())
1690     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
1691   else
1692     {
1693       if (this->shndx_ != shndx || this->u2_.object != object)
1694         return false;
1695       *poutput = offset;
1696       return true;
1697     }
1698 }
1699
1700 // Return whether this is the merge section for the input section
1701 // SHNDX in OBJECT.
1702
1703 inline bool
1704 Output_section::Input_section::is_merge_section_for(const Relobj* object,
1705                                                     unsigned int shndx) const
1706 {
1707   if (this->is_input_section())
1708     return false;
1709   return this->u2_.posd->is_merge_section_for(object, shndx);
1710 }
1711
1712 // Write out the data.  We don't have to do anything for an input
1713 // section--they are handled via Object::relocate--but this is where
1714 // we write out the data for an Output_section_data.
1715
1716 void
1717 Output_section::Input_section::write(Output_file* of)
1718 {
1719   if (!this->is_input_section())
1720     this->u2_.posd->write(of);
1721 }
1722
1723 // Write the data to a buffer.  As for write(), we don't have to do
1724 // anything for an input section.
1725
1726 void
1727 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
1728 {
1729   if (!this->is_input_section())
1730     this->u2_.posd->write_to_buffer(buffer);
1731 }
1732
1733 // Print to a map file.
1734
1735 void
1736 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
1737 {
1738   switch (this->shndx_)
1739     {
1740     case OUTPUT_SECTION_CODE:
1741     case MERGE_DATA_SECTION_CODE:
1742     case MERGE_STRING_SECTION_CODE:
1743       this->u2_.posd->print_to_mapfile(mapfile);
1744       break;
1745
1746     case RELAXED_INPUT_SECTION_CODE:
1747       {
1748         Output_relaxed_input_section* relaxed_section =
1749           this->relaxed_input_section();
1750         mapfile->print_input_section(relaxed_section->relobj(),
1751                                      relaxed_section->shndx());
1752       }
1753       break;
1754     default:
1755       mapfile->print_input_section(this->u2_.object, this->shndx_);
1756       break;
1757     }
1758 }
1759
1760 // Output_section methods.
1761
1762 // Construct an Output_section.  NAME will point into a Stringpool.
1763
1764 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
1765                                elfcpp::Elf_Xword flags)
1766   : name_(name),
1767     addralign_(0),
1768     entsize_(0),
1769     load_address_(0),
1770     link_section_(NULL),
1771     link_(0),
1772     info_section_(NULL),
1773     info_symndx_(NULL),
1774     info_(0),
1775     type_(type),
1776     flags_(flags),
1777     out_shndx_(-1U),
1778     symtab_index_(0),
1779     dynsym_index_(0),
1780     input_sections_(),
1781     first_input_offset_(0),
1782     fills_(),
1783     postprocessing_buffer_(NULL),
1784     needs_symtab_index_(false),
1785     needs_dynsym_index_(false),
1786     should_link_to_symtab_(false),
1787     should_link_to_dynsym_(false),
1788     after_input_sections_(false),
1789     requires_postprocessing_(false),
1790     found_in_sections_clause_(false),
1791     has_load_address_(false),
1792     info_uses_section_index_(false),
1793     may_sort_attached_input_sections_(false),
1794     must_sort_attached_input_sections_(false),
1795     attached_input_sections_are_sorted_(false),
1796     is_relro_(false),
1797     is_relro_local_(false),
1798     is_small_section_(false),
1799     is_large_section_(false),
1800     is_interp_(false),
1801     is_dynamic_linker_section_(false),
1802     generate_code_fills_at_write_(false),
1803     tls_offset_(0),
1804     checkpoint_(NULL),
1805     merge_section_map_(),
1806     merge_section_by_properties_map_(),
1807     relaxed_input_section_map_(),
1808     is_relaxed_input_section_map_valid_(true)
1809 {
1810   // An unallocated section has no address.  Forcing this means that
1811   // we don't need special treatment for symbols defined in debug
1812   // sections.
1813   if ((flags & elfcpp::SHF_ALLOC) == 0)
1814     this->set_address(0);
1815 }
1816
1817 Output_section::~Output_section()
1818 {
1819   delete this->checkpoint_;
1820 }
1821
1822 // Set the entry size.
1823
1824 void
1825 Output_section::set_entsize(uint64_t v)
1826 {
1827   if (this->entsize_ == 0)
1828     this->entsize_ = v;
1829   else
1830     gold_assert(this->entsize_ == v);
1831 }
1832
1833 // Add the input section SHNDX, with header SHDR, named SECNAME, in
1834 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
1835 // relocation section which applies to this section, or 0 if none, or
1836 // -1U if more than one.  Return the offset of the input section
1837 // within the output section.  Return -1 if the input section will
1838 // receive special handling.  In the normal case we don't always keep
1839 // track of input sections for an Output_section.  Instead, each
1840 // Object keeps track of the Output_section for each of its input
1841 // sections.  However, if HAVE_SECTIONS_SCRIPT is true, we do keep
1842 // track of input sections here; this is used when SECTIONS appears in
1843 // a linker script.
1844
1845 template<int size, bool big_endian>
1846 off_t
1847 Output_section::add_input_section(Sized_relobj<size, big_endian>* object,
1848                                   unsigned int shndx,
1849                                   const char* secname,
1850                                   const elfcpp::Shdr<size, big_endian>& shdr,
1851                                   unsigned int reloc_shndx,
1852                                   bool have_sections_script)
1853 {
1854   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
1855   if ((addralign & (addralign - 1)) != 0)
1856     {
1857       object->error(_("invalid alignment %lu for section \"%s\""),
1858                     static_cast<unsigned long>(addralign), secname);
1859       addralign = 1;
1860     }
1861
1862   if (addralign > this->addralign_)
1863     this->addralign_ = addralign;
1864
1865   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
1866   this->update_flags_for_input_section(sh_flags);
1867
1868   uint64_t entsize = shdr.get_sh_entsize();
1869
1870   // .debug_str is a mergeable string section, but is not always so
1871   // marked by compilers.  Mark manually here so we can optimize.
1872   if (strcmp(secname, ".debug_str") == 0)
1873     {
1874       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
1875       entsize = 1;
1876     }
1877
1878   // If this is a SHF_MERGE section, we pass all the input sections to
1879   // a Output_data_merge.  We don't try to handle relocations for such
1880   // a section.  We don't try to handle empty merge sections--they
1881   // mess up the mappings, and are useless anyhow.
1882   if ((sh_flags & elfcpp::SHF_MERGE) != 0
1883       && reloc_shndx == 0
1884       && shdr.get_sh_size() > 0)
1885     {
1886       if (this->add_merge_input_section(object, shndx, sh_flags,
1887                                         entsize, addralign))
1888         {
1889           // Tell the relocation routines that they need to call the
1890           // output_offset method to determine the final address.
1891           return -1;
1892         }
1893     }
1894
1895   off_t offset_in_section = this->current_data_size_for_child();
1896   off_t aligned_offset_in_section = align_address(offset_in_section,
1897                                                   addralign);
1898
1899   // Determine if we want to delay code-fill generation until the output
1900   // section is written.  When the target is relaxing, we want to delay fill
1901   // generating to avoid adjusting them during relaxation.
1902   if (!this->generate_code_fills_at_write_
1903       && !have_sections_script
1904       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
1905       && parameters->target().has_code_fill()
1906       && parameters->target().may_relax())
1907     {
1908       gold_assert(this->fills_.empty());
1909       this->generate_code_fills_at_write_ = true;
1910     }
1911
1912   if (aligned_offset_in_section > offset_in_section
1913       && !this->generate_code_fills_at_write_
1914       && !have_sections_script
1915       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
1916       && parameters->target().has_code_fill())
1917     {
1918       // We need to add some fill data.  Using fill_list_ when
1919       // possible is an optimization, since we will often have fill
1920       // sections without input sections.
1921       off_t fill_len = aligned_offset_in_section - offset_in_section;
1922       if (this->input_sections_.empty())
1923         this->fills_.push_back(Fill(offset_in_section, fill_len));
1924       else
1925         {
1926           std::string fill_data(parameters->target().code_fill(fill_len));
1927           Output_data_const* odc = new Output_data_const(fill_data, 1);
1928           this->input_sections_.push_back(Input_section(odc));
1929         }
1930     }
1931
1932   this->set_current_data_size_for_child(aligned_offset_in_section
1933                                         + shdr.get_sh_size());
1934
1935   // We need to keep track of this section if we are already keeping
1936   // track of sections, or if we are relaxing.  Also, if this is a
1937   // section which requires sorting, or which may require sorting in
1938   // the future, we keep track of the sections.
1939   if (have_sections_script
1940       || !this->input_sections_.empty()
1941       || this->may_sort_attached_input_sections()
1942       || this->must_sort_attached_input_sections()
1943       || parameters->options().user_set_Map()
1944       || parameters->target().may_relax())
1945     this->input_sections_.push_back(Input_section(object, shndx,
1946                                                   shdr.get_sh_size(),
1947                                                   addralign));
1948
1949   return aligned_offset_in_section;
1950 }
1951
1952 // Add arbitrary data to an output section.
1953
1954 void
1955 Output_section::add_output_section_data(Output_section_data* posd)
1956 {
1957   Input_section inp(posd);
1958   this->add_output_section_data(&inp);
1959
1960   if (posd->is_data_size_valid())
1961     {
1962       off_t offset_in_section = this->current_data_size_for_child();
1963       off_t aligned_offset_in_section = align_address(offset_in_section,
1964                                                       posd->addralign());
1965       this->set_current_data_size_for_child(aligned_offset_in_section
1966                                             + posd->data_size());
1967     }
1968 }
1969
1970 // Add a relaxed input section.
1971
1972 void
1973 Output_section::add_relaxed_input_section(Output_relaxed_input_section* poris)
1974 {
1975   Input_section inp(poris);
1976   this->add_output_section_data(&inp);
1977   if (this->is_relaxed_input_section_map_valid_)
1978     {
1979       Input_section_specifier iss(poris->relobj(), poris->shndx());
1980       this->relaxed_input_section_map_[iss] = poris;
1981     }
1982
1983   // For a relaxed section, we use the current data size.  Linker scripts
1984   // get all the input sections, including relaxed one from an output
1985   // section and add them back to them same output section to compute the
1986   // output section size.  If we do not account for sizes of relaxed input
1987   // sections,  an output section would be incorrectly sized.
1988   off_t offset_in_section = this->current_data_size_for_child();
1989   off_t aligned_offset_in_section = align_address(offset_in_section,
1990                                                   poris->addralign());
1991   this->set_current_data_size_for_child(aligned_offset_in_section
1992                                         + poris->current_data_size());
1993 }
1994
1995 // Add arbitrary data to an output section by Input_section.
1996
1997 void
1998 Output_section::add_output_section_data(Input_section* inp)
1999 {
2000   if (this->input_sections_.empty())
2001     this->first_input_offset_ = this->current_data_size_for_child();
2002
2003   this->input_sections_.push_back(*inp);
2004
2005   uint64_t addralign = inp->addralign();
2006   if (addralign > this->addralign_)
2007     this->addralign_ = addralign;
2008
2009   inp->set_output_section(this);
2010 }
2011
2012 // Add a merge section to an output section.
2013
2014 void
2015 Output_section::add_output_merge_section(Output_section_data* posd,
2016                                          bool is_string, uint64_t entsize)
2017 {
2018   Input_section inp(posd, is_string, entsize);
2019   this->add_output_section_data(&inp);
2020 }
2021
2022 // Add an input section to a SHF_MERGE section.
2023
2024 bool
2025 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
2026                                         uint64_t flags, uint64_t entsize,
2027                                         uint64_t addralign)
2028 {
2029   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
2030
2031   // We only merge strings if the alignment is not more than the
2032   // character size.  This could be handled, but it's unusual.
2033   if (is_string && addralign > entsize)
2034     return false;
2035
2036   // We cannot restore merged input section states.
2037   gold_assert(this->checkpoint_ == NULL);
2038
2039   // Look up merge sections by required properties.
2040   Merge_section_properties msp(is_string, entsize, addralign);
2041   Merge_section_by_properties_map::const_iterator p =
2042     this->merge_section_by_properties_map_.find(msp);
2043   if (p != this->merge_section_by_properties_map_.end())
2044     {
2045       Output_merge_base* merge_section = p->second;
2046       merge_section->add_input_section(object, shndx);
2047       gold_assert(merge_section->is_string() == is_string
2048                   && merge_section->entsize() == entsize
2049                   && merge_section->addralign() == addralign);
2050
2051       // Link input section to found merge section.
2052       Input_section_specifier iss(object, shndx);
2053       this->merge_section_map_[iss] = merge_section;
2054       return true;
2055     }
2056
2057   // We handle the actual constant merging in Output_merge_data or
2058   // Output_merge_string_data.
2059   Output_merge_base* pomb;
2060   if (!is_string)
2061     pomb = new Output_merge_data(entsize, addralign);
2062   else
2063     {
2064       switch (entsize)
2065         {
2066         case 1:
2067           pomb = new Output_merge_string<char>(addralign);
2068           break;
2069         case 2:
2070           pomb = new Output_merge_string<uint16_t>(addralign);
2071           break;
2072         case 4:
2073           pomb = new Output_merge_string<uint32_t>(addralign);
2074           break;
2075         default:
2076           return false;
2077         }
2078     }
2079
2080   // Add new merge section to this output section and link merge section
2081   // properties to new merge section in map.
2082   this->add_output_merge_section(pomb, is_string, entsize);
2083   this->merge_section_by_properties_map_[msp] = pomb;
2084
2085   // Add input section to new merge section and link input section to new
2086   // merge section in map.
2087   pomb->add_input_section(object, shndx);
2088   Input_section_specifier iss(object, shndx);
2089   this->merge_section_map_[iss] = pomb;
2090
2091   return true;
2092 }
2093
2094 // Build a relaxation map to speed up relaxation of existing input sections.
2095 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2096
2097 void
2098 Output_section::build_relaxation_map(
2099   const Input_section_list& input_sections,
2100   size_t limit,
2101   Relaxation_map* relaxation_map) const
2102 {
2103   for (size_t i = 0; i < limit; ++i)
2104     {
2105       const Input_section& is(input_sections[i]);
2106       if (is.is_input_section() || is.is_relaxed_input_section())
2107         {
2108           Input_section_specifier iss(is.relobj(), is.shndx());
2109           (*relaxation_map)[iss] = i;
2110         }
2111     }
2112 }
2113
2114 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2115 // sections in RELAXED_SECTIONS.  MAP is a prebuilt map from input section
2116 // specifier to indices of INPUT_SECTIONS.
2117
2118 void
2119 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2120   const std::vector<Output_relaxed_input_section*>& relaxed_sections,
2121   const Relaxation_map& map,
2122   Input_section_list* input_sections)
2123 {
2124   for (size_t i = 0; i < relaxed_sections.size(); ++i)
2125     {
2126       Output_relaxed_input_section* poris = relaxed_sections[i];
2127       Input_section_specifier iss(poris->relobj(), poris->shndx());
2128       Relaxation_map::const_iterator p = map.find(iss);
2129       gold_assert(p != map.end());
2130       gold_assert((*input_sections)[p->second].is_input_section());
2131       (*input_sections)[p->second] = Input_section(poris);
2132     }
2133 }
2134
2135 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2136 // is a vector of pointers to Output_relaxed_input_section or its derived
2137 // classes.  The relaxed sections must correspond to existing input sections.
2138
2139 void
2140 Output_section::convert_input_sections_to_relaxed_sections(
2141   const std::vector<Output_relaxed_input_section*>& relaxed_sections)
2142 {
2143   gold_assert(parameters->target().may_relax());
2144
2145   // We want to make sure that restore_states does not undo the effect of
2146   // this.  If there is no checkpoint active, just search the current
2147   // input section list and replace the sections there.  If there is
2148   // a checkpoint, also replace the sections there.
2149
2150   // By default, we look at the whole list.
2151   size_t limit = this->input_sections_.size();
2152
2153   if (this->checkpoint_ != NULL)
2154     {
2155       // Replace input sections with relaxed input section in the saved
2156       // copy of the input section list.
2157       if (this->checkpoint_->input_sections_saved())
2158         {
2159           Relaxation_map map;
2160           this->build_relaxation_map(
2161                     *(this->checkpoint_->input_sections()),
2162                     this->checkpoint_->input_sections()->size(),
2163                     &map);
2164           this->convert_input_sections_in_list_to_relaxed_sections(
2165                     relaxed_sections,
2166                     map,
2167                     this->checkpoint_->input_sections());
2168         }
2169       else
2170         {
2171           // We have not copied the input section list yet.  Instead, just
2172           // look at the portion that would be saved.
2173           limit = this->checkpoint_->input_sections_size();
2174         }
2175     }
2176
2177   // Convert input sections in input_section_list.
2178   Relaxation_map map;
2179   this->build_relaxation_map(this->input_sections_, limit, &map);
2180   this->convert_input_sections_in_list_to_relaxed_sections(
2181             relaxed_sections,
2182             map,
2183             &this->input_sections_);
2184 }
2185
2186 // Update the output section flags based on input section flags.
2187
2188 void
2189 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags)
2190 {
2191   // If we created the section with SHF_ALLOC clear, we set the
2192   // address.  If we are now setting the SHF_ALLOC flag, we need to
2193   // undo that.
2194   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0
2195       && (flags & elfcpp::SHF_ALLOC) != 0)
2196     this->mark_address_invalid();
2197
2198   this->flags_ |= (flags
2199                    & (elfcpp::SHF_WRITE
2200                       | elfcpp::SHF_ALLOC
2201                       | elfcpp::SHF_EXECINSTR));
2202 }
2203
2204 // Find the merge section into which an input section with index SHNDX in
2205 // OBJECT has been added.  Return NULL if none found.
2206
2207 Output_section_data*
2208 Output_section::find_merge_section(const Relobj* object,
2209                                    unsigned int shndx) const
2210 {
2211   Input_section_specifier iss(object, shndx);
2212   Output_section_data_by_input_section_map::const_iterator p =
2213     this->merge_section_map_.find(iss);
2214   if (p != this->merge_section_map_.end())
2215     {
2216       Output_section_data* posd = p->second;
2217       gold_assert(posd->is_merge_section_for(object, shndx));
2218       return posd;
2219     }
2220   else
2221     return NULL;
2222 }
2223
2224 // Find an relaxed input section corresponding to an input section
2225 // in OBJECT with index SHNDX.
2226
2227 const Output_section_data*
2228 Output_section::find_relaxed_input_section(const Relobj* object,
2229                                            unsigned int shndx) const
2230 {
2231   // Be careful that the map may not be valid due to input section export
2232   // to scripts or a check-point restore.
2233   if (!this->is_relaxed_input_section_map_valid_)
2234     {
2235       // Rebuild the map as needed.
2236       this->relaxed_input_section_map_.clear();
2237       for (Input_section_list::const_iterator p = this->input_sections_.begin();
2238            p != this->input_sections_.end();
2239            ++p)
2240         if (p->is_relaxed_input_section())
2241           {
2242             Input_section_specifier iss(p->relobj(), p->shndx());
2243             this->relaxed_input_section_map_[iss] =
2244               p->relaxed_input_section();
2245           }
2246       this->is_relaxed_input_section_map_valid_ = true;
2247     }
2248
2249   Input_section_specifier iss(object, shndx);
2250   Output_section_data_by_input_section_map::const_iterator p =
2251     this->relaxed_input_section_map_.find(iss);
2252   if (p != this->relaxed_input_section_map_.end())
2253     return p->second;
2254   else
2255     return NULL;
2256 }
2257
2258 // Given an address OFFSET relative to the start of input section
2259 // SHNDX in OBJECT, return whether this address is being included in
2260 // the final link.  This should only be called if SHNDX in OBJECT has
2261 // a special mapping.
2262
2263 bool
2264 Output_section::is_input_address_mapped(const Relobj* object,
2265                                         unsigned int shndx,
2266                                         off_t offset) const
2267 {
2268   // Look at the Output_section_data_maps first.
2269   const Output_section_data* posd = this->find_merge_section(object, shndx);
2270   if (posd == NULL)
2271     posd = this->find_relaxed_input_section(object, shndx);
2272
2273   if (posd != NULL)
2274     {
2275       section_offset_type output_offset;
2276       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2277       gold_assert(found);
2278       return output_offset != -1;
2279     }
2280
2281   // Fall back to the slow look-up.
2282   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2283        p != this->input_sections_.end();
2284        ++p)
2285     {
2286       section_offset_type output_offset;
2287       if (p->output_offset(object, shndx, offset, &output_offset))
2288         return output_offset != -1;
2289     }
2290
2291   // By default we assume that the address is mapped.  This should
2292   // only be called after we have passed all sections to Layout.  At
2293   // that point we should know what we are discarding.
2294   return true;
2295 }
2296
2297 // Given an address OFFSET relative to the start of input section
2298 // SHNDX in object OBJECT, return the output offset relative to the
2299 // start of the input section in the output section.  This should only
2300 // be called if SHNDX in OBJECT has a special mapping.
2301
2302 section_offset_type
2303 Output_section::output_offset(const Relobj* object, unsigned int shndx,
2304                               section_offset_type offset) const
2305 {
2306   // This can only be called meaningfully when we know the data size
2307   // of this.
2308   gold_assert(this->is_data_size_valid());
2309
2310   // Look at the Output_section_data_maps first.
2311   const Output_section_data* posd = this->find_merge_section(object, shndx);
2312   if (posd == NULL)
2313     posd = this->find_relaxed_input_section(object, shndx);
2314   if (posd != NULL)
2315     {
2316       section_offset_type output_offset;
2317       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2318       gold_assert(found);
2319       return output_offset;
2320     }
2321
2322   // Fall back to the slow look-up.
2323   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2324        p != this->input_sections_.end();
2325        ++p)
2326     {
2327       section_offset_type output_offset;
2328       if (p->output_offset(object, shndx, offset, &output_offset))
2329         return output_offset;
2330     }
2331   gold_unreachable();
2332 }
2333
2334 // Return the output virtual address of OFFSET relative to the start
2335 // of input section SHNDX in object OBJECT.
2336
2337 uint64_t
2338 Output_section::output_address(const Relobj* object, unsigned int shndx,
2339                                off_t offset) const
2340 {
2341   uint64_t addr = this->address() + this->first_input_offset_;
2342
2343   // Look at the Output_section_data_maps first.
2344   const Output_section_data* posd = this->find_merge_section(object, shndx);
2345   if (posd == NULL)
2346     posd = this->find_relaxed_input_section(object, shndx);
2347   if (posd != NULL && posd->is_address_valid())
2348     {
2349       section_offset_type output_offset;
2350       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2351       gold_assert(found);
2352       return posd->address() + output_offset;
2353     }
2354
2355   // Fall back to the slow look-up.
2356   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2357        p != this->input_sections_.end();
2358        ++p)
2359     {
2360       addr = align_address(addr, p->addralign());
2361       section_offset_type output_offset;
2362       if (p->output_offset(object, shndx, offset, &output_offset))
2363         {
2364           if (output_offset == -1)
2365             return -1ULL;
2366           return addr + output_offset;
2367         }
2368       addr += p->data_size();
2369     }
2370
2371   // If we get here, it means that we don't know the mapping for this
2372   // input section.  This might happen in principle if
2373   // add_input_section were called before add_output_section_data.
2374   // But it should never actually happen.
2375
2376   gold_unreachable();
2377 }
2378
2379 // Find the output address of the start of the merged section for
2380 // input section SHNDX in object OBJECT.
2381
2382 bool
2383 Output_section::find_starting_output_address(const Relobj* object,
2384                                              unsigned int shndx,
2385                                              uint64_t* paddr) const
2386 {
2387   // FIXME: This becomes a bottle-neck if we have many relaxed sections.
2388   // Looking up the merge section map does not always work as we sometimes
2389   // find a merge section without its address set.
2390   uint64_t addr = this->address() + this->first_input_offset_;
2391   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2392        p != this->input_sections_.end();
2393        ++p)
2394     {
2395       addr = align_address(addr, p->addralign());
2396
2397       // It would be nice if we could use the existing output_offset
2398       // method to get the output offset of input offset 0.
2399       // Unfortunately we don't know for sure that input offset 0 is
2400       // mapped at all.
2401       if (p->is_merge_section_for(object, shndx))
2402         {
2403           *paddr = addr;
2404           return true;
2405         }
2406
2407       addr += p->data_size();
2408     }
2409
2410   // We couldn't find a merge output section for this input section.
2411   return false;
2412 }
2413
2414 // Set the data size of an Output_section.  This is where we handle
2415 // setting the addresses of any Output_section_data objects.
2416
2417 void
2418 Output_section::set_final_data_size()
2419 {
2420   if (this->input_sections_.empty())
2421     {
2422       this->set_data_size(this->current_data_size_for_child());
2423       return;
2424     }
2425
2426   if (this->must_sort_attached_input_sections())
2427     this->sort_attached_input_sections();
2428
2429   uint64_t address = this->address();
2430   off_t startoff = this->offset();
2431   off_t off = startoff + this->first_input_offset_;
2432   for (Input_section_list::iterator p = this->input_sections_.begin();
2433        p != this->input_sections_.end();
2434        ++p)
2435     {
2436       off = align_address(off, p->addralign());
2437       p->set_address_and_file_offset(address + (off - startoff), off,
2438                                      startoff);
2439       off += p->data_size();
2440     }
2441
2442   this->set_data_size(off - startoff);
2443 }
2444
2445 // Reset the address and file offset.
2446
2447 void
2448 Output_section::do_reset_address_and_file_offset()
2449 {
2450   // An unallocated section has no address.  Forcing this means that
2451   // we don't need special treatment for symbols defined in debug
2452   // sections.  We do the same in the constructor.
2453   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
2454      this->set_address(0);
2455
2456   for (Input_section_list::iterator p = this->input_sections_.begin();
2457        p != this->input_sections_.end();
2458        ++p)
2459     p->reset_address_and_file_offset();
2460 }
2461
2462 // Return true if address and file offset have the values after reset.
2463
2464 bool
2465 Output_section::do_address_and_file_offset_have_reset_values() const
2466 {
2467   if (this->is_offset_valid())
2468     return false;
2469
2470   // An unallocated section has address 0 after its construction or a reset.
2471   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
2472     return this->is_address_valid() && this->address() == 0;
2473   else
2474     return !this->is_address_valid();
2475 }
2476
2477 // Set the TLS offset.  Called only for SHT_TLS sections.
2478
2479 void
2480 Output_section::do_set_tls_offset(uint64_t tls_base)
2481 {
2482   this->tls_offset_ = this->address() - tls_base;
2483 }
2484
2485 // In a few cases we need to sort the input sections attached to an
2486 // output section.  This is used to implement the type of constructor
2487 // priority ordering implemented by the GNU linker, in which the
2488 // priority becomes part of the section name and the sections are
2489 // sorted by name.  We only do this for an output section if we see an
2490 // attached input section matching ".ctor.*", ".dtor.*",
2491 // ".init_array.*" or ".fini_array.*".
2492
2493 class Output_section::Input_section_sort_entry
2494 {
2495  public:
2496   Input_section_sort_entry()
2497     : input_section_(), index_(-1U), section_has_name_(false),
2498       section_name_()
2499   { }
2500
2501   Input_section_sort_entry(const Input_section& input_section,
2502                            unsigned int index)
2503     : input_section_(input_section), index_(index),
2504       section_has_name_(input_section.is_input_section()
2505                         || input_section.is_relaxed_input_section())
2506   {
2507     if (this->section_has_name_)
2508       {
2509         // This is only called single-threaded from Layout::finalize,
2510         // so it is OK to lock.  Unfortunately we have no way to pass
2511         // in a Task token.
2512         const Task* dummy_task = reinterpret_cast<const Task*>(-1);
2513         Object* obj = (input_section.is_input_section()
2514                        ? input_section.relobj()
2515                        : input_section.relaxed_input_section()->relobj());
2516         Task_lock_obj<Object> tl(dummy_task, obj);
2517
2518         // This is a slow operation, which should be cached in
2519         // Layout::layout if this becomes a speed problem.
2520         this->section_name_ = obj->section_name(input_section.shndx());
2521       }
2522   }
2523
2524   // Return the Input_section.
2525   const Input_section&
2526   input_section() const
2527   {
2528     gold_assert(this->index_ != -1U);
2529     return this->input_section_;
2530   }
2531
2532   // The index of this entry in the original list.  This is used to
2533   // make the sort stable.
2534   unsigned int
2535   index() const
2536   {
2537     gold_assert(this->index_ != -1U);
2538     return this->index_;
2539   }
2540
2541   // Whether there is a section name.
2542   bool
2543   section_has_name() const
2544   { return this->section_has_name_; }
2545
2546   // The section name.
2547   const std::string&
2548   section_name() const
2549   {
2550     gold_assert(this->section_has_name_);
2551     return this->section_name_;
2552   }
2553
2554   // Return true if the section name has a priority.  This is assumed
2555   // to be true if it has a dot after the initial dot.
2556   bool
2557   has_priority() const
2558   {
2559     gold_assert(this->section_has_name_);
2560     return this->section_name_.find('.', 1);
2561   }
2562
2563   // Return true if this an input file whose base name matches
2564   // FILE_NAME.  The base name must have an extension of ".o", and
2565   // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
2566   // This is to match crtbegin.o as well as crtbeginS.o without
2567   // getting confused by other possibilities.  Overall matching the
2568   // file name this way is a dreadful hack, but the GNU linker does it
2569   // in order to better support gcc, and we need to be compatible.
2570   bool
2571   match_file_name(const char* match_file_name) const
2572   {
2573     const std::string& file_name(this->input_section_.relobj()->name());
2574     const char* base_name = lbasename(file_name.c_str());
2575     size_t match_len = strlen(match_file_name);
2576     if (strncmp(base_name, match_file_name, match_len) != 0)
2577       return false;
2578     size_t base_len = strlen(base_name);
2579     if (base_len != match_len + 2 && base_len != match_len + 3)
2580       return false;
2581     return memcmp(base_name + base_len - 2, ".o", 2) == 0;
2582   }
2583
2584  private:
2585   // The Input_section we are sorting.
2586   Input_section input_section_;
2587   // The index of this Input_section in the original list.
2588   unsigned int index_;
2589   // Whether this Input_section has a section name--it won't if this
2590   // is some random Output_section_data.
2591   bool section_has_name_;
2592   // The section name if there is one.
2593   std::string section_name_;
2594 };
2595
2596 // Return true if S1 should come before S2 in the output section.
2597
2598 bool
2599 Output_section::Input_section_sort_compare::operator()(
2600     const Output_section::Input_section_sort_entry& s1,
2601     const Output_section::Input_section_sort_entry& s2) const
2602 {
2603   // crtbegin.o must come first.
2604   bool s1_begin = s1.match_file_name("crtbegin");
2605   bool s2_begin = s2.match_file_name("crtbegin");
2606   if (s1_begin || s2_begin)
2607     {
2608       if (!s1_begin)
2609         return false;
2610       if (!s2_begin)
2611         return true;
2612       return s1.index() < s2.index();
2613     }
2614
2615   // crtend.o must come last.
2616   bool s1_end = s1.match_file_name("crtend");
2617   bool s2_end = s2.match_file_name("crtend");
2618   if (s1_end || s2_end)
2619     {
2620       if (!s1_end)
2621         return true;
2622       if (!s2_end)
2623         return false;
2624       return s1.index() < s2.index();
2625     }
2626
2627   // We sort all the sections with no names to the end.
2628   if (!s1.section_has_name() || !s2.section_has_name())
2629     {
2630       if (s1.section_has_name())
2631         return true;
2632       if (s2.section_has_name())
2633         return false;
2634       return s1.index() < s2.index();
2635     }
2636
2637   // A section with a priority follows a section without a priority.
2638   // The GNU linker does this for all but .init_array sections; until
2639   // further notice we'll assume that that is an mistake.
2640   bool s1_has_priority = s1.has_priority();
2641   bool s2_has_priority = s2.has_priority();
2642   if (s1_has_priority && !s2_has_priority)
2643     return false;
2644   if (!s1_has_priority && s2_has_priority)
2645     return true;
2646
2647   // Otherwise we sort by name.
2648   int compare = s1.section_name().compare(s2.section_name());
2649   if (compare != 0)
2650     return compare < 0;
2651
2652   // Otherwise we keep the input order.
2653   return s1.index() < s2.index();
2654 }
2655
2656 // Sort the input sections attached to an output section.
2657
2658 void
2659 Output_section::sort_attached_input_sections()
2660 {
2661   if (this->attached_input_sections_are_sorted_)
2662     return;
2663
2664   if (this->checkpoint_ != NULL
2665       && !this->checkpoint_->input_sections_saved())
2666     this->checkpoint_->save_input_sections();
2667
2668   // The only thing we know about an input section is the object and
2669   // the section index.  We need the section name.  Recomputing this
2670   // is slow but this is an unusual case.  If this becomes a speed
2671   // problem we can cache the names as required in Layout::layout.
2672
2673   // We start by building a larger vector holding a copy of each
2674   // Input_section, plus its current index in the list and its name.
2675   std::vector<Input_section_sort_entry> sort_list;
2676
2677   unsigned int i = 0;
2678   for (Input_section_list::iterator p = this->input_sections_.begin();
2679        p != this->input_sections_.end();
2680        ++p, ++i)
2681     sort_list.push_back(Input_section_sort_entry(*p, i));
2682
2683   // Sort the input sections.
2684   std::sort(sort_list.begin(), sort_list.end(), Input_section_sort_compare());
2685
2686   // Copy the sorted input sections back to our list.
2687   this->input_sections_.clear();
2688   for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin();
2689        p != sort_list.end();
2690        ++p)
2691     this->input_sections_.push_back(p->input_section());
2692
2693   // Remember that we sorted the input sections, since we might get
2694   // called again.
2695   this->attached_input_sections_are_sorted_ = true;
2696 }
2697
2698 // Write the section header to *OSHDR.
2699
2700 template<int size, bool big_endian>
2701 void
2702 Output_section::write_header(const Layout* layout,
2703                              const Stringpool* secnamepool,
2704                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
2705 {
2706   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
2707   oshdr->put_sh_type(this->type_);
2708
2709   elfcpp::Elf_Xword flags = this->flags_;
2710   if (this->info_section_ != NULL && this->info_uses_section_index_)
2711     flags |= elfcpp::SHF_INFO_LINK;
2712   oshdr->put_sh_flags(flags);
2713
2714   oshdr->put_sh_addr(this->address());
2715   oshdr->put_sh_offset(this->offset());
2716   oshdr->put_sh_size(this->data_size());
2717   if (this->link_section_ != NULL)
2718     oshdr->put_sh_link(this->link_section_->out_shndx());
2719   else if (this->should_link_to_symtab_)
2720     oshdr->put_sh_link(layout->symtab_section()->out_shndx());
2721   else if (this->should_link_to_dynsym_)
2722     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
2723   else
2724     oshdr->put_sh_link(this->link_);
2725
2726   elfcpp::Elf_Word info;
2727   if (this->info_section_ != NULL)
2728     {
2729       if (this->info_uses_section_index_)
2730         info = this->info_section_->out_shndx();
2731       else
2732         info = this->info_section_->symtab_index();
2733     }
2734   else if (this->info_symndx_ != NULL)
2735     info = this->info_symndx_->symtab_index();
2736   else
2737     info = this->info_;
2738   oshdr->put_sh_info(info);
2739
2740   oshdr->put_sh_addralign(this->addralign_);
2741   oshdr->put_sh_entsize(this->entsize_);
2742 }
2743
2744 // Write out the data.  For input sections the data is written out by
2745 // Object::relocate, but we have to handle Output_section_data objects
2746 // here.
2747
2748 void
2749 Output_section::do_write(Output_file* of)
2750 {
2751   gold_assert(!this->requires_postprocessing());
2752
2753   // If the target performs relaxation, we delay filler generation until now.
2754   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
2755
2756   off_t output_section_file_offset = this->offset();
2757   for (Fill_list::iterator p = this->fills_.begin();
2758        p != this->fills_.end();
2759        ++p)
2760     {
2761       std::string fill_data(parameters->target().code_fill(p->length()));
2762       of->write(output_section_file_offset + p->section_offset(),
2763                 fill_data.data(), fill_data.size());
2764     }
2765
2766   off_t off = this->offset() + this->first_input_offset_;
2767   for (Input_section_list::iterator p = this->input_sections_.begin();
2768        p != this->input_sections_.end();
2769        ++p)
2770     {
2771       off_t aligned_off = align_address(off, p->addralign());
2772       if (this->generate_code_fills_at_write_ && (off != aligned_off))
2773         {
2774           size_t fill_len = aligned_off - off;
2775           std::string fill_data(parameters->target().code_fill(fill_len));
2776           of->write(off, fill_data.data(), fill_data.size());
2777         }
2778
2779       p->write(of);
2780       off = aligned_off + p->data_size();
2781     }
2782 }
2783
2784 // If a section requires postprocessing, create the buffer to use.
2785
2786 void
2787 Output_section::create_postprocessing_buffer()
2788 {
2789   gold_assert(this->requires_postprocessing());
2790
2791   if (this->postprocessing_buffer_ != NULL)
2792     return;
2793
2794   if (!this->input_sections_.empty())
2795     {
2796       off_t off = this->first_input_offset_;
2797       for (Input_section_list::iterator p = this->input_sections_.begin();
2798            p != this->input_sections_.end();
2799            ++p)
2800         {
2801           off = align_address(off, p->addralign());
2802           p->finalize_data_size();
2803           off += p->data_size();
2804         }
2805       this->set_current_data_size_for_child(off);
2806     }
2807
2808   off_t buffer_size = this->current_data_size_for_child();
2809   this->postprocessing_buffer_ = new unsigned char[buffer_size];
2810 }
2811
2812 // Write all the data of an Output_section into the postprocessing
2813 // buffer.  This is used for sections which require postprocessing,
2814 // such as compression.  Input sections are handled by
2815 // Object::Relocate.
2816
2817 void
2818 Output_section::write_to_postprocessing_buffer()
2819 {
2820   gold_assert(this->requires_postprocessing());
2821
2822   // If the target performs relaxation, we delay filler generation until now.
2823   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
2824
2825   unsigned char* buffer = this->postprocessing_buffer();
2826   for (Fill_list::iterator p = this->fills_.begin();
2827        p != this->fills_.end();
2828        ++p)
2829     {
2830       std::string fill_data(parameters->target().code_fill(p->length()));
2831       memcpy(buffer + p->section_offset(), fill_data.data(),
2832              fill_data.size());
2833     }
2834
2835   off_t off = this->first_input_offset_;
2836   for (Input_section_list::iterator p = this->input_sections_.begin();
2837        p != this->input_sections_.end();
2838        ++p)
2839     {
2840       off_t aligned_off = align_address(off, p->addralign());
2841       if (this->generate_code_fills_at_write_ && (off != aligned_off))
2842         {
2843           size_t fill_len = aligned_off - off;
2844           std::string fill_data(parameters->target().code_fill(fill_len));
2845           memcpy(buffer + off, fill_data.data(), fill_data.size());
2846         }
2847
2848       p->write_to_buffer(buffer + aligned_off);
2849       off = aligned_off + p->data_size();
2850     }
2851 }
2852
2853 // Get the input sections for linker script processing.  We leave
2854 // behind the Output_section_data entries.  Note that this may be
2855 // slightly incorrect for merge sections.  We will leave them behind,
2856 // but it is possible that the script says that they should follow
2857 // some other input sections, as in:
2858 //    .rodata { *(.rodata) *(.rodata.cst*) }
2859 // For that matter, we don't handle this correctly:
2860 //    .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
2861 // With luck this will never matter.
2862
2863 uint64_t
2864 Output_section::get_input_sections(
2865     uint64_t address,
2866     const std::string& fill,
2867     std::list<Simple_input_section>* input_sections)
2868 {
2869   if (this->checkpoint_ != NULL
2870       && !this->checkpoint_->input_sections_saved())
2871     this->checkpoint_->save_input_sections();
2872
2873   // Invalidate the relaxed input section map.
2874   this->is_relaxed_input_section_map_valid_ = false;
2875
2876   uint64_t orig_address = address;
2877
2878   address = align_address(address, this->addralign());
2879
2880   Input_section_list remaining;
2881   for (Input_section_list::iterator p = this->input_sections_.begin();
2882        p != this->input_sections_.end();
2883        ++p)
2884     {
2885       if (p->is_input_section())
2886         input_sections->push_back(Simple_input_section(p->relobj(),
2887                                                        p->shndx()));
2888       else if (p->is_relaxed_input_section())
2889         input_sections->push_back(
2890             Simple_input_section(p->relaxed_input_section()));
2891       else
2892         {
2893           uint64_t aligned_address = align_address(address, p->addralign());
2894           if (aligned_address != address && !fill.empty())
2895             {
2896               section_size_type length =
2897                 convert_to_section_size_type(aligned_address - address);
2898               std::string this_fill;
2899               this_fill.reserve(length);
2900               while (this_fill.length() + fill.length() <= length)
2901                 this_fill += fill;
2902               if (this_fill.length() < length)
2903                 this_fill.append(fill, 0, length - this_fill.length());
2904
2905               Output_section_data* posd = new Output_data_const(this_fill, 0);
2906               remaining.push_back(Input_section(posd));
2907             }
2908           address = aligned_address;
2909
2910           remaining.push_back(*p);
2911
2912           p->finalize_data_size();
2913           address += p->data_size();
2914         }
2915     }
2916
2917   this->input_sections_.swap(remaining);
2918   this->first_input_offset_ = 0;
2919
2920   uint64_t data_size = address - orig_address;
2921   this->set_current_data_size_for_child(data_size);
2922   return data_size;
2923 }
2924
2925 // Add an input section from a script.
2926
2927 void
2928 Output_section::add_input_section_for_script(const Simple_input_section& sis,
2929                                              off_t data_size,
2930                                              uint64_t addralign)
2931 {
2932   if (addralign > this->addralign_)
2933     this->addralign_ = addralign;
2934
2935   off_t offset_in_section = this->current_data_size_for_child();
2936   off_t aligned_offset_in_section = align_address(offset_in_section,
2937                                                   addralign);
2938
2939   this->set_current_data_size_for_child(aligned_offset_in_section
2940                                         + data_size);
2941
2942   Input_section is =
2943     (sis.is_relaxed_input_section()
2944      ? Input_section(sis.relaxed_input_section())
2945      : Input_section(sis.relobj(), sis.shndx(), data_size, addralign));
2946   this->input_sections_.push_back(is);
2947 }
2948
2949 //
2950
2951 void
2952 Output_section::save_states()
2953 {
2954   gold_assert(this->checkpoint_ == NULL);
2955   Checkpoint_output_section* checkpoint =
2956     new Checkpoint_output_section(this->addralign_, this->flags_,
2957                                   this->input_sections_,
2958                                   this->first_input_offset_,
2959                                   this->attached_input_sections_are_sorted_);
2960   this->checkpoint_ = checkpoint;
2961   gold_assert(this->fills_.empty());
2962 }
2963
2964 void
2965 Output_section::restore_states()
2966 {
2967   gold_assert(this->checkpoint_ != NULL);
2968   Checkpoint_output_section* checkpoint = this->checkpoint_;
2969
2970   this->addralign_ = checkpoint->addralign();
2971   this->flags_ = checkpoint->flags();
2972   this->first_input_offset_ = checkpoint->first_input_offset();
2973
2974   if (!checkpoint->input_sections_saved())
2975     {
2976       // If we have not copied the input sections, just resize it.
2977       size_t old_size = checkpoint->input_sections_size();
2978       gold_assert(this->input_sections_.size() >= old_size);
2979       this->input_sections_.resize(old_size);
2980     }
2981   else
2982     {
2983       // We need to copy the whole list.  This is not efficient for
2984       // extremely large output with hundreads of thousands of input
2985       // objects.  We may need to re-think how we should pass sections
2986       // to scripts.
2987       this->input_sections_ = *checkpoint->input_sections();
2988     }
2989
2990   this->attached_input_sections_are_sorted_ =
2991     checkpoint->attached_input_sections_are_sorted();
2992
2993   // Simply invalidate the relaxed input section map since we do not keep
2994   // track of it.
2995   this->is_relaxed_input_section_map_valid_ = false;
2996 }
2997
2998 // Print to the map file.
2999
3000 void
3001 Output_section::do_print_to_mapfile(Mapfile* mapfile) const
3002 {
3003   mapfile->print_output_section(this);
3004
3005   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3006        p != this->input_sections_.end();
3007        ++p)
3008     p->print_to_mapfile(mapfile);
3009 }
3010
3011 // Print stats for merge sections to stderr.
3012
3013 void
3014 Output_section::print_merge_stats()
3015 {
3016   Input_section_list::iterator p;
3017   for (p = this->input_sections_.begin();
3018        p != this->input_sections_.end();
3019        ++p)
3020     p->print_merge_stats(this->name_);
3021 }
3022
3023 // Output segment methods.
3024
3025 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
3026   : output_data_(),
3027     output_bss_(),
3028     vaddr_(0),
3029     paddr_(0),
3030     memsz_(0),
3031     max_align_(0),
3032     min_p_align_(0),
3033     offset_(0),
3034     filesz_(0),
3035     type_(type),
3036     flags_(flags),
3037     is_max_align_known_(false),
3038     are_addresses_set_(false),
3039     is_large_data_segment_(false)
3040 {
3041 }
3042
3043 // Add an Output_section to an Output_segment.
3044
3045 void
3046 Output_segment::add_output_section(Output_section* os,
3047                                    elfcpp::Elf_Word seg_flags,
3048                                    bool do_sort)
3049 {
3050   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
3051   gold_assert(!this->is_max_align_known_);
3052   gold_assert(os->is_large_data_section() == this->is_large_data_segment());
3053
3054   // Update the segment flags.
3055   this->flags_ |= seg_flags;
3056
3057   Output_segment::Output_data_list* pdl;
3058   if (os->type() == elfcpp::SHT_NOBITS)
3059     pdl = &this->output_bss_;
3060   else
3061     pdl = &this->output_data_;
3062
3063   // Note that while there may be many input sections in an output
3064   // section, there are normally only a few output sections in an
3065   // output segment.  The loops below are expected to be fast.
3066
3067   // So that PT_NOTE segments will work correctly, we need to ensure
3068   // that all SHT_NOTE sections are adjacent.  This will normally
3069   // happen automatically, because all the SHT_NOTE input sections
3070   // will wind up in the same output section.  However, it is possible
3071   // for multiple SHT_NOTE input sections to have different section
3072   // flags, and thus be in different output sections, but for the
3073   // different section flags to map into the same segment flags and
3074   // thus the same output segment.
3075   if (os->type() == elfcpp::SHT_NOTE && !pdl->empty())
3076     {
3077       Output_segment::Output_data_list::iterator p = pdl->end();
3078       do
3079         {
3080           --p;
3081           if ((*p)->is_section_type(elfcpp::SHT_NOTE))
3082             {
3083               ++p;
3084               pdl->insert(p, os);
3085               return;
3086             }
3087         }
3088       while (p != pdl->begin());
3089     }
3090
3091   // Similarly, so that PT_TLS segments will work, we need to group
3092   // SHF_TLS sections.  An SHF_TLS/SHT_NOBITS section is a special
3093   // case: we group the SHF_TLS/SHT_NOBITS sections right after the
3094   // SHF_TLS/SHT_PROGBITS sections.  This lets us set up PT_TLS
3095   // correctly.  SHF_TLS sections get added to both a PT_LOAD segment
3096   // and the PT_TLS segment; we do this grouping only for the PT_LOAD
3097   // segment.
3098   if (this->type_ != elfcpp::PT_TLS
3099       && (os->flags() & elfcpp::SHF_TLS) != 0)
3100     {
3101       pdl = &this->output_data_;
3102       if (!pdl->empty())
3103         {
3104           bool nobits = os->type() == elfcpp::SHT_NOBITS;
3105           bool sawtls = false;
3106           Output_segment::Output_data_list::iterator p = pdl->end();
3107           gold_assert(p != pdl->begin());
3108           do
3109             {
3110               --p;
3111               bool insert;
3112               if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
3113                 {
3114                   sawtls = true;
3115                   // Put a NOBITS section after the first TLS section.
3116                   // Put a PROGBITS section after the first
3117                   // TLS/PROGBITS section.
3118                   insert = nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS);
3119                 }
3120               else
3121                 {
3122                   // If we've gone past the TLS sections, but we've
3123                   // seen a TLS section, then we need to insert this
3124                   // section now.
3125                   insert = sawtls;
3126                 }
3127
3128               if (insert)
3129                 {
3130                   ++p;
3131                   pdl->insert(p, os);
3132                   return;
3133                 }
3134             }
3135           while (p != pdl->begin());
3136         }
3137
3138       // There are no TLS sections yet; put this one at the requested
3139       // location in the section list.
3140     }
3141
3142   // For the PT_GNU_RELRO segment, we need to group relro sections,
3143   // and we need to put them before any non-relro sections.  Also,
3144   // relro local sections go before relro non-local sections.
3145   if (parameters->options().relro() && os->is_relro())
3146     {
3147       gold_assert(pdl == &this->output_data_);
3148       Output_segment::Output_data_list::iterator p;
3149       for (p = pdl->begin(); p != pdl->end(); ++p)
3150         {
3151           if (!(*p)->is_section())
3152             break;
3153
3154           Output_section* pos = (*p)->output_section();
3155           if (!pos->is_relro()
3156               || (os->is_relro_local() && !pos->is_relro_local()))
3157             break;
3158         }
3159
3160       pdl->insert(p, os);
3161       return;
3162     }
3163
3164   // Small data sections go at the end of the list of data sections.
3165   // If OS is not small, and there are small sections, we have to
3166   // insert it before the first small section.
3167   if (os->type() != elfcpp::SHT_NOBITS
3168       && !os->is_small_section()
3169       && !pdl->empty()
3170       && pdl->back()->is_section()
3171       && pdl->back()->output_section()->is_small_section())
3172     {
3173       for (Output_segment::Output_data_list::iterator p = pdl->begin();
3174            p != pdl->end();
3175            ++p)
3176         {
3177           if ((*p)->is_section()
3178               && (*p)->output_section()->is_small_section())
3179             {
3180               pdl->insert(p, os);
3181               return;
3182             }
3183         }
3184       gold_unreachable();
3185     }
3186
3187   // A small BSS section goes at the start of the BSS sections, after
3188   // other small BSS sections.
3189   if (os->type() == elfcpp::SHT_NOBITS && os->is_small_section())
3190     {
3191       for (Output_segment::Output_data_list::iterator p = pdl->begin();
3192            p != pdl->end();
3193            ++p)
3194         {
3195           if (!(*p)->is_section()
3196               || !(*p)->output_section()->is_small_section())
3197             {
3198               pdl->insert(p, os);
3199               return;
3200             }
3201         }
3202     }
3203
3204   // A large BSS section goes at the end of the BSS sections, which
3205   // means that one that is not large must come before the first large
3206   // one.
3207   if (os->type() == elfcpp::SHT_NOBITS
3208       && !os->is_large_section()
3209       && !pdl->empty()
3210       && pdl->back()->is_section()
3211       && pdl->back()->output_section()->is_large_section())
3212     {
3213       for (Output_segment::Output_data_list::iterator p = pdl->begin();
3214            p != pdl->end();
3215            ++p)
3216         {
3217           if ((*p)->is_section()
3218               && (*p)->output_section()->is_large_section())
3219             {
3220               pdl->insert(p, os);
3221               return;
3222             }
3223         }
3224       gold_unreachable();
3225     }
3226
3227   // We do some further output section sorting in order to make the
3228   // generated program run more efficiently.  We should only do this
3229   // when not using a linker script, so it is controled by the DO_SORT
3230   // parameter.
3231   if (do_sort)
3232     {
3233       // FreeBSD requires the .interp section to be in the first page
3234       // of the executable.  That is a more efficient location anyhow
3235       // for any OS, since it means that the kernel will have the data
3236       // handy after it reads the program headers.
3237       if (os->is_interp() && !pdl->empty())
3238         {
3239           pdl->insert(pdl->begin(), os);
3240           return;
3241         }
3242
3243       // Put loadable non-writable notes immediately after the .interp
3244       // sections, so that the PT_NOTE segment is on the first page of
3245       // the executable.
3246       if (os->type() == elfcpp::SHT_NOTE
3247           && (os->flags() & elfcpp::SHF_WRITE) == 0
3248           && !pdl->empty())
3249         {
3250           Output_segment::Output_data_list::iterator p = pdl->begin();
3251           if ((*p)->is_section() && (*p)->output_section()->is_interp())
3252             ++p;
3253           pdl->insert(p, os);
3254         }
3255
3256       // If this section is used by the dynamic linker, and it is not
3257       // writable, then put it first, after the .interp section and
3258       // any loadable notes.  This makes it more likely that the
3259       // dynamic linker will have to read less data from the disk.
3260       if (os->is_dynamic_linker_section()
3261           && !pdl->empty()
3262           && (os->flags() & elfcpp::SHF_WRITE) == 0)
3263         {
3264           bool is_reloc = (os->type() == elfcpp::SHT_REL
3265                            || os->type() == elfcpp::SHT_RELA);
3266           Output_segment::Output_data_list::iterator p = pdl->begin();
3267           while (p != pdl->end()
3268                  && (*p)->is_section()
3269                  && ((*p)->output_section()->is_dynamic_linker_section()
3270                      || (*p)->output_section()->type() == elfcpp::SHT_NOTE))
3271             {
3272               // Put reloc sections after the other ones.  Putting the
3273               // dynamic reloc sections first confuses BFD, notably
3274               // objcopy and strip.
3275               if (!is_reloc
3276                   && ((*p)->output_section()->type() == elfcpp::SHT_REL
3277                       || (*p)->output_section()->type() == elfcpp::SHT_RELA))
3278                 break;
3279               ++p;
3280             }
3281           pdl->insert(p, os);
3282           return;
3283         }
3284     }
3285
3286   // If there were no constraints on the output section, just add it
3287   // to the end of the list.
3288   pdl->push_back(os);
3289 }
3290
3291 // Remove an Output_section from this segment.  It is an error if it
3292 // is not present.
3293
3294 void
3295 Output_segment::remove_output_section(Output_section* os)
3296 {
3297   // We only need this for SHT_PROGBITS.
3298   gold_assert(os->type() == elfcpp::SHT_PROGBITS);
3299   for (Output_data_list::iterator p = this->output_data_.begin();
3300        p != this->output_data_.end();
3301        ++p)
3302    {
3303      if (*p == os)
3304        {
3305          this->output_data_.erase(p);
3306          return;
3307        }
3308    }
3309   gold_unreachable();
3310 }
3311
3312 // Add an Output_data (which is not an Output_section) to the start of
3313 // a segment.
3314
3315 void
3316 Output_segment::add_initial_output_data(Output_data* od)
3317 {
3318   gold_assert(!this->is_max_align_known_);
3319   this->output_data_.push_front(od);
3320 }
3321
3322 // Return whether the first data section is a relro section.
3323
3324 bool
3325 Output_segment::is_first_section_relro() const
3326 {
3327   return (!this->output_data_.empty()
3328           && this->output_data_.front()->is_section()
3329           && this->output_data_.front()->output_section()->is_relro());
3330 }
3331
3332 // Return the maximum alignment of the Output_data in Output_segment.
3333
3334 uint64_t
3335 Output_segment::maximum_alignment()
3336 {
3337   if (!this->is_max_align_known_)
3338     {
3339       uint64_t addralign;
3340
3341       addralign = Output_segment::maximum_alignment_list(&this->output_data_);
3342       if (addralign > this->max_align_)
3343         this->max_align_ = addralign;
3344
3345       addralign = Output_segment::maximum_alignment_list(&this->output_bss_);
3346       if (addralign > this->max_align_)
3347         this->max_align_ = addralign;
3348
3349       // If -z relro is in effect, and the first section in this
3350       // segment is a relro section, then the segment must be aligned
3351       // to at least the common page size.  This ensures that the
3352       // PT_GNU_RELRO segment will start at a page boundary.
3353       if (this->type_ == elfcpp::PT_LOAD
3354           && parameters->options().relro()
3355           && this->is_first_section_relro())
3356         {
3357           addralign = parameters->target().common_pagesize();
3358           if (addralign > this->max_align_)
3359             this->max_align_ = addralign;
3360         }
3361
3362       this->is_max_align_known_ = true;
3363     }
3364
3365   return this->max_align_;
3366 }
3367
3368 // Return the maximum alignment of a list of Output_data.
3369
3370 uint64_t
3371 Output_segment::maximum_alignment_list(const Output_data_list* pdl)
3372 {
3373   uint64_t ret = 0;
3374   for (Output_data_list::const_iterator p = pdl->begin();
3375        p != pdl->end();
3376        ++p)
3377     {
3378       uint64_t addralign = (*p)->addralign();
3379       if (addralign > ret)
3380         ret = addralign;
3381     }
3382   return ret;
3383 }
3384
3385 // Return the number of dynamic relocs applied to this segment.
3386
3387 unsigned int
3388 Output_segment::dynamic_reloc_count() const
3389 {
3390   return (this->dynamic_reloc_count_list(&this->output_data_)
3391           + this->dynamic_reloc_count_list(&this->output_bss_));
3392 }
3393
3394 // Return the number of dynamic relocs applied to an Output_data_list.
3395
3396 unsigned int
3397 Output_segment::dynamic_reloc_count_list(const Output_data_list* pdl) const
3398 {
3399   unsigned int count = 0;
3400   for (Output_data_list::const_iterator p = pdl->begin();
3401        p != pdl->end();
3402        ++p)
3403     count += (*p)->dynamic_reloc_count();
3404   return count;
3405 }
3406
3407 // Set the section addresses for an Output_segment.  If RESET is true,
3408 // reset the addresses first.  ADDR is the address and *POFF is the
3409 // file offset.  Set the section indexes starting with *PSHNDX.
3410 // Return the address of the immediately following segment.  Update
3411 // *POFF and *PSHNDX.
3412
3413 uint64_t
3414 Output_segment::set_section_addresses(const Layout* layout, bool reset,
3415                                       uint64_t addr, off_t* poff,
3416                                       unsigned int* pshndx)
3417 {
3418   gold_assert(this->type_ == elfcpp::PT_LOAD);
3419
3420   if (!reset && this->are_addresses_set_)
3421     {
3422       gold_assert(this->paddr_ == addr);
3423       addr = this->vaddr_;
3424     }
3425   else
3426     {
3427       this->vaddr_ = addr;
3428       this->paddr_ = addr;
3429       this->are_addresses_set_ = true;
3430     }
3431
3432   bool in_tls = false;
3433
3434   bool in_relro = (parameters->options().relro()
3435                    && this->is_first_section_relro());
3436
3437   off_t orig_off = *poff;
3438   this->offset_ = orig_off;
3439
3440   addr = this->set_section_list_addresses(layout, reset, &this->output_data_,
3441                                           addr, poff, pshndx, &in_tls,
3442                                           &in_relro);
3443   this->filesz_ = *poff - orig_off;
3444
3445   off_t off = *poff;
3446
3447   uint64_t ret = this->set_section_list_addresses(layout, reset,
3448                                                   &this->output_bss_,
3449                                                   addr, poff, pshndx,
3450                                                   &in_tls, &in_relro);
3451
3452   // If the last section was a TLS section, align upward to the
3453   // alignment of the TLS segment, so that the overall size of the TLS
3454   // segment is aligned.
3455   if (in_tls)
3456     {
3457       uint64_t segment_align = layout->tls_segment()->maximum_alignment();
3458       *poff = align_address(*poff, segment_align);
3459     }
3460
3461   // If all the sections were relro sections, align upward to the
3462   // common page size.
3463   if (in_relro)
3464     {
3465       uint64_t page_align = parameters->target().common_pagesize();
3466       *poff = align_address(*poff, page_align);
3467     }
3468
3469   this->memsz_ = *poff - orig_off;
3470
3471   // Ignore the file offset adjustments made by the BSS Output_data
3472   // objects.
3473   *poff = off;
3474
3475   return ret;
3476 }
3477
3478 // Set the addresses and file offsets in a list of Output_data
3479 // structures.
3480
3481 uint64_t
3482 Output_segment::set_section_list_addresses(const Layout* layout, bool reset,
3483                                            Output_data_list* pdl,
3484                                            uint64_t addr, off_t* poff,
3485                                            unsigned int* pshndx,
3486                                            bool* in_tls, bool* in_relro)
3487 {
3488   off_t startoff = *poff;
3489
3490   off_t off = startoff;
3491   for (Output_data_list::iterator p = pdl->begin();
3492        p != pdl->end();
3493        ++p)
3494     {
3495       if (reset)
3496         (*p)->reset_address_and_file_offset();
3497
3498       // When using a linker script the section will most likely
3499       // already have an address.
3500       if (!(*p)->is_address_valid())
3501         {
3502           uint64_t align = (*p)->addralign();
3503
3504           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
3505             {
3506               // Give the first TLS section the alignment of the
3507               // entire TLS segment.  Otherwise the TLS segment as a
3508               // whole may be misaligned.
3509               if (!*in_tls)
3510                 {
3511                   Output_segment* tls_segment = layout->tls_segment();
3512                   gold_assert(tls_segment != NULL);
3513                   uint64_t segment_align = tls_segment->maximum_alignment();
3514                   gold_assert(segment_align >= align);
3515                   align = segment_align;
3516
3517                   *in_tls = true;
3518                 }
3519             }
3520           else
3521             {
3522               // If this is the first section after the TLS segment,
3523               // align it to at least the alignment of the TLS
3524               // segment, so that the size of the overall TLS segment
3525               // is aligned.
3526               if (*in_tls)
3527                 {
3528                   uint64_t segment_align =
3529                       layout->tls_segment()->maximum_alignment();
3530                   if (segment_align > align)
3531                     align = segment_align;
3532
3533                   *in_tls = false;
3534                 }
3535             }
3536
3537           // If this is a non-relro section after a relro section,
3538           // align it to a common page boundary so that the dynamic
3539           // linker has a page to mark as read-only.
3540           if (*in_relro
3541               && (!(*p)->is_section()
3542                   || !(*p)->output_section()->is_relro()))
3543             {
3544               uint64_t page_align = parameters->target().common_pagesize();
3545               if (page_align > align)
3546                 align = page_align;
3547               *in_relro = false;
3548             }
3549
3550           off = align_address(off, align);
3551           (*p)->set_address_and_file_offset(addr + (off - startoff), off);
3552         }
3553       else
3554         {
3555           // The script may have inserted a skip forward, but it
3556           // better not have moved backward.
3557           if ((*p)->address() >= addr + (off - startoff))
3558             off += (*p)->address() - (addr + (off - startoff));
3559           else
3560             {
3561               if (!layout->script_options()->saw_sections_clause())
3562                 gold_unreachable();
3563               else
3564                 {
3565                   Output_section* os = (*p)->output_section();
3566
3567                   // Cast to unsigned long long to avoid format warnings.
3568                   unsigned long long previous_dot =
3569                     static_cast<unsigned long long>(addr + (off - startoff));
3570                   unsigned long long dot =
3571                     static_cast<unsigned long long>((*p)->address());
3572
3573                   if (os == NULL)
3574                     gold_error(_("dot moves backward in linker script "
3575                                  "from 0x%llx to 0x%llx"), previous_dot, dot);
3576                   else
3577                     gold_error(_("address of section '%s' moves backward "
3578                                  "from 0x%llx to 0x%llx"),
3579                                os->name(), previous_dot, dot);
3580                 }
3581             }
3582           (*p)->set_file_offset(off);
3583           (*p)->finalize_data_size();
3584         }
3585
3586       // We want to ignore the size of a SHF_TLS or SHT_NOBITS
3587       // section.  Such a section does not affect the size of a
3588       // PT_LOAD segment.
3589       if (!(*p)->is_section_flag_set(elfcpp::SHF_TLS)
3590           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
3591         off += (*p)->data_size();
3592
3593       if ((*p)->is_section())
3594         {
3595           (*p)->set_out_shndx(*pshndx);
3596           ++*pshndx;
3597         }
3598     }
3599
3600   *poff = off;
3601   return addr + (off - startoff);
3602 }
3603
3604 // For a non-PT_LOAD segment, set the offset from the sections, if
3605 // any.
3606
3607 void
3608 Output_segment::set_offset()
3609 {
3610   gold_assert(this->type_ != elfcpp::PT_LOAD);
3611
3612   gold_assert(!this->are_addresses_set_);
3613
3614   if (this->output_data_.empty() && this->output_bss_.empty())
3615     {
3616       this->vaddr_ = 0;
3617       this->paddr_ = 0;
3618       this->are_addresses_set_ = true;
3619       this->memsz_ = 0;
3620       this->min_p_align_ = 0;
3621       this->offset_ = 0;
3622       this->filesz_ = 0;
3623       return;
3624     }
3625
3626   const Output_data* first;
3627   if (this->output_data_.empty())
3628     first = this->output_bss_.front();
3629   else
3630     first = this->output_data_.front();
3631   this->vaddr_ = first->address();
3632   this->paddr_ = (first->has_load_address()
3633                   ? first->load_address()
3634                   : this->vaddr_);
3635   this->are_addresses_set_ = true;
3636   this->offset_ = first->offset();
3637
3638   if (this->output_data_.empty())
3639     this->filesz_ = 0;
3640   else
3641     {
3642       const Output_data* last_data = this->output_data_.back();
3643       this->filesz_ = (last_data->address()
3644                        + last_data->data_size()
3645                        - this->vaddr_);
3646     }
3647
3648   const Output_data* last;
3649   if (this->output_bss_.empty())
3650     last = this->output_data_.back();
3651   else
3652     last = this->output_bss_.back();
3653   this->memsz_ = (last->address()
3654                   + last->data_size()
3655                   - this->vaddr_);
3656
3657   // If this is a TLS segment, align the memory size.  The code in
3658   // set_section_list ensures that the section after the TLS segment
3659   // is aligned to give us room.
3660   if (this->type_ == elfcpp::PT_TLS)
3661     {
3662       uint64_t segment_align = this->maximum_alignment();
3663       gold_assert(this->vaddr_ == align_address(this->vaddr_, segment_align));
3664       this->memsz_ = align_address(this->memsz_, segment_align);
3665     }
3666
3667   // If this is a RELRO segment, align the memory size.  The code in
3668   // set_section_list ensures that the section after the RELRO segment
3669   // is aligned to give us room.
3670   if (this->type_ == elfcpp::PT_GNU_RELRO)
3671     {
3672       uint64_t page_align = parameters->target().common_pagesize();
3673       gold_assert(this->vaddr_ == align_address(this->vaddr_, page_align));
3674       this->memsz_ = align_address(this->memsz_, page_align);
3675     }
3676 }
3677
3678 // Set the TLS offsets of the sections in the PT_TLS segment.
3679
3680 void
3681 Output_segment::set_tls_offsets()
3682 {
3683   gold_assert(this->type_ == elfcpp::PT_TLS);
3684
3685   for (Output_data_list::iterator p = this->output_data_.begin();
3686        p != this->output_data_.end();
3687        ++p)
3688     (*p)->set_tls_offset(this->vaddr_);
3689
3690   for (Output_data_list::iterator p = this->output_bss_.begin();
3691        p != this->output_bss_.end();
3692        ++p)
3693     (*p)->set_tls_offset(this->vaddr_);
3694 }
3695
3696 // Return the address of the first section.
3697
3698 uint64_t
3699 Output_segment::first_section_load_address() const
3700 {
3701   for (Output_data_list::const_iterator p = this->output_data_.begin();
3702        p != this->output_data_.end();
3703        ++p)
3704     if ((*p)->is_section())
3705       return (*p)->has_load_address() ? (*p)->load_address() : (*p)->address();
3706
3707   for (Output_data_list::const_iterator p = this->output_bss_.begin();
3708        p != this->output_bss_.end();
3709        ++p)
3710     if ((*p)->is_section())
3711       return (*p)->has_load_address() ? (*p)->load_address() : (*p)->address();
3712
3713   gold_unreachable();
3714 }
3715
3716 // Return the number of Output_sections in an Output_segment.
3717
3718 unsigned int
3719 Output_segment::output_section_count() const
3720 {
3721   return (this->output_section_count_list(&this->output_data_)
3722           + this->output_section_count_list(&this->output_bss_));
3723 }
3724
3725 // Return the number of Output_sections in an Output_data_list.
3726
3727 unsigned int
3728 Output_segment::output_section_count_list(const Output_data_list* pdl) const
3729 {
3730   unsigned int count = 0;
3731   for (Output_data_list::const_iterator p = pdl->begin();
3732        p != pdl->end();
3733        ++p)
3734     {
3735       if ((*p)->is_section())
3736         ++count;
3737     }
3738   return count;
3739 }
3740
3741 // Return the section attached to the list segment with the lowest
3742 // load address.  This is used when handling a PHDRS clause in a
3743 // linker script.
3744
3745 Output_section*
3746 Output_segment::section_with_lowest_load_address() const
3747 {
3748   Output_section* found = NULL;
3749   uint64_t found_lma = 0;
3750   this->lowest_load_address_in_list(&this->output_data_, &found, &found_lma);
3751
3752   Output_section* found_data = found;
3753   this->lowest_load_address_in_list(&this->output_bss_, &found, &found_lma);
3754   if (found != found_data && found_data != NULL)
3755     {
3756       gold_error(_("nobits section %s may not precede progbits section %s "
3757                    "in same segment"),
3758                  found->name(), found_data->name());
3759       return NULL;
3760     }
3761
3762   return found;
3763 }
3764
3765 // Look through a list for a section with a lower load address.
3766
3767 void
3768 Output_segment::lowest_load_address_in_list(const Output_data_list* pdl,
3769                                             Output_section** found,
3770                                             uint64_t* found_lma) const
3771 {
3772   for (Output_data_list::const_iterator p = pdl->begin();
3773        p != pdl->end();
3774        ++p)
3775     {
3776       if (!(*p)->is_section())
3777         continue;
3778       Output_section* os = static_cast<Output_section*>(*p);
3779       uint64_t lma = (os->has_load_address()
3780                       ? os->load_address()
3781                       : os->address());
3782       if (*found == NULL || lma < *found_lma)
3783         {
3784           *found = os;
3785           *found_lma = lma;
3786         }
3787     }
3788 }
3789
3790 // Write the segment data into *OPHDR.
3791
3792 template<int size, bool big_endian>
3793 void
3794 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
3795 {
3796   ophdr->put_p_type(this->type_);
3797   ophdr->put_p_offset(this->offset_);
3798   ophdr->put_p_vaddr(this->vaddr_);
3799   ophdr->put_p_paddr(this->paddr_);
3800   ophdr->put_p_filesz(this->filesz_);
3801   ophdr->put_p_memsz(this->memsz_);
3802   ophdr->put_p_flags(this->flags_);
3803   ophdr->put_p_align(std::max(this->min_p_align_, this->maximum_alignment()));
3804 }
3805
3806 // Write the section headers into V.
3807
3808 template<int size, bool big_endian>
3809 unsigned char*
3810 Output_segment::write_section_headers(const Layout* layout,
3811                                       const Stringpool* secnamepool,
3812                                       unsigned char* v,
3813                                       unsigned int *pshndx) const
3814 {
3815   // Every section that is attached to a segment must be attached to a
3816   // PT_LOAD segment, so we only write out section headers for PT_LOAD
3817   // segments.
3818   if (this->type_ != elfcpp::PT_LOAD)
3819     return v;
3820
3821   v = this->write_section_headers_list<size, big_endian>(layout, secnamepool,
3822                                                          &this->output_data_,
3823                                                          v, pshndx);
3824   v = this->write_section_headers_list<size, big_endian>(layout, secnamepool,
3825                                                          &this->output_bss_,
3826                                                          v, pshndx);
3827   return v;
3828 }
3829
3830 template<int size, bool big_endian>
3831 unsigned char*
3832 Output_segment::write_section_headers_list(const Layout* layout,
3833                                            const Stringpool* secnamepool,
3834                                            const Output_data_list* pdl,
3835                                            unsigned char* v,
3836                                            unsigned int* pshndx) const
3837 {
3838   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
3839   for (Output_data_list::const_iterator p = pdl->begin();
3840        p != pdl->end();
3841        ++p)
3842     {
3843       if ((*p)->is_section())
3844         {
3845           const Output_section* ps = static_cast<const Output_section*>(*p);
3846           gold_assert(*pshndx == ps->out_shndx());
3847           elfcpp::Shdr_write<size, big_endian> oshdr(v);
3848           ps->write_header(layout, secnamepool, &oshdr);
3849           v += shdr_size;
3850           ++*pshndx;
3851         }
3852     }
3853   return v;
3854 }
3855
3856 // Print the output sections to the map file.
3857
3858 void
3859 Output_segment::print_sections_to_mapfile(Mapfile* mapfile) const
3860 {
3861   if (this->type() != elfcpp::PT_LOAD)
3862     return;
3863   this->print_section_list_to_mapfile(mapfile, &this->output_data_);
3864   this->print_section_list_to_mapfile(mapfile, &this->output_bss_);
3865 }
3866
3867 // Print an output section list to the map file.
3868
3869 void
3870 Output_segment::print_section_list_to_mapfile(Mapfile* mapfile,
3871                                               const Output_data_list* pdl) const
3872 {
3873   for (Output_data_list::const_iterator p = pdl->begin();
3874        p != pdl->end();
3875        ++p)
3876     (*p)->print_to_mapfile(mapfile);
3877 }
3878
3879 // Output_file methods.
3880
3881 Output_file::Output_file(const char* name)
3882   : name_(name),
3883     o_(-1),
3884     file_size_(0),
3885     base_(NULL),
3886     map_is_anonymous_(false),
3887     is_temporary_(false)
3888 {
3889 }
3890
3891 // Try to open an existing file.  Returns false if the file doesn't
3892 // exist, has a size of 0 or can't be mmapped.
3893
3894 bool
3895 Output_file::open_for_modification()
3896 {
3897   // The name "-" means "stdout".
3898   if (strcmp(this->name_, "-") == 0)
3899     return false;
3900
3901   // Don't bother opening files with a size of zero.
3902   struct stat s;
3903   if (::stat(this->name_, &s) != 0 || s.st_size == 0)
3904     return false;
3905
3906   int o = open_descriptor(-1, this->name_, O_RDWR, 0);
3907   if (o < 0)
3908     gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
3909   this->o_ = o;
3910   this->file_size_ = s.st_size;
3911
3912   // If the file can't be mmapped, copying the content to an anonymous
3913   // map will probably negate the performance benefits of incremental
3914   // linking.  This could be helped by using views and loading only
3915   // the necessary parts, but this is not supported as of now.
3916   if (!this->map_no_anonymous())
3917     {
3918       release_descriptor(o, true);
3919       this->o_ = -1;
3920       this->file_size_ = 0;
3921       return false;
3922     }
3923
3924   return true;
3925 }
3926
3927 // Open the output file.
3928
3929 void
3930 Output_file::open(off_t file_size)
3931 {
3932   this->file_size_ = file_size;
3933
3934   // Unlink the file first; otherwise the open() may fail if the file
3935   // is busy (e.g. it's an executable that's currently being executed).
3936   //
3937   // However, the linker may be part of a system where a zero-length
3938   // file is created for it to write to, with tight permissions (gcc
3939   // 2.95 did something like this).  Unlinking the file would work
3940   // around those permission controls, so we only unlink if the file
3941   // has a non-zero size.  We also unlink only regular files to avoid
3942   // trouble with directories/etc.
3943   //
3944   // If we fail, continue; this command is merely a best-effort attempt
3945   // to improve the odds for open().
3946
3947   // We let the name "-" mean "stdout"
3948   if (!this->is_temporary_)
3949     {
3950       if (strcmp(this->name_, "-") == 0)
3951         this->o_ = STDOUT_FILENO;
3952       else
3953         {
3954           struct stat s;
3955           if (::stat(this->name_, &s) == 0
3956               && (S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
3957             {
3958               if (s.st_size != 0)
3959                 ::unlink(this->name_);
3960               else if (!parameters->options().relocatable())
3961                 {
3962                   // If we don't unlink the existing file, add execute
3963                   // permission where read permissions already exist
3964                   // and where the umask permits.
3965                   int mask = ::umask(0);
3966                   ::umask(mask);
3967                   s.st_mode |= (s.st_mode & 0444) >> 2;
3968                   ::chmod(this->name_, s.st_mode & ~mask);
3969                 }
3970             }
3971
3972           int mode = parameters->options().relocatable() ? 0666 : 0777;
3973           int o = open_descriptor(-1, this->name_, O_RDWR | O_CREAT | O_TRUNC,
3974                                   mode);
3975           if (o < 0)
3976             gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
3977           this->o_ = o;
3978         }
3979     }
3980
3981   this->map();
3982 }
3983
3984 // Resize the output file.
3985
3986 void
3987 Output_file::resize(off_t file_size)
3988 {
3989   // If the mmap is mapping an anonymous memory buffer, this is easy:
3990   // just mremap to the new size.  If it's mapping to a file, we want
3991   // to unmap to flush to the file, then remap after growing the file.
3992   if (this->map_is_anonymous_)
3993     {
3994       void* base = ::mremap(this->base_, this->file_size_, file_size,
3995                             MREMAP_MAYMOVE);
3996       if (base == MAP_FAILED)
3997         gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
3998       this->base_ = static_cast<unsigned char*>(base);
3999       this->file_size_ = file_size;
4000     }
4001   else
4002     {
4003       this->unmap();
4004       this->file_size_ = file_size;
4005       if (!this->map_no_anonymous())
4006         gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
4007     }
4008 }
4009
4010 // Map an anonymous block of memory which will later be written to the
4011 // file.  Return whether the map succeeded.
4012
4013 bool
4014 Output_file::map_anonymous()
4015 {
4016   void* base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
4017                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
4018   if (base != MAP_FAILED)
4019     {
4020       this->map_is_anonymous_ = true;
4021       this->base_ = static_cast<unsigned char*>(base);
4022       return true;
4023     }
4024   return false;
4025 }
4026
4027 // Map the file into memory.  Return whether the mapping succeeded.
4028
4029 bool
4030 Output_file::map_no_anonymous()
4031 {
4032   const int o = this->o_;
4033
4034   // If the output file is not a regular file, don't try to mmap it;
4035   // instead, we'll mmap a block of memory (an anonymous buffer), and
4036   // then later write the buffer to the file.
4037   void* base;
4038   struct stat statbuf;
4039   if (o == STDOUT_FILENO || o == STDERR_FILENO
4040       || ::fstat(o, &statbuf) != 0
4041       || !S_ISREG(statbuf.st_mode)
4042       || this->is_temporary_)
4043     return false;
4044
4045   // Ensure that we have disk space available for the file.  If we
4046   // don't do this, it is possible that we will call munmap, close,
4047   // and exit with dirty buffers still in the cache with no assigned
4048   // disk blocks.  If the disk is out of space at that point, the
4049   // output file will wind up incomplete, but we will have already
4050   // exited.  The alternative to fallocate would be to use fdatasync,
4051   // but that would be a more significant performance hit.
4052   if (::posix_fallocate(o, 0, this->file_size_) < 0)
4053     gold_fatal(_("%s: %s"), this->name_, strerror(errno));
4054
4055   // Map the file into memory.
4056   base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
4057                 MAP_SHARED, o, 0);
4058
4059   // The mmap call might fail because of file system issues: the file
4060   // system might not support mmap at all, or it might not support
4061   // mmap with PROT_WRITE.
4062   if (base == MAP_FAILED)
4063     return false;
4064
4065   this->map_is_anonymous_ = false;
4066   this->base_ = static_cast<unsigned char*>(base);
4067   return true;
4068 }
4069
4070 // Map the file into memory.
4071
4072 void
4073 Output_file::map()
4074 {
4075   if (this->map_no_anonymous())
4076     return;
4077
4078   // The mmap call might fail because of file system issues: the file
4079   // system might not support mmap at all, or it might not support
4080   // mmap with PROT_WRITE.  I'm not sure which errno values we will
4081   // see in all cases, so if the mmap fails for any reason and we
4082   // don't care about file contents, try for an anonymous map.
4083   if (this->map_anonymous())
4084     return;
4085
4086   gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
4087              this->name_, static_cast<unsigned long>(this->file_size_),
4088              strerror(errno));
4089 }
4090
4091 // Unmap the file from memory.
4092
4093 void
4094 Output_file::unmap()
4095 {
4096   if (::munmap(this->base_, this->file_size_) < 0)
4097     gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
4098   this->base_ = NULL;
4099 }
4100
4101 // Close the output file.
4102
4103 void
4104 Output_file::close()
4105 {
4106   // If the map isn't file-backed, we need to write it now.
4107   if (this->map_is_anonymous_ && !this->is_temporary_)
4108     {
4109       size_t bytes_to_write = this->file_size_;
4110       size_t offset = 0;
4111       while (bytes_to_write > 0)
4112         {
4113           ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
4114                                           bytes_to_write);
4115           if (bytes_written == 0)
4116             gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
4117           else if (bytes_written < 0)
4118             gold_error(_("%s: write: %s"), this->name_, strerror(errno));
4119           else
4120             {
4121               bytes_to_write -= bytes_written;
4122               offset += bytes_written;
4123             }
4124         }
4125     }
4126   this->unmap();
4127
4128   // We don't close stdout or stderr
4129   if (this->o_ != STDOUT_FILENO
4130       && this->o_ != STDERR_FILENO
4131       && !this->is_temporary_)
4132     if (::close(this->o_) < 0)
4133       gold_error(_("%s: close: %s"), this->name_, strerror(errno));
4134   this->o_ = -1;
4135 }
4136
4137 // Instantiate the templates we need.  We could use the configure
4138 // script to restrict this to only the ones for implemented targets.
4139
4140 #ifdef HAVE_TARGET_32_LITTLE
4141 template
4142 off_t
4143 Output_section::add_input_section<32, false>(
4144     Sized_relobj<32, false>* object,
4145     unsigned int shndx,
4146     const char* secname,
4147     const elfcpp::Shdr<32, false>& shdr,
4148     unsigned int reloc_shndx,
4149     bool have_sections_script);
4150 #endif
4151
4152 #ifdef HAVE_TARGET_32_BIG
4153 template
4154 off_t
4155 Output_section::add_input_section<32, true>(
4156     Sized_relobj<32, true>* object,
4157     unsigned int shndx,
4158     const char* secname,
4159     const elfcpp::Shdr<32, true>& shdr,
4160     unsigned int reloc_shndx,
4161     bool have_sections_script);
4162 #endif
4163
4164 #ifdef HAVE_TARGET_64_LITTLE
4165 template
4166 off_t
4167 Output_section::add_input_section<64, false>(
4168     Sized_relobj<64, false>* object,
4169     unsigned int shndx,
4170     const char* secname,
4171     const elfcpp::Shdr<64, false>& shdr,
4172     unsigned int reloc_shndx,
4173     bool have_sections_script);
4174 #endif
4175
4176 #ifdef HAVE_TARGET_64_BIG
4177 template
4178 off_t
4179 Output_section::add_input_section<64, true>(
4180     Sized_relobj<64, true>* object,
4181     unsigned int shndx,
4182     const char* secname,
4183     const elfcpp::Shdr<64, true>& shdr,
4184     unsigned int reloc_shndx,
4185     bool have_sections_script);
4186 #endif
4187
4188 #ifdef HAVE_TARGET_32_LITTLE
4189 template
4190 class Output_reloc<elfcpp::SHT_REL, false, 32, false>;
4191 #endif
4192
4193 #ifdef HAVE_TARGET_32_BIG
4194 template
4195 class Output_reloc<elfcpp::SHT_REL, false, 32, true>;
4196 #endif
4197
4198 #ifdef HAVE_TARGET_64_LITTLE
4199 template
4200 class Output_reloc<elfcpp::SHT_REL, false, 64, false>;
4201 #endif
4202
4203 #ifdef HAVE_TARGET_64_BIG
4204 template
4205 class Output_reloc<elfcpp::SHT_REL, false, 64, true>;
4206 #endif
4207
4208 #ifdef HAVE_TARGET_32_LITTLE
4209 template
4210 class Output_reloc<elfcpp::SHT_REL, true, 32, false>;
4211 #endif
4212
4213 #ifdef HAVE_TARGET_32_BIG
4214 template
4215 class Output_reloc<elfcpp::SHT_REL, true, 32, true>;
4216 #endif
4217
4218 #ifdef HAVE_TARGET_64_LITTLE
4219 template
4220 class Output_reloc<elfcpp::SHT_REL, true, 64, false>;
4221 #endif
4222
4223 #ifdef HAVE_TARGET_64_BIG
4224 template
4225 class Output_reloc<elfcpp::SHT_REL, true, 64, true>;
4226 #endif
4227
4228 #ifdef HAVE_TARGET_32_LITTLE
4229 template
4230 class Output_reloc<elfcpp::SHT_RELA, false, 32, false>;
4231 #endif
4232
4233 #ifdef HAVE_TARGET_32_BIG
4234 template
4235 class Output_reloc<elfcpp::SHT_RELA, false, 32, true>;
4236 #endif
4237
4238 #ifdef HAVE_TARGET_64_LITTLE
4239 template
4240 class Output_reloc<elfcpp::SHT_RELA, false, 64, false>;
4241 #endif
4242
4243 #ifdef HAVE_TARGET_64_BIG
4244 template
4245 class Output_reloc<elfcpp::SHT_RELA, false, 64, true>;
4246 #endif
4247
4248 #ifdef HAVE_TARGET_32_LITTLE
4249 template
4250 class Output_reloc<elfcpp::SHT_RELA, true, 32, false>;
4251 #endif
4252
4253 #ifdef HAVE_TARGET_32_BIG
4254 template
4255 class Output_reloc<elfcpp::SHT_RELA, true, 32, true>;
4256 #endif
4257
4258 #ifdef HAVE_TARGET_64_LITTLE
4259 template
4260 class Output_reloc<elfcpp::SHT_RELA, true, 64, false>;
4261 #endif
4262
4263 #ifdef HAVE_TARGET_64_BIG
4264 template
4265 class Output_reloc<elfcpp::SHT_RELA, true, 64, true>;
4266 #endif
4267
4268 #ifdef HAVE_TARGET_32_LITTLE
4269 template
4270 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
4271 #endif
4272
4273 #ifdef HAVE_TARGET_32_BIG
4274 template
4275 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
4276 #endif
4277
4278 #ifdef HAVE_TARGET_64_LITTLE
4279 template
4280 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
4281 #endif
4282
4283 #ifdef HAVE_TARGET_64_BIG
4284 template
4285 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
4286 #endif
4287
4288 #ifdef HAVE_TARGET_32_LITTLE
4289 template
4290 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
4291 #endif
4292
4293 #ifdef HAVE_TARGET_32_BIG
4294 template
4295 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
4296 #endif
4297
4298 #ifdef HAVE_TARGET_64_LITTLE
4299 template
4300 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
4301 #endif
4302
4303 #ifdef HAVE_TARGET_64_BIG
4304 template
4305 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
4306 #endif
4307
4308 #ifdef HAVE_TARGET_32_LITTLE
4309 template
4310 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
4311 #endif
4312
4313 #ifdef HAVE_TARGET_32_BIG
4314 template
4315 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
4316 #endif
4317
4318 #ifdef HAVE_TARGET_64_LITTLE
4319 template
4320 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
4321 #endif
4322
4323 #ifdef HAVE_TARGET_64_BIG
4324 template
4325 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
4326 #endif
4327
4328 #ifdef HAVE_TARGET_32_LITTLE
4329 template
4330 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
4331 #endif
4332
4333 #ifdef HAVE_TARGET_32_BIG
4334 template
4335 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
4336 #endif
4337
4338 #ifdef HAVE_TARGET_64_LITTLE
4339 template
4340 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
4341 #endif
4342
4343 #ifdef HAVE_TARGET_64_BIG
4344 template
4345 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
4346 #endif
4347
4348 #ifdef HAVE_TARGET_32_LITTLE
4349 template
4350 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, false>;
4351 #endif
4352
4353 #ifdef HAVE_TARGET_32_BIG
4354 template
4355 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, true>;
4356 #endif
4357
4358 #ifdef HAVE_TARGET_64_LITTLE
4359 template
4360 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, false>;
4361 #endif
4362
4363 #ifdef HAVE_TARGET_64_BIG
4364 template
4365 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, true>;
4366 #endif
4367
4368 #ifdef HAVE_TARGET_32_LITTLE
4369 template
4370 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, false>;
4371 #endif
4372
4373 #ifdef HAVE_TARGET_32_BIG
4374 template
4375 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, true>;
4376 #endif
4377
4378 #ifdef HAVE_TARGET_64_LITTLE
4379 template
4380 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, false>;
4381 #endif
4382
4383 #ifdef HAVE_TARGET_64_BIG
4384 template
4385 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, true>;
4386 #endif
4387
4388 #ifdef HAVE_TARGET_32_LITTLE
4389 template
4390 class Output_data_group<32, false>;
4391 #endif
4392
4393 #ifdef HAVE_TARGET_32_BIG
4394 template
4395 class Output_data_group<32, true>;
4396 #endif
4397
4398 #ifdef HAVE_TARGET_64_LITTLE
4399 template
4400 class Output_data_group<64, false>;
4401 #endif
4402
4403 #ifdef HAVE_TARGET_64_BIG
4404 template
4405 class Output_data_group<64, true>;
4406 #endif
4407
4408 #ifdef HAVE_TARGET_32_LITTLE
4409 template
4410 class Output_data_got<32, false>;
4411 #endif
4412
4413 #ifdef HAVE_TARGET_32_BIG
4414 template
4415 class Output_data_got<32, true>;
4416 #endif
4417
4418 #ifdef HAVE_TARGET_64_LITTLE
4419 template
4420 class Output_data_got<64, false>;
4421 #endif
4422
4423 #ifdef HAVE_TARGET_64_BIG
4424 template
4425 class Output_data_got<64, true>;
4426 #endif
4427
4428 } // End namespace gold.