gold/output.cc

   1 // output.cc -- manage the output file for gold
   2
   3 // Copyright (C) 2006-2014 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/stat.h>
  31 #include <algorithm>
  32
  33 #ifdef HAVE_SYS_MMAN_H
  34 #include <sys/mman.h>
  35 #endif
  36
  37 #include "libiberty.h"
  38
  39 #include "dwarf.h"
  40 #include "parameters.h"
  41 #include "object.h"
  42 #include "symtab.h"
  43 #include "reloc.h"
  44 #include "merge.h"
  45 #include "descriptors.h"
  46 #include "layout.h"
  47 #include "output.h"
  48
  49 // For systems without mmap support.
  50 #ifndef HAVE_MMAP
  51 # define mmap gold_mmap
  52 # define munmap gold_munmap
  53 # define mremap gold_mremap
  54 # ifndef MAP_FAILED
  55 #  define MAP_FAILED (reinterpret_cast<void*>(-1))
  56 # endif
  57 # ifndef PROT_READ
  58 #  define PROT_READ 0
  59 # endif
  60 # ifndef PROT_WRITE
  61 #  define PROT_WRITE 0
  62 # endif
  63 # ifndef MAP_PRIVATE
  64 #  define MAP_PRIVATE 0
  65 # endif
  66 # ifndef MAP_ANONYMOUS
  67 #  define MAP_ANONYMOUS 0
  68 # endif
  69 # ifndef MAP_SHARED
  70 #  define MAP_SHARED 0
  71 # endif
  72
  73 # ifndef ENOSYS
  74 #  define ENOSYS EINVAL
  75 # endif
  76
  77 static void *
  78 gold_mmap(void *, size_t, int, int, int, off_t)
  79 {
  80   errno = ENOSYS;
  81   return MAP_FAILED;
  82 }
  83
  84 static int
  85 gold_munmap(void *, size_t)
  86 {
  87   errno = ENOSYS;
  88   return -1;
  89 }
  90
  91 static void *
  92 gold_mremap(void *, size_t, size_t, int)
  93 {
  94   errno = ENOSYS;
  95   return MAP_FAILED;
  96 }
  97
  98 #endif
  99
 100 #if defined(HAVE_MMAP) && !defined(HAVE_MREMAP)
 101 # define mremap gold_mremap
 102 extern "C" void *gold_mremap(void *, size_t, size_t, int);
 103 #endif
 104
 105 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
 106 #ifndef MAP_ANONYMOUS
 107 # define MAP_ANONYMOUS  MAP_ANON
 108 #endif
 109
 110 #ifndef MREMAP_MAYMOVE
 111 # define MREMAP_MAYMOVE 1
 112 #endif
 113
 114 // Mingw does not have S_ISLNK.
 115 #ifndef S_ISLNK
 116 # define S_ISLNK(mode) 0
 117 #endif
 118
 119 namespace gold
 120 {
 121
 122 // A wrapper around posix_fallocate.  If we don't have posix_fallocate,
 123 // or the --no-posix-fallocate option is set, we try the fallocate
 124 // system call directly.  If that fails, we use ftruncate to set
 125 // the file size and hope that there is enough disk space.
 126
 127 static int
 128 gold_fallocate(int o, off_t offset, off_t len)
 129 {
 130 #ifdef HAVE_POSIX_FALLOCATE
 131   if (parameters->options().posix_fallocate())
 132     return ::posix_fallocate(o, offset, len);
 133 #endif // defined(HAVE_POSIX_FALLOCATE)
 134 #ifdef HAVE_FALLOCATE
 135   if (::fallocate(o, 0, offset, len) == 0)
 136     return 0;
 137 #endif // defined(HAVE_FALLOCATE)
 138   if (::ftruncate(o, offset + len) < 0)
 139     return errno;
 140   return 0;
 141 }
 142
 143 // Output_data variables.
 144
 145 bool Output_data::allocated_sizes_are_fixed;
 146
 147 // Output_data methods.
 148
 149 Output_data::~Output_data()
 150 {
 151 }
 152
 153 // Return the default alignment for the target size.
 154
 155 uint64_t
 156 Output_data::default_alignment()
 157 {
 158   return Output_data::default_alignment_for_size(
 159       parameters->target().get_size());
 160 }
 161
 162 // Return the default alignment for a size--32 or 64.
 163
 164 uint64_t
 165 Output_data::default_alignment_for_size(int size)
 166 {
 167   if (size == 32)
 168     return 4;
 169   else if (size == 64)
 170     return 8;
 171   else
 172     gold_unreachable();
 173 }
 174
 175 // Output_section_header methods.  This currently assumes that the
 176 // segment and section lists are complete at construction time.
 177
 178 Output_section_headers::Output_section_headers(
 179     const Layout* layout,
 180     const Layout::Segment_list* segment_list,
 181     const Layout::Section_list* section_list,
 182     const Layout::Section_list* unattached_section_list,
 183     const Stringpool* secnamepool,
 184     const Output_section* shstrtab_section)
 185   : layout_(layout),
 186     segment_list_(segment_list),
 187     section_list_(section_list),
 188     unattached_section_list_(unattached_section_list),
 189     secnamepool_(secnamepool),
 190     shstrtab_section_(shstrtab_section)
 191 {
 192 }
 193
 194 // Compute the current data size.
 195
 196 off_t
 197 Output_section_headers::do_size() const
 198 {
 199   // Count all the sections.  Start with 1 for the null section.
 200   off_t count = 1;
 201   if (!parameters->options().relocatable())
 202     {
 203       for (Layout::Segment_list::const_iterator p =
 204              this->segment_list_->begin();
 205            p != this->segment_list_->end();
 206            ++p)
 207         if ((*p)->type() == elfcpp::PT_LOAD)
 208           count += (*p)->output_section_count();
 209     }
 210   else
 211     {
 212       for (Layout::Section_list::const_iterator p =
 213              this->section_list_->begin();
 214            p != this->section_list_->end();
 215            ++p)
 216         if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
 217           ++count;
 218     }
 219   count += this->unattached_section_list_->size();
 220
 221   const int size = parameters->target().get_size();
 222   int shdr_size;
 223   if (size == 32)
 224     shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
 225   else if (size == 64)
 226     shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
 227   else
 228     gold_unreachable();
 229
 230   return count * shdr_size;
 231 }
 232
 233 // Write out the section headers.
 234
 235 void
 236 Output_section_headers::do_write(Output_file* of)
 237 {
 238   switch (parameters->size_and_endianness())
 239     {
 240 #ifdef HAVE_TARGET_32_LITTLE
 241     case Parameters::TARGET_32_LITTLE:
 242       this->do_sized_write<32, false>(of);
 243       break;
 244 #endif
 245 #ifdef HAVE_TARGET_32_BIG
 246     case Parameters::TARGET_32_BIG:
 247       this->do_sized_write<32, true>(of);
 248       break;
 249 #endif
 250 #ifdef HAVE_TARGET_64_LITTLE
 251     case Parameters::TARGET_64_LITTLE:
 252       this->do_sized_write<64, false>(of);
 253       break;
 254 #endif
 255 #ifdef HAVE_TARGET_64_BIG
 256     case Parameters::TARGET_64_BIG:
 257       this->do_sized_write<64, true>(of);
 258       break;
 259 #endif
 260     default:
 261       gold_unreachable();
 262     }
 263 }
 264
 265 template<int size, bool big_endian>
 266 void
 267 Output_section_headers::do_sized_write(Output_file* of)
 268 {
 269   off_t all_shdrs_size = this->data_size();
 270   unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
 271
 272   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 273   unsigned char* v = view;
 274
 275   {
 276     typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
 277     oshdr.put_sh_name(0);
 278     oshdr.put_sh_type(elfcpp::SHT_NULL);
 279     oshdr.put_sh_flags(0);
 280     oshdr.put_sh_addr(0);
 281     oshdr.put_sh_offset(0);
 282
 283     size_t section_count = (this->data_size()
 284                             / elfcpp::Elf_sizes<size>::shdr_size);
 285     if (section_count < elfcpp::SHN_LORESERVE)
 286       oshdr.put_sh_size(0);
 287     else
 288       oshdr.put_sh_size(section_count);
 289
 290     unsigned int shstrndx = this->shstrtab_section_->out_shndx();
 291     if (shstrndx < elfcpp::SHN_LORESERVE)
 292       oshdr.put_sh_link(0);
 293     else
 294       oshdr.put_sh_link(shstrndx);
 295
 296     size_t segment_count = this->segment_list_->size();
 297     oshdr.put_sh_info(segment_count >= elfcpp::PN_XNUM ? segment_count : 0);
 298
 299     oshdr.put_sh_addralign(0);
 300     oshdr.put_sh_entsize(0);
 301   }
 302
 303   v += shdr_size;
 304
 305   unsigned int shndx = 1;
 306   if (!parameters->options().relocatable())
 307     {
 308       for (Layout::Segment_list::const_iterator p =
 309              this->segment_list_->begin();
 310            p != this->segment_list_->end();
 311            ++p)
 312         v = (*p)->write_section_headers<size, big_endian>(this->layout_,
 313                                                           this->secnamepool_,
 314                                                           v,
 315                                                           &shndx);
 316     }
 317   else
 318     {
 319       for (Layout::Section_list::const_iterator p =
 320              this->section_list_->begin();
 321            p != this->section_list_->end();
 322            ++p)
 323         {
 324           // We do unallocated sections below, except that group
 325           // sections have to come first.
 326           if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
 327               && (*p)->type() != elfcpp::SHT_GROUP)
 328             continue;
 329           gold_assert(shndx == (*p)->out_shndx());
 330           elfcpp::Shdr_write<size, big_endian> oshdr(v);
 331           (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
 332           v += shdr_size;
 333           ++shndx;
 334         }
 335     }
 336
 337   for (Layout::Section_list::const_iterator p =
 338          this->unattached_section_list_->begin();
 339        p != this->unattached_section_list_->end();
 340        ++p)
 341     {
 342       // For a relocatable link, we did unallocated group sections
 343       // above, since they have to come first.
 344       if ((*p)->type() == elfcpp::SHT_GROUP
 345           && parameters->options().relocatable())
 346         continue;
 347       gold_assert(shndx == (*p)->out_shndx());
 348       elfcpp::Shdr_write<size, big_endian> oshdr(v);
 349       (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
 350       v += shdr_size;
 351       ++shndx;
 352     }
 353
 354   of->write_output_view(this->offset(), all_shdrs_size, view);
 355 }
 356
 357 // Output_segment_header methods.
 358
 359 Output_segment_headers::Output_segment_headers(
 360     const Layout::Segment_list& segment_list)
 361   : segment_list_(segment_list)
 362 {
 363   this->set_current_data_size_for_child(this->do_size());
 364 }
 365
 366 void
 367 Output_segment_headers::do_write(Output_file* of)
 368 {
 369   switch (parameters->size_and_endianness())
 370     {
 371 #ifdef HAVE_TARGET_32_LITTLE
 372     case Parameters::TARGET_32_LITTLE:
 373       this->do_sized_write<32, false>(of);
 374       break;
 375 #endif
 376 #ifdef HAVE_TARGET_32_BIG
 377     case Parameters::TARGET_32_BIG:
 378       this->do_sized_write<32, true>(of);
 379       break;
 380 #endif
 381 #ifdef HAVE_TARGET_64_LITTLE
 382     case Parameters::TARGET_64_LITTLE:
 383       this->do_sized_write<64, false>(of);
 384       break;
 385 #endif
 386 #ifdef HAVE_TARGET_64_BIG
 387     case Parameters::TARGET_64_BIG:
 388       this->do_sized_write<64, true>(of);
 389       break;
 390 #endif
 391     default:
 392       gold_unreachable();
 393     }
 394 }
 395
 396 template<int size, bool big_endian>
 397 void
 398 Output_segment_headers::do_sized_write(Output_file* of)
 399 {
 400   const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
 401   off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
 402   gold_assert(all_phdrs_size == this->data_size());
 403   unsigned char* view = of->get_output_view(this->offset(),
 404                                             all_phdrs_size);
 405   unsigned char* v = view;
 406   for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
 407        p != this->segment_list_.end();
 408        ++p)
 409     {
 410       elfcpp::Phdr_write<size, big_endian> ophdr(v);
 411       (*p)->write_header(&ophdr);
 412       v += phdr_size;
 413     }
 414
 415   gold_assert(v - view == all_phdrs_size);
 416
 417   of->write_output_view(this->offset(), all_phdrs_size, view);
 418 }
 419
 420 off_t
 421 Output_segment_headers::do_size() const
 422 {
 423   const int size = parameters->target().get_size();
 424   int phdr_size;
 425   if (size == 32)
 426     phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
 427   else if (size == 64)
 428     phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
 429   else
 430     gold_unreachable();
 431
 432   return this->segment_list_.size() * phdr_size;
 433 }
 434
 435 // Output_file_header methods.
 436
 437 Output_file_header::Output_file_header(Target* target,
 438                                        const Symbol_table* symtab,
 439                                        const Output_segment_headers* osh)
 440   : target_(target),
 441     symtab_(symtab),
 442     segment_header_(osh),
 443     section_header_(NULL),
 444     shstrtab_(NULL)
 445 {
 446   this->set_data_size(this->do_size());
 447 }
 448
 449 // Set the section table information for a file header.
 450
 451 void
 452 Output_file_header::set_section_info(const Output_section_headers* shdrs,
 453                                      const Output_section* shstrtab)
 454 {
 455   this->section_header_ = shdrs;
 456   this->shstrtab_ = shstrtab;
 457 }
 458
 459 // Write out the file header.
 460
 461 void
 462 Output_file_header::do_write(Output_file* of)
 463 {
 464   gold_assert(this->offset() == 0);
 465
 466   switch (parameters->size_and_endianness())
 467     {
 468 #ifdef HAVE_TARGET_32_LITTLE
 469     case Parameters::TARGET_32_LITTLE:
 470       this->do_sized_write<32, false>(of);
 471       break;
 472 #endif
 473 #ifdef HAVE_TARGET_32_BIG
 474     case Parameters::TARGET_32_BIG:
 475       this->do_sized_write<32, true>(of);
 476       break;
 477 #endif
 478 #ifdef HAVE_TARGET_64_LITTLE
 479     case Parameters::TARGET_64_LITTLE:
 480       this->do_sized_write<64, false>(of);
 481       break;
 482 #endif
 483 #ifdef HAVE_TARGET_64_BIG
 484     case Parameters::TARGET_64_BIG:
 485       this->do_sized_write<64, true>(of);
 486       break;
 487 #endif
 488     default:
 489       gold_unreachable();
 490     }
 491 }
 492
 493 // Write out the file header with appropriate size and endianness.
 494
 495 template<int size, bool big_endian>
 496 void
 497 Output_file_header::do_sized_write(Output_file* of)
 498 {
 499   gold_assert(this->offset() == 0);
 500
 501   int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
 502   unsigned char* view = of->get_output_view(0, ehdr_size);
 503   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
 504
 505   unsigned char e_ident[elfcpp::EI_NIDENT];
 506   memset(e_ident, 0, elfcpp::EI_NIDENT);
 507   e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
 508   e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
 509   e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
 510   e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
 511   if (size == 32)
 512     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
 513   else if (size == 64)
 514     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
 515   else
 516     gold_unreachable();
 517   e_ident[elfcpp::EI_DATA] = (big_endian
 518                               ? elfcpp::ELFDATA2MSB
 519                               : elfcpp::ELFDATA2LSB);
 520   e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
 521   oehdr.put_e_ident(e_ident);
 522
 523   elfcpp::ET e_type;
 524   if (parameters->options().relocatable())
 525     e_type = elfcpp::ET_REL;
 526   else if (parameters->options().output_is_position_independent())
 527     e_type = elfcpp::ET_DYN;
 528   else
 529     e_type = elfcpp::ET_EXEC;
 530   oehdr.put_e_type(e_type);
 531
 532   oehdr.put_e_machine(this->target_->machine_code());
 533   oehdr.put_e_version(elfcpp::EV_CURRENT);
 534
 535   oehdr.put_e_entry(this->entry<size>());
 536
 537   if (this->segment_header_ == NULL)
 538     oehdr.put_e_phoff(0);
 539   else
 540     oehdr.put_e_phoff(this->segment_header_->offset());
 541
 542   oehdr.put_e_shoff(this->section_header_->offset());
 543   oehdr.put_e_flags(this->target_->processor_specific_flags());
 544   oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
 545
 546   if (this->segment_header_ == NULL)
 547     {
 548       oehdr.put_e_phentsize(0);
 549       oehdr.put_e_phnum(0);
 550     }
 551   else
 552     {
 553       oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
 554       size_t phnum = (this->segment_header_->data_size()
 555                       / elfcpp::Elf_sizes<size>::phdr_size);
 556       if (phnum > elfcpp::PN_XNUM)
 557         phnum = elfcpp::PN_XNUM;
 558       oehdr.put_e_phnum(phnum);
 559     }
 560
 561   oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
 562   size_t section_count = (this->section_header_->data_size()
 563                           / elfcpp::Elf_sizes<size>::shdr_size);
 564
 565   if (section_count < elfcpp::SHN_LORESERVE)
 566     oehdr.put_e_shnum(this->section_header_->data_size()
 567                       / elfcpp::Elf_sizes<size>::shdr_size);
 568   else
 569     oehdr.put_e_shnum(0);
 570
 571   unsigned int shstrndx = this->shstrtab_->out_shndx();
 572   if (shstrndx < elfcpp::SHN_LORESERVE)
 573     oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
 574   else
 575     oehdr.put_e_shstrndx(elfcpp::SHN_XINDEX);
 576
 577   // Let the target adjust the ELF header, e.g., to set EI_OSABI in
 578   // the e_ident field.
 579   this->target_->adjust_elf_header(view, ehdr_size);
 580
 581   of->write_output_view(0, ehdr_size, view);
 582 }
 583
 584 // Return the value to use for the entry address.
 585
 586 template<int size>
 587 typename elfcpp::Elf_types<size>::Elf_Addr
 588 Output_file_header::entry()
 589 {
 590   const bool should_issue_warning = (parameters->options().entry() != NULL
 591                                      && !parameters->options().relocatable()
 592                                      && !parameters->options().shared());
 593   const char* entry = parameters->entry();
 594   Symbol* sym = this->symtab_->lookup(entry);
 595
 596   typename Sized_symbol<size>::Value_type v;
 597   if (sym != NULL)
 598     {
 599       Sized_symbol<size>* ssym;
 600       ssym = this->symtab_->get_sized_symbol<size>(sym);
 601       if (!ssym->is_defined() && should_issue_warning)
 602         gold_warning("entry symbol '%s' exists but is not defined", entry);
 603       v = ssym->value();
 604     }
 605   else
 606     {
 607       // We couldn't find the entry symbol.  See if we can parse it as
 608       // a number.  This supports, e.g., -e 0x1000.
 609       char* endptr;
 610       v = strtoull(entry, &endptr, 0);
 611       if (*endptr != '\0')
 612         {
 613           if (should_issue_warning)
 614             gold_warning("cannot find entry symbol '%s'", entry);
 615           v = 0;
 616         }
 617     }
 618
 619   return v;
 620 }
 621
 622 // Compute the current data size.
 623
 624 off_t
 625 Output_file_header::do_size() const
 626 {
 627   const int size = parameters->target().get_size();
 628   if (size == 32)
 629     return elfcpp::Elf_sizes<32>::ehdr_size;
 630   else if (size == 64)
 631     return elfcpp::Elf_sizes<64>::ehdr_size;
 632   else
 633     gold_unreachable();
 634 }
 635
 636 // Output_data_const methods.
 637
 638 void
 639 Output_data_const::do_write(Output_file* of)
 640 {
 641   of->write(this->offset(), this->data_.data(), this->data_.size());
 642 }
 643
 644 // Output_data_const_buffer methods.
 645
 646 void
 647 Output_data_const_buffer::do_write(Output_file* of)
 648 {
 649   of->write(this->offset(), this->p_, this->data_size());
 650 }
 651
 652 // Output_section_data methods.
 653
 654 // Record the output section, and set the entry size and such.
 655
 656 void
 657 Output_section_data::set_output_section(Output_section* os)
 658 {
 659   gold_assert(this->output_section_ == NULL);
 660   this->output_section_ = os;
 661   this->do_adjust_output_section(os);
 662 }
 663
 664 // Return the section index of the output section.
 665
 666 unsigned int
 667 Output_section_data::do_out_shndx() const
 668 {
 669   gold_assert(this->output_section_ != NULL);
 670   return this->output_section_->out_shndx();
 671 }
 672
 673 // Set the alignment, which means we may need to update the alignment
 674 // of the output section.
 675
 676 void
 677 Output_section_data::set_addralign(uint64_t addralign)
 678 {
 679   this->addralign_ = addralign;
 680   if (this->output_section_ != NULL
 681       && this->output_section_->addralign() < addralign)
 682     this->output_section_->set_addralign(addralign);
 683 }
 684
 685 // Output_data_strtab methods.
 686
 687 // Set the final data size.
 688
 689 void
 690 Output_data_strtab::set_final_data_size()
 691 {
 692   this->strtab_->set_string_offsets();
 693   this->set_data_size(this->strtab_->get_strtab_size());
 694 }
 695
 696 // Write out a string table.
 697
 698 void
 699 Output_data_strtab::do_write(Output_file* of)
 700 {
 701   this->strtab_->write(of, this->offset());
 702 }
 703
 704 // Output_reloc methods.
 705
 706 // A reloc against a global symbol.
 707
 708 template<bool dynamic, int size, bool big_endian>
 709 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 710     Symbol* gsym,
 711     unsigned int type,
 712     Output_data* od,
 713     Address address,
 714     bool is_relative,
 715     bool is_symbolless,
 716     bool use_plt_offset)
 717   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
 718     is_relative_(is_relative), is_symbolless_(is_symbolless),
 719     is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(INVALID_CODE)
 720 {
 721   // this->type_ is a bitfield; make sure TYPE fits.
 722   gold_assert(this->type_ == type);
 723   this->u1_.gsym = gsym;
 724   this->u2_.od = od;
 725   if (dynamic)
 726     this->set_needs_dynsym_index();
 727 }
 728
 729 template<bool dynamic, int size, bool big_endian>
 730 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 731     Symbol* gsym,
 732     unsigned int type,
 733     Sized_relobj<size, big_endian>* relobj,
 734     unsigned int shndx,
 735     Address address,
 736     bool is_relative,
 737     bool is_symbolless,
 738     bool use_plt_offset)
 739   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
 740     is_relative_(is_relative), is_symbolless_(is_symbolless),
 741     is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(shndx)
 742 {
 743   gold_assert(shndx != INVALID_CODE);
 744   // this->type_ is a bitfield; make sure TYPE fits.
 745   gold_assert(this->type_ == type);
 746   this->u1_.gsym = gsym;
 747   this->u2_.relobj = relobj;
 748   if (dynamic)
 749     this->set_needs_dynsym_index();
 750 }
 751
 752 // A reloc against a local symbol.
 753
 754 template<bool dynamic, int size, bool big_endian>
 755 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 756     Sized_relobj<size, big_endian>* relobj,
 757     unsigned int local_sym_index,
 758     unsigned int type,
 759     Output_data* od,
 760     Address address,
 761     bool is_relative,
 762     bool is_symbolless,
 763     bool is_section_symbol,
 764     bool use_plt_offset)
 765   : address_(address), local_sym_index_(local_sym_index), type_(type),
 766     is_relative_(is_relative), is_symbolless_(is_symbolless),
 767     is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset),
 768     shndx_(INVALID_CODE)
 769 {
 770   gold_assert(local_sym_index != GSYM_CODE
 771               && local_sym_index != INVALID_CODE);
 772   // this->type_ is a bitfield; make sure TYPE fits.
 773   gold_assert(this->type_ == type);
 774   this->u1_.relobj = relobj;
 775   this->u2_.od = od;
 776   if (dynamic)
 777     this->set_needs_dynsym_index();
 778 }
 779
 780 template<bool dynamic, int size, bool big_endian>
 781 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 782     Sized_relobj<size, big_endian>* relobj,
 783     unsigned int local_sym_index,
 784     unsigned int type,
 785     unsigned int shndx,
 786     Address address,
 787     bool is_relative,
 788     bool is_symbolless,
 789     bool is_section_symbol,
 790     bool use_plt_offset)
 791   : address_(address), local_sym_index_(local_sym_index), type_(type),
 792     is_relative_(is_relative), is_symbolless_(is_symbolless),
 793     is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset),
 794     shndx_(shndx)
 795 {
 796   gold_assert(local_sym_index != GSYM_CODE
 797               && local_sym_index != INVALID_CODE);
 798   gold_assert(shndx != INVALID_CODE);
 799   // this->type_ is a bitfield; make sure TYPE fits.
 800   gold_assert(this->type_ == type);
 801   this->u1_.relobj = relobj;
 802   this->u2_.relobj = relobj;
 803   if (dynamic)
 804     this->set_needs_dynsym_index();
 805 }
 806
 807 // A reloc against the STT_SECTION symbol of an output section.
 808
 809 template<bool dynamic, int size, bool big_endian>
 810 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 811     Output_section* os,
 812     unsigned int type,
 813     Output_data* od,
 814     Address address,
 815     bool is_relative)
 816   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
 817     is_relative_(is_relative), is_symbolless_(is_relative),
 818     is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE)
 819 {
 820   // this->type_ is a bitfield; make sure TYPE fits.
 821   gold_assert(this->type_ == type);
 822   this->u1_.os = os;
 823   this->u2_.od = od;
 824   if (dynamic)
 825     this->set_needs_dynsym_index();
 826   else
 827     os->set_needs_symtab_index();
 828 }
 829
 830 template<bool dynamic, int size, bool big_endian>
 831 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 832     Output_section* os,
 833     unsigned int type,
 834     Sized_relobj<size, big_endian>* relobj,
 835     unsigned int shndx,
 836     Address address,
 837     bool is_relative)
 838   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
 839     is_relative_(is_relative), is_symbolless_(is_relative),
 840     is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx)
 841 {
 842   gold_assert(shndx != INVALID_CODE);
 843   // this->type_ is a bitfield; make sure TYPE fits.
 844   gold_assert(this->type_ == type);
 845   this->u1_.os = os;
 846   this->u2_.relobj = relobj;
 847   if (dynamic)
 848     this->set_needs_dynsym_index();
 849   else
 850     os->set_needs_symtab_index();
 851 }
 852
 853 // An absolute or relative relocation.
 854
 855 template<bool dynamic, int size, bool big_endian>
 856 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 857     unsigned int type,
 858     Output_data* od,
 859     Address address,
 860     bool is_relative)
 861   : address_(address), local_sym_index_(0), type_(type),
 862     is_relative_(is_relative), is_symbolless_(false),
 863     is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
 864 {
 865   // this->type_ is a bitfield; make sure TYPE fits.
 866   gold_assert(this->type_ == type);
 867   this->u1_.relobj = NULL;
 868   this->u2_.od = od;
 869 }
 870
 871 template<bool dynamic, int size, bool big_endian>
 872 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 873     unsigned int type,
 874     Sized_relobj<size, big_endian>* relobj,
 875     unsigned int shndx,
 876     Address address,
 877     bool is_relative)
 878   : address_(address), local_sym_index_(0), type_(type),
 879     is_relative_(is_relative), is_symbolless_(false),
 880     is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
 881 {
 882   gold_assert(shndx != INVALID_CODE);
 883   // this->type_ is a bitfield; make sure TYPE fits.
 884   gold_assert(this->type_ == type);
 885   this->u1_.relobj = NULL;
 886   this->u2_.relobj = relobj;
 887 }
 888
 889 // A target specific relocation.
 890
 891 template<bool dynamic, int size, bool big_endian>
 892 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 893     unsigned int type,
 894     void* arg,
 895     Output_data* od,
 896     Address address)
 897   : address_(address), local_sym_index_(TARGET_CODE), type_(type),
 898     is_relative_(false), is_symbolless_(false),
 899     is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
 900 {
 901   // this->type_ is a bitfield; make sure TYPE fits.
 902   gold_assert(this->type_ == type);
 903   this->u1_.arg = arg;
 904   this->u2_.od = od;
 905 }
 906
 907 template<bool dynamic, int size, bool big_endian>
 908 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 909     unsigned int type,
 910     void* arg,
 911     Sized_relobj<size, big_endian>* relobj,
 912     unsigned int shndx,
 913     Address address)
 914   : address_(address), local_sym_index_(TARGET_CODE), type_(type),
 915     is_relative_(false), is_symbolless_(false),
 916     is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
 917 {
 918   gold_assert(shndx != INVALID_CODE);
 919   // this->type_ is a bitfield; make sure TYPE fits.
 920   gold_assert(this->type_ == type);
 921   this->u1_.arg = arg;
 922   this->u2_.relobj = relobj;
 923 }
 924
 925 // Record that we need a dynamic symbol index for this relocation.
 926
 927 template<bool dynamic, int size, bool big_endian>
 928 void
 929 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
 930 set_needs_dynsym_index()
 931 {
 932   if (this->is_symbolless_)
 933     return;
 934   switch (this->local_sym_index_)
 935     {
 936     case INVALID_CODE:
 937       gold_unreachable();
 938
 939     case GSYM_CODE:
 940       this->u1_.gsym->set_needs_dynsym_entry();
 941       break;
 942
 943     case SECTION_CODE:
 944       this->u1_.os->set_needs_dynsym_index();
 945       break;
 946
 947     case TARGET_CODE:
 948       // The target must take care of this if necessary.
 949       break;
 950
 951     case 0:
 952       break;
 953
 954     default:
 955       {
 956         const unsigned int lsi = this->local_sym_index_;
 957         Sized_relobj_file<size, big_endian>* relobj =
 958             this->u1_.relobj->sized_relobj();
 959         gold_assert(relobj != NULL);
 960         if (!this->is_section_symbol_)
 961           relobj->set_needs_output_dynsym_entry(lsi);
 962         else
 963           relobj->output_section(lsi)->set_needs_dynsym_index();
 964       }
 965       break;
 966     }
 967 }
 968
 969 // Get the symbol index of a relocation.
 970
 971 template<bool dynamic, int size, bool big_endian>
 972 unsigned int
 973 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 974   const
 975 {
 976   unsigned int index;
 977   if (this->is_symbolless_)
 978     return 0;
 979   switch (this->local_sym_index_)
 980     {
 981     case INVALID_CODE:
 982       gold_unreachable();
 983
 984     case GSYM_CODE:
 985       if (this->u1_.gsym == NULL)
 986         index = 0;
 987       else if (dynamic)
 988         index = this->u1_.gsym->dynsym_index();
 989       else
 990         index = this->u1_.gsym->symtab_index();
 991       break;
 992
 993     case SECTION_CODE:
 994       if (dynamic)
 995         index = this->u1_.os->dynsym_index();
 996       else
 997         index = this->u1_.os->symtab_index();
 998       break;
 999
1000     case TARGET_CODE:
1001       index = parameters->target().reloc_symbol_index(this->u1_.arg,
1002                                                       this->type_);
1003       break;
1004
1005     case 0:
1006       // Relocations without symbols use a symbol index of 0.
1007       index = 0;
1008       break;
1009
1010     default:
1011       {
1012         const unsigned int lsi = this->local_sym_index_;
1013         Sized_relobj_file<size, big_endian>* relobj =
1014             this->u1_.relobj->sized_relobj();
1015         gold_assert(relobj != NULL);
1016         if (!this->is_section_symbol_)
1017           {
1018             if (dynamic)
1019               index = relobj->dynsym_index(lsi);
1020             else
1021               index = relobj->symtab_index(lsi);
1022           }
1023         else
1024           {
1025             Output_section* os = relobj->output_section(lsi);
1026             gold_assert(os != NULL);
1027             if (dynamic)
1028               index = os->dynsym_index();
1029             else
1030               index = os->symtab_index();
1031           }
1032       }
1033       break;
1034     }
1035   gold_assert(index != -1U);
1036   return index;
1037 }
1038
1039 // For a local section symbol, get the address of the offset ADDEND
1040 // within the input section.
1041
1042 template<bool dynamic, int size, bool big_endian>
1043 typename elfcpp::Elf_types<size>::Elf_Addr
1044 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1045   local_section_offset(Addend addend) const
1046 {
1047   gold_assert(this->local_sym_index_ != GSYM_CODE
1048               && this->local_sym_index_ != SECTION_CODE
1049               && this->local_sym_index_ != TARGET_CODE
1050               && this->local_sym_index_ != INVALID_CODE
1051               && this->local_sym_index_ != 0
1052               && this->is_section_symbol_);
1053   const unsigned int lsi = this->local_sym_index_;
1054   Output_section* os = this->u1_.relobj->output_section(lsi);
1055   gold_assert(os != NULL);
1056   Address offset = this->u1_.relobj->get_output_section_offset(lsi);
1057   if (offset != invalid_address)
1058     return offset + addend;
1059   // This is a merge section.
1060   Sized_relobj_file<size, big_endian>* relobj =
1061       this->u1_.relobj->sized_relobj();
1062   gold_assert(relobj != NULL);
1063   offset = os->output_address(relobj, lsi, addend);
1064   gold_assert(offset != invalid_address);
1065   return offset;
1066 }
1067
1068 // Get the output address of a relocation.
1069
1070 template<bool dynamic, int size, bool big_endian>
1071 typename elfcpp::Elf_types<size>::Elf_Addr
1072 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const
1073 {
1074   Address address = this->address_;
1075   if (this->shndx_ != INVALID_CODE)
1076     {
1077       Output_section* os = this->u2_.relobj->output_section(this->shndx_);
1078       gold_assert(os != NULL);
1079       Address off = this->u2_.relobj->get_output_section_offset(this->shndx_);
1080       if (off != invalid_address)
1081         address += os->address() + off;
1082       else
1083         {
1084           Sized_relobj_file<size, big_endian>* relobj =
1085               this->u2_.relobj->sized_relobj();
1086           gold_assert(relobj != NULL);
1087           address = os->output_address(relobj, this->shndx_, address);
1088           gold_assert(address != invalid_address);
1089         }
1090     }
1091   else if (this->u2_.od != NULL)
1092     address += this->u2_.od->address();
1093   return address;
1094 }
1095
1096 // Write out the offset and info fields of a Rel or Rela relocation
1097 // entry.
1098
1099 template<bool dynamic, int size, bool big_endian>
1100 template<typename Write_rel>
1101 void
1102 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
1103     Write_rel* wr) const
1104 {
1105   wr->put_r_offset(this->get_address());
1106   unsigned int sym_index = this->get_symbol_index();
1107   wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
1108 }
1109
1110 // Write out a Rel relocation.
1111
1112 template<bool dynamic, int size, bool big_endian>
1113 void
1114 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
1115     unsigned char* pov) const
1116 {
1117   elfcpp::Rel_write<size, big_endian> orel(pov);
1118   this->write_rel(&orel);
1119 }
1120
1121 // Get the value of the symbol referred to by a Rel relocation.
1122
1123 template<bool dynamic, int size, bool big_endian>
1124 typename elfcpp::Elf_types<size>::Elf_Addr
1125 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
1126     Addend addend) const
1127 {
1128   if (this->local_sym_index_ == GSYM_CODE)
1129     {
1130       const Sized_symbol<size>* sym;
1131       sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
1132       if (this->use_plt_offset_ && sym->has_plt_offset())
1133         return parameters->target().plt_address_for_global(sym);
1134       else
1135         return sym->value() + addend;
1136     }
1137   if (this->local_sym_index_ == SECTION_CODE)
1138     {
1139       gold_assert(!this->use_plt_offset_);
1140       return this->u1_.os->address() + addend;
1141     }
1142   gold_assert(this->local_sym_index_ != TARGET_CODE
1143               && this->local_sym_index_ != INVALID_CODE
1144               && this->local_sym_index_ != 0
1145               && !this->is_section_symbol_);
1146   const unsigned int lsi = this->local_sym_index_;
1147   Sized_relobj_file<size, big_endian>* relobj =
1148       this->u1_.relobj->sized_relobj();
1149   gold_assert(relobj != NULL);
1150   if (this->use_plt_offset_)
1151     return parameters->target().plt_address_for_local(relobj, lsi);
1152   const Symbol_value<size>* symval = relobj->local_symbol(lsi);
1153   return symval->value(relobj, addend);
1154 }
1155
1156 // Reloc comparison.  This function sorts the dynamic relocs for the
1157 // benefit of the dynamic linker.  First we sort all relative relocs
1158 // to the front.  Among relative relocs, we sort by output address.
1159 // Among non-relative relocs, we sort by symbol index, then by output
1160 // address.
1161
1162 template<bool dynamic, int size, bool big_endian>
1163 int
1164 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
1165   compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
1166     const
1167 {
1168   if (this->is_relative_)
1169     {
1170       if (!r2.is_relative_)
1171         return -1;
1172       // Otherwise sort by reloc address below.
1173     }
1174   else if (r2.is_relative_)
1175     return 1;
1176   else
1177     {
1178       unsigned int sym1 = this->get_symbol_index();
1179       unsigned int sym2 = r2.get_symbol_index();
1180       if (sym1 < sym2)
1181         return -1;
1182       else if (sym1 > sym2)
1183         return 1;
1184       // Otherwise sort by reloc address.
1185     }
1186
1187   section_offset_type addr1 = this->get_address();
1188   section_offset_type addr2 = r2.get_address();
1189   if (addr1 < addr2)
1190     return -1;
1191   else if (addr1 > addr2)
1192     return 1;
1193
1194   // Final tie breaker, in order to generate the same output on any
1195   // host: reloc type.
1196   unsigned int type1 = this->type_;
1197   unsigned int type2 = r2.type_;
1198   if (type1 < type2)
1199     return -1;
1200   else if (type1 > type2)
1201     return 1;
1202
1203   // These relocs appear to be exactly the same.
1204   return 0;
1205 }
1206
1207 // Write out a Rela relocation.
1208
1209 template<bool dynamic, int size, bool big_endian>
1210 void
1211 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
1212     unsigned char* pov) const
1213 {
1214   elfcpp::Rela_write<size, big_endian> orel(pov);
1215   this->rel_.write_rel(&orel);
1216   Addend addend = this->addend_;
1217   if (this->rel_.is_target_specific())
1218     addend = parameters->target().reloc_addend(this->rel_.target_arg(),
1219                                                this->rel_.type(), addend);
1220   else if (this->rel_.is_symbolless())
1221     addend = this->rel_.symbol_value(addend);
1222   else if (this->rel_.is_local_section_symbol())
1223     addend = this->rel_.local_section_offset(addend);
1224   orel.put_r_addend(addend);
1225 }
1226
1227 // Output_data_reloc_base methods.
1228
1229 // Adjust the output section.
1230
1231 template<int sh_type, bool dynamic, int size, bool big_endian>
1232 void
1233 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
1234     ::do_adjust_output_section(Output_section* os)
1235 {
1236   if (sh_type == elfcpp::SHT_REL)
1237     os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1238   else if (sh_type == elfcpp::SHT_RELA)
1239     os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1240   else
1241     gold_unreachable();
1242
1243   // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1244   // static link.  The backends will generate a dynamic reloc section
1245   // to hold this.  In that case we don't want to link to the dynsym
1246   // section, because there isn't one.
1247   if (!dynamic)
1248     os->set_should_link_to_symtab();
1249   else if (parameters->doing_static_link())
1250     ;
1251   else
1252     os->set_should_link_to_dynsym();
1253 }
1254
1255 // Write out relocation data.
1256
1257 template<int sh_type, bool dynamic, int size, bool big_endian>
1258 void
1259 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
1260     Output_file* of)
1261 {
1262   const off_t off = this->offset();
1263   const off_t oview_size = this->data_size();
1264   unsigned char* const oview = of->get_output_view(off, oview_size);
1265
1266   if (this->sort_relocs())
1267     {
1268       gold_assert(dynamic);
1269       std::sort(this->relocs_.begin(), this->relocs_.end(),
1270                 Sort_relocs_comparison());
1271     }
1272
1273   unsigned char* pov = oview;
1274   for (typename Relocs::const_iterator p = this->relocs_.begin();
1275        p != this->relocs_.end();
1276        ++p)
1277     {
1278       p->write(pov);
1279       pov += reloc_size;
1280     }
1281
1282   gold_assert(pov - oview == oview_size);
1283
1284   of->write_output_view(off, oview_size, oview);
1285
1286   // We no longer need the relocation entries.
1287   this->relocs_.clear();
1288 }
1289
1290 // Class Output_relocatable_relocs.
1291
1292 template<int sh_type, int size, bool big_endian>
1293 void
1294 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size()
1295 {
1296   this->set_data_size(this->rr_->output_reloc_count()
1297                       * Reloc_types<sh_type, size, big_endian>::reloc_size);
1298 }
1299
1300 // class Output_data_group.
1301
1302 template<int size, bool big_endian>
1303 Output_data_group<size, big_endian>::Output_data_group(
1304     Sized_relobj_file<size, big_endian>* relobj,
1305     section_size_type entry_count,
1306     elfcpp::Elf_Word flags,
1307     std::vector<unsigned int>* input_shndxes)
1308   : Output_section_data(entry_count * 4, 4, false),
1309     relobj_(relobj),
1310     flags_(flags)
1311 {
1312   this->input_shndxes_.swap(*input_shndxes);
1313 }
1314
1315 // Write out the section group, which means translating the section
1316 // indexes to apply to the output file.
1317
1318 template<int size, bool big_endian>
1319 void
1320 Output_data_group<size, big_endian>::do_write(Output_file* of)
1321 {
1322   const off_t off = this->offset();
1323   const section_size_type oview_size =
1324     convert_to_section_size_type(this->data_size());
1325   unsigned char* const oview = of->get_output_view(off, oview_size);
1326
1327   elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview);
1328   elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_);
1329   ++contents;
1330
1331   for (std::vector<unsigned int>::const_iterator p =
1332          this->input_shndxes_.begin();
1333        p != this->input_shndxes_.end();
1334        ++p, ++contents)
1335     {
1336       Output_section* os = this->relobj_->output_section(*p);
1337
1338       unsigned int output_shndx;
1339       if (os != NULL)
1340         output_shndx = os->out_shndx();
1341       else
1342         {
1343           this->relobj_->error(_("section group retained but "
1344                                  "group element discarded"));
1345           output_shndx = 0;
1346         }
1347
1348       elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx);
1349     }
1350
1351   size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview;
1352   gold_assert(wrote == oview_size);
1353
1354   of->write_output_view(off, oview_size, oview);
1355
1356   // We no longer need this information.
1357   this->input_shndxes_.clear();
1358 }
1359
1360 // Output_data_got::Got_entry methods.
1361
1362 // Write out the entry.
1363
1364 template<int got_size, bool big_endian>
1365 void
1366 Output_data_got<got_size, big_endian>::Got_entry::write(
1367     unsigned int got_indx,
1368     unsigned char* pov) const
1369 {
1370   Valtype val = 0;
1371
1372   switch (this->local_sym_index_)
1373     {
1374     case GSYM_CODE:
1375       {
1376         // If the symbol is resolved locally, we need to write out the
1377         // link-time value, which will be relocated dynamically by a
1378         // RELATIVE relocation.
1379         Symbol* gsym = this->u_.gsym;
1380         if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset())
1381           val = parameters->target().plt_address_for_global(gsym);
1382         else
1383           {
1384             switch (parameters->size_and_endianness())
1385               {
1386 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1387               case Parameters::TARGET_32_LITTLE:
1388               case Parameters::TARGET_32_BIG:
1389                 {
1390                   // This cast is ugly.  We don't want to put a
1391                   // virtual method in Symbol, because we want Symbol
1392                   // to be as small as possible.
1393                   Sized_symbol<32>::Value_type v;
1394                   v = static_cast<Sized_symbol<32>*>(gsym)->value();
1395                   val = convert_types<Valtype, Sized_symbol<32>::Value_type>(v);
1396                 }
1397                 break;
1398 #endif
1399 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1400               case Parameters::TARGET_64_LITTLE:
1401               case Parameters::TARGET_64_BIG:
1402                 {
1403                   Sized_symbol<64>::Value_type v;
1404                   v = static_cast<Sized_symbol<64>*>(gsym)->value();
1405                   val = convert_types<Valtype, Sized_symbol<64>::Value_type>(v);
1406                 }
1407                 break;
1408 #endif
1409               default:
1410                 gold_unreachable();
1411               }
1412             if (this->use_plt_or_tls_offset_
1413                 && gsym->type() == elfcpp::STT_TLS)
1414               val += parameters->target().tls_offset_for_global(gsym,
1415                                                                 got_indx);
1416           }
1417       }
1418       break;
1419
1420     case CONSTANT_CODE:
1421       val = this->u_.constant;
1422       break;
1423
1424     case RESERVED_CODE:
1425       // If we're doing an incremental update, don't touch this GOT entry.
1426       if (parameters->incremental_update())
1427         return;
1428       val = this->u_.constant;
1429       break;
1430
1431     default:
1432       {
1433         const Relobj* object = this->u_.object;
1434         const unsigned int lsi = this->local_sym_index_;
1435         bool is_tls = object->local_is_tls(lsi);
1436         if (this->use_plt_or_tls_offset_ && !is_tls)
1437           val = parameters->target().plt_address_for_local(object, lsi);
1438         else
1439           {
1440             uint64_t lval = object->local_symbol_value(lsi, 0);
1441             val = convert_types<Valtype, uint64_t>(lval);
1442             if (this->use_plt_or_tls_offset_ && is_tls)
1443               val += parameters->target().tls_offset_for_local(object, lsi,
1444                                                                got_indx);
1445           }
1446       }
1447       break;
1448     }
1449
1450   elfcpp::Swap<got_size, big_endian>::writeval(pov, val);
1451 }
1452
1453 // Output_data_got methods.
1454
1455 // Add an entry for a global symbol to the GOT.  This returns true if
1456 // this is a new GOT entry, false if the symbol already had a GOT
1457 // entry.
1458
1459 template<int got_size, bool big_endian>
1460 bool
1461 Output_data_got<got_size, big_endian>::add_global(
1462     Symbol* gsym,
1463     unsigned int got_type)
1464 {
1465   if (gsym->has_got_offset(got_type))
1466     return false;
1467
1468   unsigned int got_offset = this->add_got_entry(Got_entry(gsym, false));
1469   gsym->set_got_offset(got_type, got_offset);
1470   return true;
1471 }
1472
1473 // Like add_global, but use the PLT offset.
1474
1475 template<int got_size, bool big_endian>
1476 bool
1477 Output_data_got<got_size, big_endian>::add_global_plt(Symbol* gsym,
1478                                                       unsigned int got_type)
1479 {
1480   if (gsym->has_got_offset(got_type))
1481     return false;
1482
1483   unsigned int got_offset = this->add_got_entry(Got_entry(gsym, true));
1484   gsym->set_got_offset(got_type, got_offset);
1485   return true;
1486 }
1487
1488 // Add an entry for a global symbol to the GOT, and add a dynamic
1489 // relocation of type R_TYPE for the GOT entry.
1490
1491 template<int got_size, bool big_endian>
1492 void
1493 Output_data_got<got_size, big_endian>::add_global_with_rel(
1494     Symbol* gsym,
1495     unsigned int got_type,
1496     Output_data_reloc_generic* rel_dyn,
1497     unsigned int r_type)
1498 {
1499   if (gsym->has_got_offset(got_type))
1500     return;
1501
1502   unsigned int got_offset = this->add_got_entry(Got_entry());
1503   gsym->set_got_offset(got_type, got_offset);
1504   rel_dyn->add_global_generic(gsym, r_type, this, got_offset, 0);
1505 }
1506
1507 // Add a pair of entries for a global symbol to the GOT, and add
1508 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1509 // If R_TYPE_2 == 0, add the second entry with no relocation.
1510 template<int got_size, bool big_endian>
1511 void
1512 Output_data_got<got_size, big_endian>::add_global_pair_with_rel(
1513     Symbol* gsym,
1514     unsigned int got_type,
1515     Output_data_reloc_generic* rel_dyn,
1516     unsigned int r_type_1,
1517     unsigned int r_type_2)
1518 {
1519   if (gsym->has_got_offset(got_type))
1520     return;
1521
1522   unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry());
1523   gsym->set_got_offset(got_type, got_offset);
1524   rel_dyn->add_global_generic(gsym, r_type_1, this, got_offset, 0);
1525
1526   if (r_type_2 != 0)
1527     rel_dyn->add_global_generic(gsym, r_type_2, this,
1528                                 got_offset + got_size / 8, 0);
1529 }
1530
1531 // Add an entry for a local symbol to the GOT.  This returns true if
1532 // this is a new GOT entry, false if the symbol already has a GOT
1533 // entry.
1534
1535 template<int got_size, bool big_endian>
1536 bool
1537 Output_data_got<got_size, big_endian>::add_local(
1538     Relobj* object,
1539     unsigned int symndx,
1540     unsigned int got_type)
1541 {
1542   if (object->local_has_got_offset(symndx, got_type))
1543     return false;
1544
1545   unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1546                                                           false));
1547   object->set_local_got_offset(symndx, got_type, got_offset);
1548   return true;
1549 }
1550
1551 // Like add_local, but use the PLT offset.
1552
1553 template<int got_size, bool big_endian>
1554 bool
1555 Output_data_got<got_size, big_endian>::add_local_plt(
1556     Relobj* object,
1557     unsigned int symndx,
1558     unsigned int got_type)
1559 {
1560   if (object->local_has_got_offset(symndx, got_type))
1561     return false;
1562
1563   unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1564                                                           true));
1565   object->set_local_got_offset(symndx, got_type, got_offset);
1566   return true;
1567 }
1568
1569 // Add an entry for a local symbol to the GOT, and add a dynamic
1570 // relocation of type R_TYPE for the GOT entry.
1571
1572 template<int got_size, bool big_endian>
1573 void
1574 Output_data_got<got_size, big_endian>::add_local_with_rel(
1575     Relobj* object,
1576     unsigned int symndx,
1577     unsigned int got_type,
1578     Output_data_reloc_generic* rel_dyn,
1579     unsigned int r_type)
1580 {
1581   if (object->local_has_got_offset(symndx, got_type))
1582     return;
1583
1584   unsigned int got_offset = this->add_got_entry(Got_entry());
1585   object->set_local_got_offset(symndx, got_type, got_offset);
1586   rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0);
1587 }
1588
1589 // Add a pair of entries for a local symbol to the GOT, and add
1590 // a dynamic relocation of type R_TYPE using the section symbol of
1591 // the output section to which input section SHNDX maps, on the first.
1592 // The first got entry will have a value of zero, the second the
1593 // value of the local symbol.
1594 template<int got_size, bool big_endian>
1595 void
1596 Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
1597     Relobj* object,
1598     unsigned int symndx,
1599     unsigned int shndx,
1600     unsigned int got_type,
1601     Output_data_reloc_generic* rel_dyn,
1602     unsigned int r_type)
1603 {
1604   if (object->local_has_got_offset(symndx, got_type))
1605     return;
1606
1607   unsigned int got_offset =
1608       this->add_got_entry_pair(Got_entry(),
1609                                Got_entry(object, symndx, false));
1610   object->set_local_got_offset(symndx, got_type, got_offset);
1611   Output_section* os = object->output_section(shndx);
1612   rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0);
1613 }
1614
1615 // Add a pair of entries for a local symbol to the GOT, and add
1616 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
1617 // The first got entry will have a value of zero, the second the
1618 // value of the local symbol offset by Target::tls_offset_for_local.
1619 template<int got_size, bool big_endian>
1620 void
1621 Output_data_got<got_size, big_endian>::add_local_tls_pair(
1622     Relobj* object,
1623     unsigned int symndx,
1624     unsigned int got_type,
1625     Output_data_reloc_generic* rel_dyn,
1626     unsigned int r_type)
1627 {
1628   if (object->local_has_got_offset(symndx, got_type))
1629     return;
1630
1631   unsigned int got_offset
1632     = this->add_got_entry_pair(Got_entry(),
1633                                Got_entry(object, symndx, true));
1634   object->set_local_got_offset(symndx, got_type, got_offset);
1635   rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0);
1636 }
1637
1638 // Reserve a slot in the GOT for a local symbol or the second slot of a pair.
1639
1640 template<int got_size, bool big_endian>
1641 void
1642 Output_data_got<got_size, big_endian>::reserve_local(
1643     unsigned int i,
1644     Relobj* object,
1645     unsigned int sym_index,
1646     unsigned int got_type)
1647 {
1648   this->do_reserve_slot(i);
1649   object->set_local_got_offset(sym_index, got_type, this->got_offset(i));
1650 }
1651
1652 // Reserve a slot in the GOT for a global symbol.
1653
1654 template<int got_size, bool big_endian>
1655 void
1656 Output_data_got<got_size, big_endian>::reserve_global(
1657     unsigned int i,
1658     Symbol* gsym,
1659     unsigned int got_type)
1660 {
1661   this->do_reserve_slot(i);
1662   gsym->set_got_offset(got_type, this->got_offset(i));
1663 }
1664
1665 // Write out the GOT.
1666
1667 template<int got_size, bool big_endian>
1668 void
1669 Output_data_got<got_size, big_endian>::do_write(Output_file* of)
1670 {
1671   const int add = got_size / 8;
1672
1673   const off_t off = this->offset();
1674   const off_t oview_size = this->data_size();
1675   unsigned char* const oview = of->get_output_view(off, oview_size);
1676
1677   unsigned char* pov = oview;
1678   for (unsigned int i = 0; i < this->entries_.size(); ++i)
1679     {
1680       this->entries_[i].write(i, pov);
1681       pov += add;
1682     }
1683
1684   gold_assert(pov - oview == oview_size);
1685
1686   of->write_output_view(off, oview_size, oview);
1687
1688   // We no longer need the GOT entries.
1689   this->entries_.clear();
1690 }
1691
1692 // Create a new GOT entry and return its offset.
1693
1694 template<int got_size, bool big_endian>
1695 unsigned int
1696 Output_data_got<got_size, big_endian>::add_got_entry(Got_entry got_entry)
1697 {
1698   if (!this->is_data_size_valid())
1699     {
1700       this->entries_.push_back(got_entry);
1701       this->set_got_size();
1702       return this->last_got_offset();
1703     }
1704   else
1705     {
1706       // For an incremental update, find an available slot.
1707       off_t got_offset = this->free_list_.allocate(got_size / 8,
1708                                                    got_size / 8, 0);
1709       if (got_offset == -1)
1710         gold_fallback(_("out of patch space (GOT);"
1711                         " relink with --incremental-full"));
1712       unsigned int got_index = got_offset / (got_size / 8);
1713       gold_assert(got_index < this->entries_.size());
1714       this->entries_[got_index] = got_entry;
1715       return static_cast<unsigned int>(got_offset);
1716     }
1717 }
1718
1719 // Create a pair of new GOT entries and return the offset of the first.
1720
1721 template<int got_size, bool big_endian>
1722 unsigned int
1723 Output_data_got<got_size, big_endian>::add_got_entry_pair(
1724     Got_entry got_entry_1,
1725     Got_entry got_entry_2)
1726 {
1727   if (!this->is_data_size_valid())
1728     {
1729       unsigned int got_offset;
1730       this->entries_.push_back(got_entry_1);
1731       got_offset = this->last_got_offset();
1732       this->entries_.push_back(got_entry_2);
1733       this->set_got_size();
1734       return got_offset;
1735     }
1736   else
1737     {
1738       // For an incremental update, find an available pair of slots.
1739       off_t got_offset = this->free_list_.allocate(2 * got_size / 8,
1740                                                    got_size / 8, 0);
1741       if (got_offset == -1)
1742         gold_fallback(_("out of patch space (GOT);"
1743                         " relink with --incremental-full"));
1744       unsigned int got_index = got_offset / (got_size / 8);
1745       gold_assert(got_index < this->entries_.size());
1746       this->entries_[got_index] = got_entry_1;
1747       this->entries_[got_index + 1] = got_entry_2;
1748       return static_cast<unsigned int>(got_offset);
1749     }
1750 }
1751
1752 // Replace GOT entry I with a new value.
1753
1754 template<int got_size, bool big_endian>
1755 void
1756 Output_data_got<got_size, big_endian>::replace_got_entry(
1757     unsigned int i,
1758     Got_entry got_entry)
1759 {
1760   gold_assert(i < this->entries_.size());
1761   this->entries_[i] = got_entry;
1762 }
1763
1764 // Output_data_dynamic::Dynamic_entry methods.
1765
1766 // Write out the entry.
1767
1768 template<int size, bool big_endian>
1769 void
1770 Output_data_dynamic::Dynamic_entry::write(
1771     unsigned char* pov,
1772     const Stringpool* pool) const
1773 {
1774   typename elfcpp::Elf_types<size>::Elf_WXword val;
1775   switch (this->offset_)
1776     {
1777     case DYNAMIC_NUMBER:
1778       val = this->u_.val;
1779       break;
1780
1781     case DYNAMIC_SECTION_SIZE:
1782       val = this->u_.od->data_size();
1783       if (this->od2 != NULL)
1784         val += this->od2->data_size();
1785       break;
1786
1787     case DYNAMIC_SYMBOL:
1788       {
1789         const Sized_symbol<size>* s =
1790           static_cast<const Sized_symbol<size>*>(this->u_.sym);
1791         val = s->value();
1792       }
1793       break;
1794
1795     case DYNAMIC_STRING:
1796       val = pool->get_offset(this->u_.str);
1797       break;
1798
1799     default:
1800       val = this->u_.od->address() + this->offset_;
1801       break;
1802     }
1803
1804   elfcpp::Dyn_write<size, big_endian> dw(pov);
1805   dw.put_d_tag(this->tag_);
1806   dw.put_d_val(val);
1807 }
1808
1809 // Output_data_dynamic methods.
1810
1811 // Adjust the output section to set the entry size.
1812
1813 void
1814 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1815 {
1816   if (parameters->target().get_size() == 32)
1817     os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1818   else if (parameters->target().get_size() == 64)
1819     os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1820   else
1821     gold_unreachable();
1822 }
1823
1824 // Set the final data size.
1825
1826 void
1827 Output_data_dynamic::set_final_data_size()
1828 {
1829   // Add the terminating entry if it hasn't been added.
1830   // Because of relaxation, we can run this multiple times.
1831   if (this->entries_.empty() || this->entries_.back().tag() != elfcpp::DT_NULL)
1832     {
1833       int extra = parameters->options().spare_dynamic_tags();
1834       for (int i = 0; i < extra; ++i)
1835         this->add_constant(elfcpp::DT_NULL, 0);
1836       this->add_constant(elfcpp::DT_NULL, 0);
1837     }
1838
1839   int dyn_size;
1840   if (parameters->target().get_size() == 32)
1841     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1842   else if (parameters->target().get_size() == 64)
1843     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1844   else
1845     gold_unreachable();
1846   this->set_data_size(this->entries_.size() * dyn_size);
1847 }
1848
1849 // Write out the dynamic entries.
1850
1851 void
1852 Output_data_dynamic::do_write(Output_file* of)
1853 {
1854   switch (parameters->size_and_endianness())
1855     {
1856 #ifdef HAVE_TARGET_32_LITTLE
1857     case Parameters::TARGET_32_LITTLE:
1858       this->sized_write<32, false>(of);
1859       break;
1860 #endif
1861 #ifdef HAVE_TARGET_32_BIG
1862     case Parameters::TARGET_32_BIG:
1863       this->sized_write<32, true>(of);
1864       break;
1865 #endif
1866 #ifdef HAVE_TARGET_64_LITTLE
1867     case Parameters::TARGET_64_LITTLE:
1868       this->sized_write<64, false>(of);
1869       break;
1870 #endif
1871 #ifdef HAVE_TARGET_64_BIG
1872     case Parameters::TARGET_64_BIG:
1873       this->sized_write<64, true>(of);
1874       break;
1875 #endif
1876     default:
1877       gold_unreachable();
1878     }
1879 }
1880
1881 template<int size, bool big_endian>
1882 void
1883 Output_data_dynamic::sized_write(Output_file* of)
1884 {
1885   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1886
1887   const off_t offset = this->offset();
1888   const off_t oview_size = this->data_size();
1889   unsigned char* const oview = of->get_output_view(offset, oview_size);
1890
1891   unsigned char* pov = oview;
1892   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
1893        p != this->entries_.end();
1894        ++p)
1895     {
1896       p->write<size, big_endian>(pov, this->pool_);
1897       pov += dyn_size;
1898     }
1899
1900   gold_assert(pov - oview == oview_size);
1901
1902   of->write_output_view(offset, oview_size, oview);
1903
1904   // We no longer need the dynamic entries.
1905   this->entries_.clear();
1906 }
1907
1908 // Class Output_symtab_xindex.
1909
1910 void
1911 Output_symtab_xindex::do_write(Output_file* of)
1912 {
1913   const off_t offset = this->offset();
1914   const off_t oview_size = this->data_size();
1915   unsigned char* const oview = of->get_output_view(offset, oview_size);
1916
1917   memset(oview, 0, oview_size);
1918
1919   if (parameters->target().is_big_endian())
1920     this->endian_do_write<true>(oview);
1921   else
1922     this->endian_do_write<false>(oview);
1923
1924   of->write_output_view(offset, oview_size, oview);
1925
1926   // We no longer need the data.
1927   this->entries_.clear();
1928 }
1929
1930 template<bool big_endian>
1931 void
1932 Output_symtab_xindex::endian_do_write(unsigned char* const oview)
1933 {
1934   for (Xindex_entries::const_iterator p = this->entries_.begin();
1935        p != this->entries_.end();
1936        ++p)
1937     {
1938       unsigned int symndx = p->first;
1939       gold_assert(static_cast<off_t>(symndx) * 4 < this->data_size());
1940       elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
1941     }
1942 }
1943
1944 // Output_fill_debug_info methods.
1945
1946 // Return the minimum size needed for a dummy compilation unit header.
1947
1948 size_t
1949 Output_fill_debug_info::do_minimum_hole_size() const
1950 {
1951   // Compile unit header fields: unit_length, version, debug_abbrev_offset,
1952   // address_size.
1953   const size_t len = 4 + 2 + 4 + 1;
1954   // For type units, add type_signature, type_offset.
1955   if (this->is_debug_types_)
1956     return len + 8 + 4;
1957   return len;
1958 }
1959
1960 // Write a dummy compilation unit header to fill a hole in the
1961 // .debug_info or .debug_types section.
1962
1963 void
1964 Output_fill_debug_info::do_write(Output_file* of, off_t off, size_t len) const
1965 {
1966   gold_debug(DEBUG_INCREMENTAL, "fill_debug_info(%08lx, %08lx)",
1967              static_cast<long>(off), static_cast<long>(len));
1968
1969   gold_assert(len >= this->do_minimum_hole_size());
1970
1971   unsigned char* const oview = of->get_output_view(off, len);
1972   unsigned char* pov = oview;
1973
1974   // Write header fields: unit_length, version, debug_abbrev_offset,
1975   // address_size.
1976   if (this->is_big_endian())
1977     {
1978       elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
1979       elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
1980       elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, 0);
1981     }
1982   else
1983     {
1984       elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
1985       elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
1986       elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, 0);
1987     }
1988   pov += 4 + 2 + 4;
1989   *pov++ = 4;
1990
1991   // For type units, the additional header fields -- type_signature,
1992   // type_offset -- can be filled with zeroes.
1993
1994   // Fill the remainder of the free space with zeroes.  The first
1995   // zero should tell the consumer there are no DIEs to read in this
1996   // compilation unit.
1997   if (pov < oview + len)
1998     memset(pov, 0, oview + len - pov);
1999
2000   of->write_output_view(off, len, oview);
2001 }
2002
2003 // Output_fill_debug_line methods.
2004
2005 // Return the minimum size needed for a dummy line number program header.
2006
2007 size_t
2008 Output_fill_debug_line::do_minimum_hole_size() const
2009 {
2010   // Line number program header fields: unit_length, version, header_length,
2011   // minimum_instruction_length, default_is_stmt, line_base, line_range,
2012   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2013   const size_t len = 4 + 2 + 4 + this->header_length;
2014   return len;
2015 }
2016
2017 // Write a dummy line number program header to fill a hole in the
2018 // .debug_line section.
2019
2020 void
2021 Output_fill_debug_line::do_write(Output_file* of, off_t off, size_t len) const
2022 {
2023   gold_debug(DEBUG_INCREMENTAL, "fill_debug_line(%08lx, %08lx)",
2024              static_cast<long>(off), static_cast<long>(len));
2025
2026   gold_assert(len >= this->do_minimum_hole_size());
2027
2028   unsigned char* const oview = of->get_output_view(off, len);
2029   unsigned char* pov = oview;
2030
2031   // Write header fields: unit_length, version, header_length,
2032   // minimum_instruction_length, default_is_stmt, line_base, line_range,
2033   // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2034   // We set the header_length field to cover the entire hole, so the
2035   // line number program is empty.
2036   if (this->is_big_endian())
2037     {
2038       elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
2039       elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
2040       elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, len - (4 + 2 + 4));
2041     }
2042   else
2043     {
2044       elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
2045       elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
2046       elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, len - (4 + 2 + 4));
2047     }
2048   pov += 4 + 2 + 4;
2049   *pov++ = 1;   // minimum_instruction_length
2050   *pov++ = 0;   // default_is_stmt
2051   *pov++ = 0;   // line_base
2052   *pov++ = 5;   // line_range
2053   *pov++ = 13;  // opcode_base
2054   *pov++ = 0;   // standard_opcode_lengths[1]
2055   *pov++ = 1;   // standard_opcode_lengths[2]
2056   *pov++ = 1;   // standard_opcode_lengths[3]
2057   *pov++ = 1;   // standard_opcode_lengths[4]
2058   *pov++ = 1;   // standard_opcode_lengths[5]
2059   *pov++ = 0;   // standard_opcode_lengths[6]
2060   *pov++ = 0;   // standard_opcode_lengths[7]
2061   *pov++ = 0;   // standard_opcode_lengths[8]
2062   *pov++ = 1;   // standard_opcode_lengths[9]
2063   *pov++ = 0;   // standard_opcode_lengths[10]
2064   *pov++ = 0;   // standard_opcode_lengths[11]
2065   *pov++ = 1;   // standard_opcode_lengths[12]
2066   *pov++ = 0;   // include_directories (empty)
2067   *pov++ = 0;   // filenames (empty)
2068
2069   // Some consumers don't check the header_length field, and simply
2070   // start reading the line number program immediately following the
2071   // header.  For those consumers, we fill the remainder of the free
2072   // space with DW_LNS_set_basic_block opcodes.  These are effectively
2073   // no-ops: the resulting line table program will not create any rows.
2074   if (pov < oview + len)
2075     memset(pov, elfcpp::DW_LNS_set_basic_block, oview + len - pov);
2076
2077   of->write_output_view(off, len, oview);
2078 }
2079
2080 // Output_section::Input_section methods.
2081
2082 // Return the current data size.  For an input section we store the size here.
2083 // For an Output_section_data, we have to ask it for the size.
2084
2085 off_t
2086 Output_section::Input_section::current_data_size() const
2087 {
2088   if (this->is_input_section())
2089     return this->u1_.data_size;
2090   else
2091     {
2092       this->u2_.posd->pre_finalize_data_size();
2093       return this->u2_.posd->current_data_size();
2094     }
2095 }
2096
2097 // Return the data size.  For an input section we store the size here.
2098 // For an Output_section_data, we have to ask it for the size.
2099
2100 off_t
2101 Output_section::Input_section::data_size() const
2102 {
2103   if (this->is_input_section())
2104     return this->u1_.data_size;
2105   else
2106     return this->u2_.posd->data_size();
2107 }
2108
2109 // Return the object for an input section.
2110
2111 Relobj*
2112 Output_section::Input_section::relobj() const
2113 {
2114   if (this->is_input_section())
2115     return this->u2_.object;
2116   else if (this->is_merge_section())
2117     {
2118       gold_assert(this->u2_.pomb->first_relobj() != NULL);
2119       return this->u2_.pomb->first_relobj();
2120     }
2121   else if (this->is_relaxed_input_section())
2122     return this->u2_.poris->relobj();
2123   else
2124     gold_unreachable();
2125 }
2126
2127 // Return the input section index for an input section.
2128
2129 unsigned int
2130 Output_section::Input_section::shndx() const
2131 {
2132   if (this->is_input_section())
2133     return this->shndx_;
2134   else if (this->is_merge_section())
2135     {
2136       gold_assert(this->u2_.pomb->first_relobj() != NULL);
2137       return this->u2_.pomb->first_shndx();
2138     }
2139   else if (this->is_relaxed_input_section())
2140     return this->u2_.poris->shndx();
2141   else
2142     gold_unreachable();
2143 }
2144
2145 // Set the address and file offset.
2146
2147 void
2148 Output_section::Input_section::set_address_and_file_offset(
2149     uint64_t address,
2150     off_t file_offset,
2151     off_t section_file_offset)
2152 {
2153   if (this->is_input_section())
2154     this->u2_.object->set_section_offset(this->shndx_,
2155                                          file_offset - section_file_offset);
2156   else
2157     this->u2_.posd->set_address_and_file_offset(address, file_offset);
2158 }
2159
2160 // Reset the address and file offset.
2161
2162 void
2163 Output_section::Input_section::reset_address_and_file_offset()
2164 {
2165   if (!this->is_input_section())
2166     this->u2_.posd->reset_address_and_file_offset();
2167 }
2168
2169 // Finalize the data size.
2170
2171 void
2172 Output_section::Input_section::finalize_data_size()
2173 {
2174   if (!this->is_input_section())
2175     this->u2_.posd->finalize_data_size();
2176 }
2177
2178 // Try to turn an input offset into an output offset.  We want to
2179 // return the output offset relative to the start of this
2180 // Input_section in the output section.
2181
2182 inline bool
2183 Output_section::Input_section::output_offset(
2184     const Relobj* object,
2185     unsigned int shndx,
2186     section_offset_type offset,
2187     section_offset_type* poutput) const
2188 {
2189   if (!this->is_input_section())
2190     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
2191   else
2192     {
2193       if (this->shndx_ != shndx || this->u2_.object != object)
2194         return false;
2195       *poutput = offset;
2196       return true;
2197     }
2198 }
2199
2200 // Return whether this is the merge section for the input section
2201 // SHNDX in OBJECT.
2202
2203 inline bool
2204 Output_section::Input_section::is_merge_section_for(const Relobj* object,
2205                                                     unsigned int shndx) const
2206 {
2207   if (this->is_input_section())
2208     return false;
2209   return this->u2_.posd->is_merge_section_for(object, shndx);
2210 }
2211
2212 // Write out the data.  We don't have to do anything for an input
2213 // section--they are handled via Object::relocate--but this is where
2214 // we write out the data for an Output_section_data.
2215
2216 void
2217 Output_section::Input_section::write(Output_file* of)
2218 {
2219   if (!this->is_input_section())
2220     this->u2_.posd->write(of);
2221 }
2222
2223 // Write the data to a buffer.  As for write(), we don't have to do
2224 // anything for an input section.
2225
2226 void
2227 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
2228 {
2229   if (!this->is_input_section())
2230     this->u2_.posd->write_to_buffer(buffer);
2231 }
2232
2233 // Print to a map file.
2234
2235 void
2236 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
2237 {
2238   switch (this->shndx_)
2239     {
2240     case OUTPUT_SECTION_CODE:
2241     case MERGE_DATA_SECTION_CODE:
2242     case MERGE_STRING_SECTION_CODE:
2243       this->u2_.posd->print_to_mapfile(mapfile);
2244       break;
2245
2246     case RELAXED_INPUT_SECTION_CODE:
2247       {
2248         Output_relaxed_input_section* relaxed_section =
2249           this->relaxed_input_section();
2250         mapfile->print_input_section(relaxed_section->relobj(),
2251                                      relaxed_section->shndx());
2252       }
2253       break;
2254     default:
2255       mapfile->print_input_section(this->u2_.object, this->shndx_);
2256       break;
2257     }
2258 }
2259
2260 // Output_section methods.
2261
2262 // Construct an Output_section.  NAME will point into a Stringpool.
2263
2264 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
2265                                elfcpp::Elf_Xword flags)
2266   : name_(name),
2267     addralign_(0),
2268     entsize_(0),
2269     load_address_(0),
2270     link_section_(NULL),
2271     link_(0),
2272     info_section_(NULL),
2273     info_symndx_(NULL),
2274     info_(0),
2275     type_(type),
2276     flags_(flags),
2277     order_(ORDER_INVALID),
2278     out_shndx_(-1U),
2279     symtab_index_(0),
2280     dynsym_index_(0),
2281     input_sections_(),
2282     first_input_offset_(0),
2283     fills_(),
2284     postprocessing_buffer_(NULL),
2285     needs_symtab_index_(false),
2286     needs_dynsym_index_(false),
2287     should_link_to_symtab_(false),
2288     should_link_to_dynsym_(false),
2289     after_input_sections_(false),
2290     requires_postprocessing_(false),
2291     found_in_sections_clause_(false),
2292     has_load_address_(false),
2293     info_uses_section_index_(false),
2294     input_section_order_specified_(false),
2295     may_sort_attached_input_sections_(false),
2296     must_sort_attached_input_sections_(false),
2297     attached_input_sections_are_sorted_(false),
2298     is_relro_(false),
2299     is_small_section_(false),
2300     is_large_section_(false),
2301     generate_code_fills_at_write_(false),
2302     is_entsize_zero_(false),
2303     section_offsets_need_adjustment_(false),
2304     is_noload_(false),
2305     always_keeps_input_sections_(false),
2306     has_fixed_layout_(false),
2307     is_patch_space_allowed_(false),
2308     is_unique_segment_(false),
2309     tls_offset_(0),
2310     extra_segment_flags_(0),
2311     segment_alignment_(0),
2312     checkpoint_(NULL),
2313     lookup_maps_(new Output_section_lookup_maps),
2314     free_list_(),
2315     free_space_fill_(NULL),
2316     patch_space_(0)
2317 {
2318   // An unallocated section has no address.  Forcing this means that
2319   // we don't need special treatment for symbols defined in debug
2320   // sections.
2321   if ((flags & elfcpp::SHF_ALLOC) == 0)
2322     this->set_address(0);
2323 }
2324
2325 Output_section::~Output_section()
2326 {
2327   delete this->checkpoint_;
2328 }
2329
2330 // Set the entry size.
2331
2332 void
2333 Output_section::set_entsize(uint64_t v)
2334 {
2335   if (this->is_entsize_zero_)
2336     ;
2337   else if (this->entsize_ == 0)
2338     this->entsize_ = v;
2339   else if (this->entsize_ != v)
2340     {
2341       this->entsize_ = 0;
2342       this->is_entsize_zero_ = 1;
2343     }
2344 }
2345
2346 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2347 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
2348 // relocation section which applies to this section, or 0 if none, or
2349 // -1U if more than one.  Return the offset of the input section
2350 // within the output section.  Return -1 if the input section will
2351 // receive special handling.  In the normal case we don't always keep
2352 // track of input sections for an Output_section.  Instead, each
2353 // Object keeps track of the Output_section for each of its input
2354 // sections.  However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2355 // track of input sections here; this is used when SECTIONS appears in
2356 // a linker script.
2357
2358 template<int size, bool big_endian>
2359 off_t
2360 Output_section::add_input_section(Layout* layout,
2361                                   Sized_relobj_file<size, big_endian>* object,
2362                                   unsigned int shndx,
2363                                   const char* secname,
2364                                   const elfcpp::Shdr<size, big_endian>& shdr,
2365                                   unsigned int reloc_shndx,
2366                                   bool have_sections_script)
2367 {
2368   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
2369   if ((addralign & (addralign - 1)) != 0)
2370     {
2371       object->error(_("invalid alignment %lu for section \"%s\""),
2372                     static_cast<unsigned long>(addralign), secname);
2373       addralign = 1;
2374     }
2375
2376   if (addralign > this->addralign_)
2377     this->addralign_ = addralign;
2378
2379   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
2380   uint64_t entsize = shdr.get_sh_entsize();
2381
2382   // .debug_str is a mergeable string section, but is not always so
2383   // marked by compilers.  Mark manually here so we can optimize.
2384   if (strcmp(secname, ".debug_str") == 0)
2385     {
2386       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
2387       entsize = 1;
2388     }
2389
2390   this->update_flags_for_input_section(sh_flags);
2391   this->set_entsize(entsize);
2392
2393   // If this is a SHF_MERGE section, we pass all the input sections to
2394   // a Output_data_merge.  We don't try to handle relocations for such
2395   // a section.  We don't try to handle empty merge sections--they
2396   // mess up the mappings, and are useless anyhow.
2397   // FIXME: Need to handle merge sections during incremental update.
2398   if ((sh_flags & elfcpp::SHF_MERGE) != 0
2399       && reloc_shndx == 0
2400       && shdr.get_sh_size() > 0
2401       && !parameters->incremental())
2402     {
2403       // Keep information about merged input sections for rebuilding fast
2404       // lookup maps if we have sections-script or we do relaxation.
2405       bool keeps_input_sections = (this->always_keeps_input_sections_
2406                                    || have_sections_script
2407                                    || parameters->target().may_relax());
2408
2409       if (this->add_merge_input_section(object, shndx, sh_flags, entsize,
2410                                         addralign, keeps_input_sections))
2411         {
2412           // Tell the relocation routines that they need to call the
2413           // output_offset method to determine the final address.
2414           return -1;
2415         }
2416     }
2417
2418   section_size_type input_section_size = shdr.get_sh_size();
2419   section_size_type uncompressed_size;
2420   if (object->section_is_compressed(shndx, &uncompressed_size))
2421     input_section_size = uncompressed_size;
2422
2423   off_t offset_in_section;
2424
2425   if (this->has_fixed_layout())
2426     {
2427       // For incremental updates, find a chunk of unused space in the section.
2428       offset_in_section = this->free_list_.allocate(input_section_size,
2429                                                     addralign, 0);
2430       if (offset_in_section == -1)
2431         gold_fallback(_("out of patch space in section %s; "
2432                         "relink with --incremental-full"),
2433                       this->name());
2434       return offset_in_section;
2435     }
2436
2437   offset_in_section = this->current_data_size_for_child();
2438   off_t aligned_offset_in_section = align_address(offset_in_section,
2439                                                   addralign);
2440   this->set_current_data_size_for_child(aligned_offset_in_section
2441                                         + input_section_size);
2442
2443   // Determine if we want to delay code-fill generation until the output
2444   // section is written.  When the target is relaxing, we want to delay fill
2445   // generating to avoid adjusting them during relaxation.  Also, if we are
2446   // sorting input sections we must delay fill generation.
2447   if (!this->generate_code_fills_at_write_
2448       && !have_sections_script
2449       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2450       && parameters->target().has_code_fill()
2451       && (parameters->target().may_relax()
2452           || layout->is_section_ordering_specified()))
2453     {
2454       gold_assert(this->fills_.empty());
2455       this->generate_code_fills_at_write_ = true;
2456     }
2457
2458   if (aligned_offset_in_section > offset_in_section
2459       && !this->generate_code_fills_at_write_
2460       && !have_sections_script
2461       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2462       && parameters->target().has_code_fill())
2463     {
2464       // We need to add some fill data.  Using fill_list_ when
2465       // possible is an optimization, since we will often have fill
2466       // sections without input sections.
2467       off_t fill_len = aligned_offset_in_section - offset_in_section;
2468       if (this->input_sections_.empty())
2469         this->fills_.push_back(Fill(offset_in_section, fill_len));
2470       else
2471         {
2472           std::string fill_data(parameters->target().code_fill(fill_len));
2473           Output_data_const* odc = new Output_data_const(fill_data, 1);
2474           this->input_sections_.push_back(Input_section(odc));
2475         }
2476     }
2477
2478   // We need to keep track of this section if we are already keeping
2479   // track of sections, or if we are relaxing.  Also, if this is a
2480   // section which requires sorting, or which may require sorting in
2481   // the future, we keep track of the sections.  If the
2482   // --section-ordering-file option is used to specify the order of
2483   // sections, we need to keep track of sections.
2484   if (this->always_keeps_input_sections_
2485       || have_sections_script
2486       || !this->input_sections_.empty()
2487       || this->may_sort_attached_input_sections()
2488       || this->must_sort_attached_input_sections()
2489       || parameters->options().user_set_Map()
2490       || parameters->target().may_relax()
2491       || layout->is_section_ordering_specified())
2492     {
2493       Input_section isecn(object, shndx, input_section_size, addralign);
2494       /* If section ordering is requested by specifying a ordering file,
2495          using --section-ordering-file, match the section name with
2496          a pattern.  */
2497       if (parameters->options().section_ordering_file())
2498         {
2499           unsigned int section_order_index =
2500             layout->find_section_order_index(std::string(secname));
2501           if (section_order_index != 0)
2502             {
2503               isecn.set_section_order_index(section_order_index);
2504               this->set_input_section_order_specified();
2505             }
2506         }
2507       this->input_sections_.push_back(isecn);
2508     }
2509
2510   return aligned_offset_in_section;
2511 }
2512
2513 // Add arbitrary data to an output section.
2514
2515 void
2516 Output_section::add_output_section_data(Output_section_data* posd)
2517 {
2518   Input_section inp(posd);
2519   this->add_output_section_data(&inp);
2520
2521   if (posd->is_data_size_valid())
2522     {
2523       off_t offset_in_section;
2524       if (this->has_fixed_layout())
2525         {
2526           // For incremental updates, find a chunk of unused space.
2527           offset_in_section = this->free_list_.allocate(posd->data_size(),
2528                                                         posd->addralign(), 0);
2529           if (offset_in_section == -1)
2530             gold_fallback(_("out of patch space in section %s; "
2531                             "relink with --incremental-full"),
2532                           this->name());
2533           // Finalize the address and offset now.
2534           uint64_t addr = this->address();
2535           off_t offset = this->offset();
2536           posd->set_address_and_file_offset(addr + offset_in_section,
2537                                             offset + offset_in_section);
2538         }
2539       else
2540         {
2541           offset_in_section = this->current_data_size_for_child();
2542           off_t aligned_offset_in_section = align_address(offset_in_section,
2543                                                           posd->addralign());
2544           this->set_current_data_size_for_child(aligned_offset_in_section
2545                                                 + posd->data_size());
2546         }
2547     }
2548   else if (this->has_fixed_layout())
2549     {
2550       // For incremental updates, arrange for the data to have a fixed layout.
2551       // This will mean that additions to the data must be allocated from
2552       // free space within the containing output section.
2553       uint64_t addr = this->address();
2554       posd->set_address(addr);
2555       posd->set_file_offset(0);
2556       // FIXME: This should eventually be unreachable.
2557       // gold_unreachable();
2558     }
2559 }
2560
2561 // Add a relaxed input section.
2562
2563 void
2564 Output_section::add_relaxed_input_section(Layout* layout,
2565                                           Output_relaxed_input_section* poris,
2566                                           const std::string& name)
2567 {
2568   Input_section inp(poris);
2569
2570   // If the --section-ordering-file option is used to specify the order of
2571   // sections, we need to keep track of sections.
2572   if (layout->is_section_ordering_specified())
2573     {
2574       unsigned int section_order_index =
2575         layout->find_section_order_index(name);
2576       if (section_order_index != 0)
2577         {
2578           inp.set_section_order_index(section_order_index);
2579           this->set_input_section_order_specified();
2580         }
2581     }
2582
2583   this->add_output_section_data(&inp);
2584   if (this->lookup_maps_->is_valid())
2585     this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2586                                                   poris->shndx(), poris);
2587
2588   // For a relaxed section, we use the current data size.  Linker scripts
2589   // get all the input sections, including relaxed one from an output
2590   // section and add them back to the same output section to compute the
2591   // output section size.  If we do not account for sizes of relaxed input
2592   // sections, an output section would be incorrectly sized.
2593   off_t offset_in_section = this->current_data_size_for_child();
2594   off_t aligned_offset_in_section = align_address(offset_in_section,
2595                                                   poris->addralign());
2596   this->set_current_data_size_for_child(aligned_offset_in_section
2597                                         + poris->current_data_size());
2598 }
2599
2600 // Add arbitrary data to an output section by Input_section.
2601
2602 void
2603 Output_section::add_output_section_data(Input_section* inp)
2604 {
2605   if (this->input_sections_.empty())
2606     this->first_input_offset_ = this->current_data_size_for_child();
2607
2608   this->input_sections_.push_back(*inp);
2609
2610   uint64_t addralign = inp->addralign();
2611   if (addralign > this->addralign_)
2612     this->addralign_ = addralign;
2613
2614   inp->set_output_section(this);
2615 }
2616
2617 // Add a merge section to an output section.
2618
2619 void
2620 Output_section::add_output_merge_section(Output_section_data* posd,
2621                                          bool is_string, uint64_t entsize)
2622 {
2623   Input_section inp(posd, is_string, entsize);
2624   this->add_output_section_data(&inp);
2625 }
2626
2627 // Add an input section to a SHF_MERGE section.
2628
2629 bool
2630 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
2631                                         uint64_t flags, uint64_t entsize,
2632                                         uint64_t addralign,
2633                                         bool keeps_input_sections)
2634 {
2635   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
2636
2637   // We cannot restore merged input section states.
2638   gold_assert(this->checkpoint_ == NULL);
2639
2640   // Look up merge sections by required properties.
2641   // Currently, we only invalidate the lookup maps in script processing
2642   // and relaxation.  We should not have done either when we reach here.
2643   // So we assume that the lookup maps are valid to simply code.
2644   gold_assert(this->lookup_maps_->is_valid());
2645   Merge_section_properties msp(is_string, entsize, addralign);
2646   Output_merge_base* pomb = this->lookup_maps_->find_merge_section(msp);
2647   bool is_new = false;
2648   if (pomb != NULL)
2649     {
2650       gold_assert(pomb->is_string() == is_string
2651                   && pomb->entsize() == entsize
2652                   && pomb->addralign() == addralign);
2653     }
2654   else
2655     {
2656       // Create a new Output_merge_data or Output_merge_string_data.
2657       if (!is_string)
2658         pomb = new Output_merge_data(entsize, addralign);
2659       else
2660         {
2661           switch (entsize)
2662             {
2663             case 1:
2664               pomb = new Output_merge_string<char>(addralign);
2665               break;
2666             case 2:
2667               pomb = new Output_merge_string<uint16_t>(addralign);
2668               break;
2669             case 4:
2670               pomb = new Output_merge_string<uint32_t>(addralign);
2671               break;
2672             default:
2673               return false;
2674             }
2675         }
2676       // If we need to do script processing or relaxation, we need to keep
2677       // the original input sections to rebuild the fast lookup maps.
2678       if (keeps_input_sections)
2679         pomb->set_keeps_input_sections();
2680       is_new = true;
2681     }
2682
2683   if (pomb->add_input_section(object, shndx))
2684     {
2685       // Add new merge section to this output section and link merge
2686       // section properties to new merge section in map.
2687       if (is_new)
2688         {
2689           this->add_output_merge_section(pomb, is_string, entsize);
2690           this->lookup_maps_->add_merge_section(msp, pomb);
2691         }
2692
2693       // Add input section to new merge section and link input section to new
2694       // merge section in map.
2695       this->lookup_maps_->add_merge_input_section(object, shndx, pomb);
2696       return true;
2697     }
2698   else
2699     {
2700       // If add_input_section failed, delete new merge section to avoid
2701       // exporting empty merge sections in Output_section::get_input_section.
2702       if (is_new)
2703         delete pomb;
2704       return false;
2705     }
2706 }
2707
2708 // Build a relaxation map to speed up relaxation of existing input sections.
2709 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2710
2711 void
2712 Output_section::build_relaxation_map(
2713   const Input_section_list& input_sections,
2714   size_t limit,
2715   Relaxation_map* relaxation_map) const
2716 {
2717   for (size_t i = 0; i < limit; ++i)
2718     {
2719       const Input_section& is(input_sections[i]);
2720       if (is.is_input_section() || is.is_relaxed_input_section())
2721         {
2722           Section_id sid(is.relobj(), is.shndx());
2723           (*relaxation_map)[sid] = i;
2724         }
2725     }
2726 }
2727
2728 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2729 // sections in RELAXED_SECTIONS.  MAP is a prebuilt map from section id
2730 // indices of INPUT_SECTIONS.
2731
2732 void
2733 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2734   const std::vector<Output_relaxed_input_section*>& relaxed_sections,
2735   const Relaxation_map& map,
2736   Input_section_list* input_sections)
2737 {
2738   for (size_t i = 0; i < relaxed_sections.size(); ++i)
2739     {
2740       Output_relaxed_input_section* poris = relaxed_sections[i];
2741       Section_id sid(poris->relobj(), poris->shndx());
2742       Relaxation_map::const_iterator p = map.find(sid);
2743       gold_assert(p != map.end());
2744       gold_assert((*input_sections)[p->second].is_input_section());
2745
2746       // Remember section order index of original input section
2747       // if it is set.  Copy it to the relaxed input section.
2748       unsigned int soi =
2749         (*input_sections)[p->second].section_order_index();
2750       (*input_sections)[p->second] = Input_section(poris);
2751       (*input_sections)[p->second].set_section_order_index(soi);
2752     }
2753 }
2754
2755 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2756 // is a vector of pointers to Output_relaxed_input_section or its derived
2757 // classes.  The relaxed sections must correspond to existing input sections.
2758
2759 void
2760 Output_section::convert_input_sections_to_relaxed_sections(
2761   const std::vector<Output_relaxed_input_section*>& relaxed_sections)
2762 {
2763   gold_assert(parameters->target().may_relax());
2764
2765   // We want to make sure that restore_states does not undo the effect of
2766   // this.  If there is no checkpoint active, just search the current
2767   // input section list and replace the sections there.  If there is
2768   // a checkpoint, also replace the sections there.
2769
2770   // By default, we look at the whole list.
2771   size_t limit = this->input_sections_.size();
2772
2773   if (this->checkpoint_ != NULL)
2774     {
2775       // Replace input sections with relaxed input section in the saved
2776       // copy of the input section list.
2777       if (this->checkpoint_->input_sections_saved())
2778         {
2779           Relaxation_map map;
2780           this->build_relaxation_map(
2781                     *(this->checkpoint_->input_sections()),
2782                     this->checkpoint_->input_sections()->size(),
2783                     &map);
2784           this->convert_input_sections_in_list_to_relaxed_sections(
2785                     relaxed_sections,
2786                     map,
2787                     this->checkpoint_->input_sections());
2788         }
2789       else
2790         {
2791           // We have not copied the input section list yet.  Instead, just
2792           // look at the portion that would be saved.
2793           limit = this->checkpoint_->input_sections_size();
2794         }
2795     }
2796
2797   // Convert input sections in input_section_list.
2798   Relaxation_map map;
2799   this->build_relaxation_map(this->input_sections_, limit, &map);
2800   this->convert_input_sections_in_list_to_relaxed_sections(
2801             relaxed_sections,
2802             map,
2803             &this->input_sections_);
2804
2805   // Update fast look-up map.
2806   if (this->lookup_maps_->is_valid())
2807     for (size_t i = 0; i < relaxed_sections.size(); ++i)
2808       {
2809         Output_relaxed_input_section* poris = relaxed_sections[i];
2810         this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2811                                                       poris->shndx(), poris);
2812       }
2813 }
2814
2815 // Update the output section flags based on input section flags.
2816
2817 void
2818 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags)
2819 {
2820   // If we created the section with SHF_ALLOC clear, we set the
2821   // address.  If we are now setting the SHF_ALLOC flag, we need to
2822   // undo that.
2823   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0
2824       && (flags & elfcpp::SHF_ALLOC) != 0)
2825     this->mark_address_invalid();
2826
2827   this->flags_ |= (flags
2828                    & (elfcpp::SHF_WRITE
2829                       | elfcpp::SHF_ALLOC
2830                       | elfcpp::SHF_EXECINSTR));
2831
2832   if ((flags & elfcpp::SHF_MERGE) == 0)
2833     this->flags_ &=~ elfcpp::SHF_MERGE;
2834   else
2835     {
2836       if (this->current_data_size_for_child() == 0)
2837         this->flags_ |= elfcpp::SHF_MERGE;
2838     }
2839
2840   if ((flags & elfcpp::SHF_STRINGS) == 0)
2841     this->flags_ &=~ elfcpp::SHF_STRINGS;
2842   else
2843     {
2844       if (this->current_data_size_for_child() == 0)
2845         this->flags_ |= elfcpp::SHF_STRINGS;
2846     }
2847 }
2848
2849 // Find the merge section into which an input section with index SHNDX in
2850 // OBJECT has been added.  Return NULL if none found.
2851
2852 Output_section_data*
2853 Output_section::find_merge_section(const Relobj* object,
2854                                    unsigned int shndx) const
2855 {
2856   if (!this->lookup_maps_->is_valid())
2857     this->build_lookup_maps();
2858   return this->lookup_maps_->find_merge_section(object, shndx);
2859 }
2860
2861 // Build the lookup maps for merge and relaxed sections.  This is needs
2862 // to be declared as a const methods so that it is callable with a const
2863 // Output_section pointer.  The method only updates states of the maps.
2864
2865 void
2866 Output_section::build_lookup_maps() const
2867 {
2868   this->lookup_maps_->clear();
2869   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2870        p != this->input_sections_.end();
2871        ++p)
2872     {
2873       if (p->is_merge_section())
2874         {
2875           Output_merge_base* pomb = p->output_merge_base();
2876           Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
2877                                        pomb->addralign());
2878           this->lookup_maps_->add_merge_section(msp, pomb);
2879           for (Output_merge_base::Input_sections::const_iterator is =
2880                  pomb->input_sections_begin();
2881                is != pomb->input_sections_end();
2882                ++is)
2883             {
2884               const Const_section_id& csid = *is;
2885             this->lookup_maps_->add_merge_input_section(csid.first,
2886                                                         csid.second, pomb);
2887             }
2888
2889         }
2890       else if (p->is_relaxed_input_section())
2891         {
2892           Output_relaxed_input_section* poris = p->relaxed_input_section();
2893           this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2894                                                         poris->shndx(), poris);
2895         }
2896     }
2897 }
2898
2899 // Find an relaxed input section corresponding to an input section
2900 // in OBJECT with index SHNDX.
2901
2902 const Output_relaxed_input_section*
2903 Output_section::find_relaxed_input_section(const Relobj* object,
2904                                            unsigned int shndx) const
2905 {
2906   if (!this->lookup_maps_->is_valid())
2907     this->build_lookup_maps();
2908   return this->lookup_maps_->find_relaxed_input_section(object, shndx);
2909 }
2910
2911 // Given an address OFFSET relative to the start of input section
2912 // SHNDX in OBJECT, return whether this address is being included in
2913 // the final link.  This should only be called if SHNDX in OBJECT has
2914 // a special mapping.
2915
2916 bool
2917 Output_section::is_input_address_mapped(const Relobj* object,
2918                                         unsigned int shndx,
2919                                         off_t offset) const
2920 {
2921   // Look at the Output_section_data_maps first.
2922   const Output_section_data* posd = this->find_merge_section(object, shndx);
2923   if (posd == NULL)
2924     posd = this->find_relaxed_input_section(object, shndx);
2925
2926   if (posd != NULL)
2927     {
2928       section_offset_type output_offset;
2929       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2930       gold_assert(found);
2931       return output_offset != -1;
2932     }
2933
2934   // Fall back to the slow look-up.
2935   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2936        p != this->input_sections_.end();
2937        ++p)
2938     {
2939       section_offset_type output_offset;
2940       if (p->output_offset(object, shndx, offset, &output_offset))
2941         return output_offset != -1;
2942     }
2943
2944   // By default we assume that the address is mapped.  This should
2945   // only be called after we have passed all sections to Layout.  At
2946   // that point we should know what we are discarding.
2947   return true;
2948 }
2949
2950 // Given an address OFFSET relative to the start of input section
2951 // SHNDX in object OBJECT, return the output offset relative to the
2952 // start of the input section in the output section.  This should only
2953 // be called if SHNDX in OBJECT has a special mapping.
2954
2955 section_offset_type
2956 Output_section::output_offset(const Relobj* object, unsigned int shndx,
2957                               section_offset_type offset) const
2958 {
2959   // This can only be called meaningfully when we know the data size
2960   // of this.
2961   gold_assert(this->is_data_size_valid());
2962
2963   // Look at the Output_section_data_maps first.
2964   const Output_section_data* posd = this->find_merge_section(object, shndx);
2965   if (posd == NULL)
2966     posd = this->find_relaxed_input_section(object, shndx);
2967   if (posd != NULL)
2968     {
2969       section_offset_type output_offset;
2970       bool found = posd->output_offset(object, shndx, offset, &output_offset);
2971       gold_assert(found);
2972       return output_offset;
2973     }
2974
2975   // Fall back to the slow look-up.
2976   for (Input_section_list::const_iterator p = this->input_sections_.begin();
2977        p != this->input_sections_.end();
2978        ++p)
2979     {
2980       section_offset_type output_offset;
2981       if (p->output_offset(object, shndx, offset, &output_offset))
2982         return output_offset;
2983     }
2984   gold_unreachable();
2985 }
2986
2987 // Return the output virtual address of OFFSET relative to the start
2988 // of input section SHNDX in object OBJECT.
2989
2990 uint64_t
2991 Output_section::output_address(const Relobj* object, unsigned int shndx,
2992                                off_t offset) const
2993 {
2994   uint64_t addr = this->address() + this->first_input_offset_;
2995
2996   // Look at the Output_section_data_maps first.
2997   const Output_section_data* posd = this->find_merge_section(object, shndx);
2998   if (posd == NULL)
2999     posd = this->find_relaxed_input_section(object, shndx);
3000   if (posd != NULL && posd->is_address_valid())
3001     {
3002       section_offset_type output_offset;
3003       bool found = posd->output_offset(object, shndx, offset, &output_offset);
3004       gold_assert(found);
3005       return posd->address() + output_offset;
3006     }
3007
3008   // Fall back to the slow look-up.
3009   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3010        p != this->input_sections_.end();
3011        ++p)
3012     {
3013       addr = align_address(addr, p->addralign());
3014       section_offset_type output_offset;
3015       if (p->output_offset(object, shndx, offset, &output_offset))
3016         {
3017           if (output_offset == -1)
3018             return -1ULL;
3019           return addr + output_offset;
3020         }
3021       addr += p->data_size();
3022     }
3023
3024   // If we get here, it means that we don't know the mapping for this
3025   // input section.  This might happen in principle if
3026   // add_input_section were called before add_output_section_data.
3027   // But it should never actually happen.
3028
3029   gold_unreachable();
3030 }
3031
3032 // Find the output address of the start of the merged section for
3033 // input section SHNDX in object OBJECT.
3034
3035 bool
3036 Output_section::find_starting_output_address(const Relobj* object,
3037                                              unsigned int shndx,
3038                                              uint64_t* paddr) const
3039 {
3040   // FIXME: This becomes a bottle-neck if we have many relaxed sections.
3041   // Looking up the merge section map does not always work as we sometimes
3042   // find a merge section without its address set.
3043   uint64_t addr = this->address() + this->first_input_offset_;
3044   for (Input_section_list::const_iterator p = this->input_sections_.begin();
3045        p != this->input_sections_.end();
3046        ++p)
3047     {
3048       addr = align_address(addr, p->addralign());
3049
3050       // It would be nice if we could use the existing output_offset
3051       // method to get the output offset of input offset 0.
3052       // Unfortunately we don't know for sure that input offset 0 is
3053       // mapped at all.
3054       if (p->is_merge_section_for(object, shndx))
3055         {
3056           *paddr = addr;
3057           return true;
3058         }
3059
3060       addr += p->data_size();
3061     }
3062
3063   // We couldn't find a merge output section for this input section.
3064   return false;
3065 }
3066
3067 // Update the data size of an Output_section.
3068
3069 void
3070 Output_section::update_data_size()
3071 {
3072   if (this->input_sections_.empty())
3073       return;
3074
3075   if (this->must_sort_attached_input_sections()
3076       || this->input_section_order_specified())
3077     this->sort_attached_input_sections();
3078
3079   off_t off = this->first_input_offset_;
3080   for (Input_section_list::iterator p = this->input_sections_.begin();
3081        p != this->input_sections_.end();
3082        ++p)
3083     {
3084       off = align_address(off, p->addralign());
3085       off += p->current_data_size();
3086     }
3087
3088   this->set_current_data_size_for_child(off);
3089 }
3090
3091 // Set the data size of an Output_section.  This is where we handle
3092 // setting the addresses of any Output_section_data objects.
3093
3094 void
3095 Output_section::set_final_data_size()
3096 {
3097   off_t data_size;
3098
3099   if (this->input_sections_.empty())
3100     data_size = this->current_data_size_for_child();
3101   else
3102     {
3103       if (this->must_sort_attached_input_sections()
3104           || this->input_section_order_specified())
3105         this->sort_attached_input_sections();
3106
3107       uint64_t address = this->address();
3108       off_t startoff = this->offset();
3109       off_t off = startoff + this->first_input_offset_;
3110       for (Input_section_list::iterator p = this->input_sections_.begin();
3111            p != this->input_sections_.end();
3112            ++p)
3113         {
3114           off = align_address(off, p->addralign());
3115           p->set_address_and_file_offset(address + (off - startoff), off,
3116                                          startoff);
3117           off += p->data_size();
3118         }
3119       data_size = off - startoff;
3120     }
3121
3122   // For full incremental links, we want to allocate some patch space
3123   // in most sections for subsequent incremental updates.
3124   if (this->is_patch_space_allowed_ && parameters->incremental_full())
3125     {
3126       double pct = parameters->options().incremental_patch();
3127       size_t extra = static_cast<size_t>(data_size * pct);
3128       if (this->free_space_fill_ != NULL
3129           && this->free_space_fill_->minimum_hole_size() > extra)
3130         extra = this->free_space_fill_->minimum_hole_size();
3131       off_t new_size = align_address(data_size + extra, this->addralign());
3132       this->patch_space_ = new_size - data_size;
3133       gold_debug(DEBUG_INCREMENTAL,
3134                  "set_final_data_size: %08lx + %08lx: section %s",
3135                  static_cast<long>(data_size),
3136                  static_cast<long>(this->patch_space_),
3137                  this->name());
3138       data_size = new_size;
3139     }
3140
3141   this->set_data_size(data_size);
3142 }
3143
3144 // Reset the address and file offset.
3145
3146 void
3147 Output_section::do_reset_address_and_file_offset()
3148 {
3149   // An unallocated section has no address.  Forcing this means that
3150   // we don't need special treatment for symbols defined in debug
3151   // sections.  We do the same in the constructor.  This does not
3152   // apply to NOLOAD sections though.
3153   if (((this->flags_ & elfcpp::SHF_ALLOC) == 0) && !this->is_noload_)
3154      this->set_address(0);
3155
3156   for (Input_section_list::iterator p = this->input_sections_.begin();
3157        p != this->input_sections_.end();
3158        ++p)
3159     p->reset_address_and_file_offset();
3160
3161   // Remove any patch space that was added in set_final_data_size.
3162   if (this->patch_space_ > 0)
3163     {
3164       this->set_current_data_size_for_child(this->current_data_size_for_child()
3165                                             - this->patch_space_);
3166       this->patch_space_ = 0;
3167     }
3168 }
3169
3170 // Return true if address and file offset have the values after reset.
3171
3172 bool
3173 Output_section::do_address_and_file_offset_have_reset_values() const
3174 {
3175   if (this->is_offset_valid())
3176     return false;
3177
3178   // An unallocated section has address 0 after its construction or a reset.
3179   if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
3180     return this->is_address_valid() && this->address() == 0;
3181   else
3182     return !this->is_address_valid();
3183 }
3184
3185 // Set the TLS offset.  Called only for SHT_TLS sections.
3186
3187 void
3188 Output_section::do_set_tls_offset(uint64_t tls_base)
3189 {
3190   this->tls_offset_ = this->address() - tls_base;
3191 }
3192
3193 // In a few cases we need to sort the input sections attached to an
3194 // output section.  This is used to implement the type of constructor
3195 // priority ordering implemented by the GNU linker, in which the
3196 // priority becomes part of the section name and the sections are
3197 // sorted by name.  We only do this for an output section if we see an
3198 // attached input section matching ".ctors.*", ".dtors.*",
3199 // ".init_array.*" or ".fini_array.*".
3200
3201 class Output_section::Input_section_sort_entry
3202 {
3203  public:
3204   Input_section_sort_entry()
3205     : input_section_(), index_(-1U), section_has_name_(false),
3206       section_name_()
3207   { }
3208
3209   Input_section_sort_entry(const Input_section& input_section,
3210                            unsigned int index,
3211                            bool must_sort_attached_input_sections)
3212     : input_section_(input_section), index_(index),
3213       section_has_name_(input_section.is_input_section()
3214                         || input_section.is_relaxed_input_section())
3215   {
3216     if (this->section_has_name_
3217         && must_sort_attached_input_sections)
3218       {
3219         // This is only called single-threaded from Layout::finalize,
3220         // so it is OK to lock.  Unfortunately we have no way to pass
3221         // in a Task token.
3222         const Task* dummy_task = reinterpret_cast<const Task*>(-1);
3223         Object* obj = (input_section.is_input_section()
3224                        ? input_section.relobj()
3225                        : input_section.relaxed_input_section()->relobj());
3226         Task_lock_obj<Object> tl(dummy_task, obj);
3227
3228         // This is a slow operation, which should be cached in
3229         // Layout::layout if this becomes a speed problem.
3230         this->section_name_ = obj->section_name(input_section.shndx());
3231       }
3232   }
3233
3234   // Return the Input_section.
3235   const Input_section&
3236   input_section() const
3237   {
3238     gold_assert(this->index_ != -1U);
3239     return this->input_section_;
3240   }
3241
3242   // The index of this entry in the original list.  This is used to
3243   // make the sort stable.
3244   unsigned int
3245   index() const
3246   {
3247     gold_assert(this->index_ != -1U);
3248     return this->index_;
3249   }
3250
3251   // Whether there is a section name.
3252   bool
3253   section_has_name() const
3254   { return this->section_has_name_; }
3255
3256   // The section name.
3257   const std::string&
3258   section_name() const
3259   {
3260     gold_assert(this->section_has_name_);
3261     return this->section_name_;
3262   }
3263
3264   // Return true if the section name has a priority.  This is assumed
3265   // to be true if it has a dot after the initial dot.
3266   bool
3267   has_priority() const
3268   {
3269     gold_assert(this->section_has_name_);
3270     return this->section_name_.find('.', 1) != std::string::npos;
3271   }
3272
3273   // Return the priority.  Believe it or not, gcc encodes the priority
3274   // differently for .ctors/.dtors and .init_array/.fini_array
3275   // sections.
3276   unsigned int
3277   get_priority() const
3278   {
3279     gold_assert(this->section_has_name_);
3280     bool is_ctors;
3281     if (is_prefix_of(".ctors.", this->section_name_.c_str())
3282         || is_prefix_of(".dtors.", this->section_name_.c_str()))
3283       is_ctors = true;
3284     else if (is_prefix_of(".init_array.", this->section_name_.c_str())
3285              || is_prefix_of(".fini_array.", this->section_name_.c_str()))
3286       is_ctors = false;
3287     else
3288       return 0;
3289     char* end;
3290     unsigned long prio = strtoul((this->section_name_.c_str()
3291                                   + (is_ctors ? 7 : 12)),
3292                                  &end, 10);
3293     if (*end != '\0')
3294       return 0;
3295     else if (is_ctors)
3296       return 65535 - prio;
3297     else
3298       return prio;
3299   }
3300
3301   // Return true if this an input file whose base name matches
3302   // FILE_NAME.  The base name must have an extension of ".o", and
3303   // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
3304   // This is to match crtbegin.o as well as crtbeginS.o without
3305   // getting confused by other possibilities.  Overall matching the
3306   // file name this way is a dreadful hack, but the GNU linker does it
3307   // in order to better support gcc, and we need to be compatible.
3308   bool
3309   match_file_name(const char* file_name) const
3310   {
3311     if (this->input_section_.is_output_section_data())
3312       return false;
3313     return Layout::match_file_name(this->input_section_.relobj(), file_name);
3314   }
3315
3316   // Returns 1 if THIS should appear before S in section order, -1 if S
3317   // appears before THIS and 0 if they are not comparable.
3318   int
3319   compare_section_ordering(const Input_section_sort_entry& s) const
3320   {
3321     unsigned int this_secn_index = this->input_section_.section_order_index();
3322     unsigned int s_secn_index = s.input_section().section_order_index();
3323     if (this_secn_index > 0 && s_secn_index > 0)
3324       {
3325         if (this_secn_index < s_secn_index)
3326           return 1;
3327         else if (this_secn_index > s_secn_index)
3328           return -1;
3329       }
3330     return 0;
3331   }
3332
3333  private:
3334   // The Input_section we are sorting.
3335   Input_section input_section_;
3336   // The index of this Input_section in the original list.
3337   unsigned int index_;
3338   // Whether this Input_section has a section name--it won't if this
3339   // is some random Output_section_data.
3340   bool section_has_name_;
3341   // The section name if there is one.
3342   std::string section_name_;
3343 };
3344
3345 // Return true if S1 should come before S2 in the output section.
3346
3347 bool
3348 Output_section::Input_section_sort_compare::operator()(
3349     const Output_section::Input_section_sort_entry& s1,
3350     const Output_section::Input_section_sort_entry& s2) const
3351 {
3352   // crtbegin.o must come first.
3353   bool s1_begin = s1.match_file_name("crtbegin");
3354   bool s2_begin = s2.match_file_name("crtbegin");
3355   if (s1_begin || s2_begin)
3356     {
3357       if (!s1_begin)
3358         return false;
3359       if (!s2_begin)
3360         return true;
3361       return s1.index() < s2.index();
3362     }
3363
3364   // crtend.o must come last.
3365   bool s1_end = s1.match_file_name("crtend");
3366   bool s2_end = s2.match_file_name("crtend");
3367   if (s1_end || s2_end)
3368     {
3369       if (!s1_end)
3370         return true;
3371       if (!s2_end)
3372         return false;
3373       return s1.index() < s2.index();
3374     }
3375
3376   // We sort all the sections with no names to the end.
3377   if (!s1.section_has_name() || !s2.section_has_name())
3378     {
3379       if (s1.section_has_name())
3380         return true;
3381       if (s2.section_has_name())
3382         return false;
3383       return s1.index() < s2.index();
3384     }
3385
3386   // A section with a priority follows a section without a priority.
3387   bool s1_has_priority = s1.has_priority();
3388   bool s2_has_priority = s2.has_priority();
3389   if (s1_has_priority && !s2_has_priority)
3390     return false;
3391   if (!s1_has_priority && s2_has_priority)
3392     return true;
3393
3394   // Check if a section order exists for these sections through a section
3395   // ordering file.  If sequence_num is 0, an order does not exist.
3396   int sequence_num = s1.compare_section_ordering(s2);
3397   if (sequence_num != 0)
3398     return sequence_num == 1;
3399
3400   // Otherwise we sort by name.
3401   int compare = s1.section_name().compare(s2.section_name());
3402   if (compare != 0)
3403     return compare < 0;
3404
3405   // Otherwise we keep the input order.
3406   return s1.index() < s2.index();
3407 }
3408
3409 // Return true if S1 should come before S2 in an .init_array or .fini_array
3410 // output section.
3411
3412 bool
3413 Output_section::Input_section_sort_init_fini_compare::operator()(
3414     const Output_section::Input_section_sort_entry& s1,
3415     const Output_section::Input_section_sort_entry& s2) const
3416 {
3417   // We sort all the sections with no names to the end.
3418   if (!s1.section_has_name() || !s2.section_has_name())
3419     {
3420       if (s1.section_has_name())
3421         return true;
3422       if (s2.section_has_name())
3423         return false;
3424       return s1.index() < s2.index();
3425     }
3426
3427   // A section without a priority follows a section with a priority.
3428   // This is the reverse of .ctors and .dtors sections.
3429   bool s1_has_priority = s1.has_priority();
3430   bool s2_has_priority = s2.has_priority();
3431   if (s1_has_priority && !s2_has_priority)
3432     return true;
3433   if (!s1_has_priority && s2_has_priority)
3434     return false;
3435
3436   // .ctors and .dtors sections without priority come after
3437   // .init_array and .fini_array sections without priority.
3438   if (!s1_has_priority
3439       && (s1.section_name() == ".ctors" || s1.section_name() == ".dtors")
3440       && s1.section_name() != s2.section_name())
3441     return false;
3442   if (!s2_has_priority
3443       && (s2.section_name() == ".ctors" || s2.section_name() == ".dtors")
3444       && s2.section_name() != s1.section_name())
3445     return true;
3446
3447   // Sort by priority if we can.
3448   if (s1_has_priority)
3449     {
3450       unsigned int s1_prio = s1.get_priority();
3451       unsigned int s2_prio = s2.get_priority();
3452       if (s1_prio < s2_prio)
3453         return true;
3454       else if (s1_prio > s2_prio)
3455         return false;
3456     }
3457
3458   // Check if a section order exists for these sections through a section
3459   // ordering file.  If sequence_num is 0, an order does not exist.
3460   int sequence_num = s1.compare_section_ordering(s2);
3461   if (sequence_num != 0)
3462     return sequence_num == 1;
3463
3464   // Otherwise we sort by name.
3465   int compare = s1.section_name().compare(s2.section_name());
3466   if (compare != 0)
3467     return compare < 0;
3468
3469   // Otherwise we keep the input order.
3470   return s1.index() < s2.index();
3471 }
3472
3473 // Return true if S1 should come before S2.  Sections that do not match
3474 // any pattern in the section ordering file are placed ahead of the sections
3475 // that match some pattern.
3476
3477 bool
3478 Output_section::Input_section_sort_section_order_index_compare::operator()(
3479     const Output_section::Input_section_sort_entry& s1,
3480     const Output_section::Input_section_sort_entry& s2) const
3481 {
3482   unsigned int s1_secn_index = s1.input_section().section_order_index();
3483   unsigned int s2_secn_index = s2.input_section().section_order_index();
3484
3485   // Keep input order if section ordering cannot determine order.
3486   if (s1_secn_index == s2_secn_index)
3487     return s1.index() < s2.index();
3488
3489   return s1_secn_index < s2_secn_index;
3490 }
3491
3492 // Return true if S1 should come before S2.  This is the sort comparison
3493 // function for .text to sort sections with prefixes
3494 // .text.{unlikely,exit,startup,hot} before other sections.
3495
3496 bool
3497 Output_section::Input_section_sort_section_prefix_special_ordering_compare
3498   ::operator()(
3499     const Output_section::Input_section_sort_entry& s1,
3500     const Output_section::Input_section_sort_entry& s2) const
3501 {
3502   // We sort all the sections with no names to the end.
3503   if (!s1.section_has_name() || !s2.section_has_name())
3504     {
3505       if (s1.section_has_name())
3506         return true;
3507       if (s2.section_has_name())
3508         return false;
3509       return s1.index() < s2.index();
3510     }
3511
3512   // Some input section names have special ordering requirements.
3513   int o1 = Layout::special_ordering_of_input_section(s1.section_name().c_str());
3514   int o2 = Layout::special_ordering_of_input_section(s2.section_name().c_str());
3515   if (o1 != o2)
3516     {
3517       if (o1 < 0)
3518         return false;
3519       else if (o2 < 0)
3520         return true;
3521       else
3522         return o1 < o2;
3523     }
3524
3525   // Keep input order otherwise.
3526   return s1.index() < s2.index();
3527 }
3528
3529 // Return true if S1 should come before S2.  This is the sort comparison
3530 // function for sections to sort them by name.
3531
3532 bool
3533 Output_section::Input_section_sort_section_name_compare
3534   ::operator()(
3535     const Output_section::Input_section_sort_entry& s1,
3536     const Output_section::Input_section_sort_entry& s2) const
3537 {
3538   // We sort all the sections with no names to the end.
3539   if (!s1.section_has_name() || !s2.section_has_name())
3540     {
3541       if (s1.section_has_name())
3542         return true;
3543       if (s2.section_has_name())
3544         return false;
3545       return s1.index() < s2.index();
3546     }
3547
3548   // We sort by name.
3549   int compare = s1.section_name().compare(s2.section_name());
3550   if (compare != 0)
3551     return compare < 0;
3552
3553   // Keep input order otherwise.
3554   return s1.index() < s2.index();
3555 }
3556
3557 // This updates the section order index of input sections according to the
3558 // the order specified in the mapping from Section id to order index.
3559
3560 void
3561 Output_section::update_section_layout(
3562   const Section_layout_order* order_map)
3563 {
3564   for (Input_section_list::iterator p = this->input_sections_.begin();
3565        p != this->input_sections_.end();
3566        ++p)
3567     {
3568       if (p->is_input_section()
3569           || p->is_relaxed_input_section())
3570         {
3571           Object* obj = (p->is_input_section()
3572                          ? p->relobj()
3573                          : p->relaxed_input_section()->relobj());
3574           unsigned int shndx = p->shndx();
3575           Section_layout_order::const_iterator it
3576             = order_map->find(Section_id(obj, shndx));
3577           if (it == order_map->end())
3578             continue;
3579           unsigned int section_order_index = it->second;
3580           if (section_order_index != 0)
3581             {
3582               p->set_section_order_index(section_order_index);
3583               this->set_input_section_order_specified();
3584             }
3585         }
3586     }
3587 }
3588
3589 // Sort the input sections attached to an output section.
3590
3591 void
3592 Output_section::sort_attached_input_sections()
3593 {
3594   if (this->attached_input_sections_are_sorted_)
3595     return;
3596
3597   if (this->checkpoint_ != NULL
3598       && !this->checkpoint_->input_sections_saved())
3599     this->checkpoint_->save_input_sections();
3600
3601   // The only thing we know about an input section is the object and
3602   // the section index.  We need the section name.  Recomputing this
3603   // is slow but this is an unusual case.  If this becomes a speed
3604   // problem we can cache the names as required in Layout::layout.
3605
3606   // We start by building a larger vector holding a copy of each
3607   // Input_section, plus its current index in the list and its name.
3608   std::vector<Input_section_sort_entry> sort_list;
3609
3610   unsigned int i = 0;
3611   for (Input_section_list::iterator p = this->input_sections_.begin();
3612        p != this->input_sections_.end();
3613        ++p, ++i)
3614       sort_list.push_back(Input_section_sort_entry(*p, i,
3615                             this->must_sort_attached_input_sections()));
3616
3617   // Sort the input sections.
3618   if (this->must_sort_attached_input_sections())
3619     {
3620       if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3621           || this->type() == elfcpp::SHT_INIT_ARRAY
3622           || this->type() == elfcpp::SHT_FINI_ARRAY)
3623         std::sort(sort_list.begin(), sort_list.end(),
3624                   Input_section_sort_init_fini_compare());
3625       else if (strcmp(parameters->options().sort_section(), "name") == 0)
3626         std::sort(sort_list.begin(), sort_list.end(),
3627                   Input_section_sort_section_name_compare());
3628       else if (strcmp(this->name(), ".text") == 0)
3629         std::sort(sort_list.begin(), sort_list.end(),
3630                   Input_section_sort_section_prefix_special_ordering_compare());
3631       else
3632         std::sort(sort_list.begin(), sort_list.end(),
3633                   Input_section_sort_compare());
3634     }
3635   else
3636     {
3637       gold_assert(this->input_section_order_specified());
3638       std::sort(sort_list.begin(), sort_list.end(),
3639                 Input_section_sort_section_order_index_compare());
3640     }
3641
3642   // Copy the sorted input sections back to our list.
3643   this->input_sections_.clear();
3644   for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin();
3645        p != sort_list.end();
3646        ++p)
3647     this->input_sections_.push_back(p->input_section());
3648   sort_list.clear();
3649
3650   // Remember that we sorted the input sections, since we might get
3651   // called again.
3652   this->attached_input_sections_are_sorted_ = true;
3653 }
3654
3655 // Write the section header to *OSHDR.
3656
3657 template<int size, bool big_endian>
3658 void
3659 Output_section::write_header(const Layout* layout,
3660                              const Stringpool* secnamepool,
3661                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
3662 {
3663   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
3664   oshdr->put_sh_type(this->type_);
3665
3666   elfcpp::Elf_Xword flags = this->flags_;
3667   if (this->info_section_ != NULL && this->info_uses_section_index_)
3668     flags |= elfcpp::SHF_INFO_LINK;
3669   oshdr->put_sh_flags(flags);
3670
3671   oshdr->put_sh_addr(this->address());
3672   oshdr->put_sh_offset(this->offset());
3673   oshdr->put_sh_size(this->data_size());
3674   if (this->link_section_ != NULL)
3675     oshdr->put_sh_link(this->link_section_->out_shndx());
3676   else if (this->should_link_to_symtab_)
3677     oshdr->put_sh_link(layout->symtab_section_shndx());
3678   else if (this->should_link_to_dynsym_)
3679     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
3680   else
3681     oshdr->put_sh_link(this->link_);
3682
3683   elfcpp::Elf_Word info;
3684   if (this->info_section_ != NULL)
3685     {
3686       if (this->info_uses_section_index_)
3687         info = this->info_section_->out_shndx();
3688       else
3689         info = this->info_section_->symtab_index();
3690     }
3691   else if (this->info_symndx_ != NULL)
3692     info = this->info_symndx_->symtab_index();
3693   else
3694     info = this->info_;
3695   oshdr->put_sh_info(info);
3696
3697   oshdr->put_sh_addralign(this->addralign_);
3698   oshdr->put_sh_entsize(this->entsize_);
3699 }
3700
3701 // Write out the data.  For input sections the data is written out by
3702 // Object::relocate, but we have to handle Output_section_data objects
3703 // here.
3704
3705 void
3706 Output_section::do_write(Output_file* of)
3707 {
3708   gold_assert(!this->requires_postprocessing());
3709
3710   // If the target performs relaxation, we delay filler generation until now.
3711   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3712
3713   off_t output_section_file_offset = this->offset();
3714   for (Fill_list::iterator p = this->fills_.begin();
3715        p != this->fills_.end();
3716        ++p)
3717     {
3718       std::string fill_data(parameters->target().code_fill(p->length()));
3719       of->write(output_section_file_offset + p->section_offset(),
3720                 fill_data.data(), fill_data.size());
3721     }
3722
3723   off_t off = this->offset() + this->first_input_offset_;
3724   for (Input_section_list::iterator p = this->input_sections_.begin();
3725        p != this->input_sections_.end();
3726        ++p)
3727     {
3728       off_t aligned_off = align_address(off, p->addralign());
3729       if (this->generate_code_fills_at_write_ && (off != aligned_off))
3730         {
3731           size_t fill_len = aligned_off - off;
3732           std::string fill_data(parameters->target().code_fill(fill_len));
3733           of->write(off, fill_data.data(), fill_data.size());
3734         }
3735
3736       p->write(of);
3737       off = aligned_off + p->data_size();
3738     }
3739
3740   // For incremental links, fill in unused chunks in debug sections
3741   // with dummy compilation unit headers.
3742   if (this->free_space_fill_ != NULL)
3743     {
3744       for (Free_list::Const_iterator p = this->free_list_.begin();
3745            p != this->free_list_.end();
3746            ++p)
3747         {
3748           off_t off = p->start_;
3749           size_t len = p->end_ - off;
3750           this->free_space_fill_->write(of, this->offset() + off, len);
3751         }
3752       if (this->patch_space_ > 0)
3753         {
3754           off_t off = this->current_data_size_for_child() - this->patch_space_;
3755           this->free_space_fill_->write(of, this->offset() + off,
3756                                         this->patch_space_);
3757         }
3758     }
3759 }
3760
3761 // If a section requires postprocessing, create the buffer to use.
3762
3763 void
3764 Output_section::create_postprocessing_buffer()
3765 {
3766   gold_assert(this->requires_postprocessing());
3767
3768   if (this->postprocessing_buffer_ != NULL)
3769     return;
3770
3771   if (!this->input_sections_.empty())
3772     {
3773       off_t off = this->first_input_offset_;
3774       for (Input_section_list::iterator p = this->input_sections_.begin();
3775            p != this->input_sections_.end();
3776            ++p)
3777         {
3778           off = align_address(off, p->addralign());
3779           p->finalize_data_size();
3780           off += p->data_size();
3781         }
3782       this->set_current_data_size_for_child(off);
3783     }
3784
3785   off_t buffer_size = this->current_data_size_for_child();
3786   this->postprocessing_buffer_ = new unsigned char[buffer_size];
3787 }
3788
3789 // Write all the data of an Output_section into the postprocessing
3790 // buffer.  This is used for sections which require postprocessing,
3791 // such as compression.  Input sections are handled by
3792 // Object::Relocate.
3793
3794 void
3795 Output_section::write_to_postprocessing_buffer()
3796 {
3797   gold_assert(this->requires_postprocessing());
3798
3799   // If the target performs relaxation, we delay filler generation until now.
3800   gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3801
3802   unsigned char* buffer = this->postprocessing_buffer();
3803   for (Fill_list::iterator p = this->fills_.begin();
3804        p != this->fills_.end();
3805        ++p)
3806     {
3807       std::string fill_data(parameters->target().code_fill(p->length()));
3808       memcpy(buffer + p->section_offset(), fill_data.data(),
3809              fill_data.size());
3810     }
3811
3812   off_t off = this->first_input_offset_;
3813   for (Input_section_list::iterator p = this->input_sections_.begin();
3814        p != this->input_sections_.end();
3815        ++p)
3816     {
3817       off_t aligned_off = align_address(off, p->addralign());
3818       if (this->generate_code_fills_at_write_ && (off != aligned_off))
3819         {
3820           size_t fill_len = aligned_off - off;
3821           std::string fill_data(parameters->target().code_fill(fill_len));
3822           memcpy(buffer + off, fill_data.data(), fill_data.size());
3823         }
3824
3825       p->write_to_buffer(buffer + aligned_off);
3826       off = aligned_off + p->data_size();
3827     }
3828 }
3829
3830 // Get the input sections for linker script processing.  We leave
3831 // behind the Output_section_data entries.  Note that this may be
3832 // slightly incorrect for merge sections.  We will leave them behind,
3833 // but it is possible that the script says that they should follow
3834 // some other input sections, as in:
3835 //    .rodata { *(.rodata) *(.rodata.cst*) }
3836 // For that matter, we don't handle this correctly:
3837 //    .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3838 // With luck this will never matter.
3839
3840 uint64_t
3841 Output_section::get_input_sections(
3842     uint64_t address,
3843     const std::string& fill,
3844     std::list<Input_section>* input_sections)
3845 {
3846   if (this->checkpoint_ != NULL
3847       && !this->checkpoint_->input_sections_saved())
3848     this->checkpoint_->save_input_sections();
3849
3850   // Invalidate fast look-up maps.
3851   this->lookup_maps_->invalidate();
3852
3853   uint64_t orig_address = address;
3854
3855   address = align_address(address, this->addralign());
3856
3857   Input_section_list remaining;
3858   for (Input_section_list::iterator p = this->input_sections_.begin();
3859        p != this->input_sections_.end();
3860        ++p)
3861     {
3862       if (p->is_input_section()
3863           || p->is_relaxed_input_section()
3864           || p->is_merge_section())
3865         input_sections->push_back(*p);
3866       else
3867         {
3868           uint64_t aligned_address = align_address(address, p->addralign());
3869           if (aligned_address != address && !fill.empty())
3870             {
3871               section_size_type length =
3872                 convert_to_section_size_type(aligned_address - address);
3873               std::string this_fill;
3874               this_fill.reserve(length);
3875               while (this_fill.length() + fill.length() <= length)
3876                 this_fill += fill;
3877               if (this_fill.length() < length)
3878                 this_fill.append(fill, 0, length - this_fill.length());
3879
3880               Output_section_data* posd = new Output_data_const(this_fill, 0);
3881               remaining.push_back(Input_section(posd));
3882             }
3883           address = aligned_address;
3884
3885           remaining.push_back(*p);
3886
3887           p->finalize_data_size();
3888           address += p->data_size();
3889         }
3890     }
3891
3892   this->input_sections_.swap(remaining);
3893   this->first_input_offset_ = 0;
3894
3895   uint64_t data_size = address - orig_address;
3896   this->set_current_data_size_for_child(data_size);
3897   return data_size;
3898 }
3899
3900 // Add a script input section.  SIS is an Output_section::Input_section,
3901 // which can be either a plain input section or a special input section like
3902 // a relaxed input section.  For a special input section, its size must be
3903 // finalized.
3904
3905 void
3906 Output_section::add_script_input_section(const Input_section& sis)
3907 {
3908   uint64_t data_size = sis.data_size();
3909   uint64_t addralign = sis.addralign();
3910   if (addralign > this->addralign_)
3911     this->addralign_ = addralign;
3912
3913   off_t offset_in_section = this->current_data_size_for_child();
3914   off_t aligned_offset_in_section = align_address(offset_in_section,
3915                                                   addralign);
3916
3917   this->set_current_data_size_for_child(aligned_offset_in_section
3918                                         + data_size);
3919
3920   this->input_sections_.push_back(sis);
3921
3922   // Update fast lookup maps if necessary.
3923   if (this->lookup_maps_->is_valid())
3924     {
3925       if (sis.is_merge_section())
3926         {
3927           Output_merge_base* pomb = sis.output_merge_base();
3928           Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
3929                                        pomb->addralign());
3930           this->lookup_maps_->add_merge_section(msp, pomb);
3931           for (Output_merge_base::Input_sections::const_iterator p =
3932                  pomb->input_sections_begin();
3933                p != pomb->input_sections_end();
3934                ++p)
3935             this->lookup_maps_->add_merge_input_section(p->first, p->second,
3936                                                         pomb);
3937         }
3938       else if (sis.is_relaxed_input_section())
3939         {
3940           Output_relaxed_input_section* poris = sis.relaxed_input_section();
3941           this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
3942                                                         poris->shndx(), poris);
3943         }
3944     }
3945 }
3946
3947 // Save states for relaxation.
3948
3949 void
3950 Output_section::save_states()
3951 {
3952   gold_assert(this->checkpoint_ == NULL);
3953   Checkpoint_output_section* checkpoint =
3954     new Checkpoint_output_section(this->addralign_, this->flags_,
3955                                   this->input_sections_,
3956                                   this->first_input_offset_,
3957                                   this->attached_input_sections_are_sorted_);
3958   this->checkpoint_ = checkpoint;
3959   gold_assert(this->fills_.empty());
3960 }
3961
3962 void
3963 Output_section::discard_states()
3964 {
3965   gold_assert(this->checkpoint_ != NULL);
3966   delete this->checkpoint_;
3967   this->checkpoint_ = NULL;
3968   gold_assert(this->fills_.empty());
3969
3970   // Simply invalidate the fast lookup maps since we do not keep
3971   // track of them.
3972   this->lookup_maps_->invalidate();
3973 }
3974
3975 void
3976 Output_section::restore_states()
3977 {
3978   gold_assert(this->checkpoint_ != NULL);
3979   Checkpoint_output_section* checkpoint = this->checkpoint_;
3980
3981   this->addralign_ = checkpoint->addralign();
3982   this->flags_ = checkpoint->flags();
3983   this->first_input_offset_ = checkpoint->first_input_offset();
3984
3985   if (!checkpoint->input_sections_saved())
3986     {
3987       // If we have not copied the input sections, just resize it.
3988       size_t old_size = checkpoint->input_sections_size();
3989       gold_assert(this->input_sections_.size() >= old_size);
3990       this->input_sections_.resize(old_size);
3991     }
3992   else
3993     {
3994       // We need to copy the whole list.  This is not efficient for
3995       // extremely large output with hundreads of thousands of input
3996       // objects.  We may need to re-think how we should pass sections
3997       // to scripts.
3998       this->input_sections_ = *checkpoint->input_sections();
3999     }
4000
4001   this->attached_input_sections_are_sorted_ =
4002     checkpoint->attached_input_sections_are_sorted();
4003
4004   // Simply invalidate the fast lookup maps since we do not keep
4005   // track of them.
4006   this->lookup_maps_->invalidate();
4007 }
4008
4009 // Update the section offsets of input sections in this.  This is required if
4010 // relaxation causes some input sections to change sizes.
4011
4012 void
4013 Output_section::adjust_section_offsets()
4014 {
4015   if (!this->section_offsets_need_adjustment_)
4016     return;
4017
4018   off_t off = 0;
4019   for (Input_section_list::iterator p = this->input_sections_.begin();
4020        p != this->input_sections_.end();
4021        ++p)
4022     {
4023       off = align_address(off, p->addralign());
4024       if (p->is_input_section())
4025         p->relobj()->set_section_offset(p->shndx(), off);
4026       off += p->data_size();
4027     }
4028
4029   this->section_offsets_need_adjustment_ = false;
4030 }
4031
4032 // Print to the map file.
4033
4034 void
4035 Output_section::do_print_to_mapfile(Mapfile* mapfile) const
4036 {
4037   mapfile->print_output_section(this);
4038
4039   for (Input_section_list::const_iterator p = this->input_sections_.begin();
4040        p != this->input_sections_.end();
4041        ++p)
4042     p->print_to_mapfile(mapfile);
4043 }
4044
4045 // Print stats for merge sections to stderr.
4046
4047 void
4048 Output_section::print_merge_stats()
4049 {
4050   Input_section_list::iterator p;
4051   for (p = this->input_sections_.begin();
4052        p != this->input_sections_.end();
4053        ++p)
4054     p->print_merge_stats(this->name_);
4055 }
4056
4057 // Set a fixed layout for the section.  Used for incremental update links.
4058
4059 void
4060 Output_section::set_fixed_layout(uint64_t sh_addr, off_t sh_offset,
4061                                  off_t sh_size, uint64_t sh_addralign)
4062 {
4063   this->addralign_ = sh_addralign;
4064   this->set_current_data_size(sh_size);
4065   if ((this->flags_ & elfcpp::SHF_ALLOC) != 0)
4066     this->set_address(sh_addr);
4067   this->set_file_offset(sh_offset);
4068   this->finalize_data_size();
4069   this->free_list_.init(sh_size, false);
4070   this->has_fixed_layout_ = true;
4071 }
4072
4073 // Reserve space within the fixed layout for the section.  Used for
4074 // incremental update links.
4075
4076 void
4077 Output_section::reserve(uint64_t sh_offset, uint64_t sh_size)
4078 {
4079   this->free_list_.remove(sh_offset, sh_offset + sh_size);
4080 }
4081
4082 // Allocate space from the free list for the section.  Used for
4083 // incremental update links.
4084
4085 off_t
4086 Output_section::allocate(off_t len, uint64_t addralign)
4087 {
4088   return this->free_list_.allocate(len, addralign, 0);
4089 }
4090
4091 // Output segment methods.
4092
4093 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
4094   : vaddr_(0),
4095     paddr_(0),
4096     memsz_(0),
4097     max_align_(0),
4098     min_p_align_(0),
4099     offset_(0),
4100     filesz_(0),
4101     type_(type),
4102     flags_(flags),
4103     is_max_align_known_(false),
4104     are_addresses_set_(false),
4105     is_large_data_segment_(false),
4106     is_unique_segment_(false)
4107 {
4108   // The ELF ABI specifies that a PT_TLS segment always has PF_R as
4109   // the flags.
4110   if (type == elfcpp::PT_TLS)
4111     this->flags_ = elfcpp::PF_R;
4112 }
4113
4114 // Add an Output_section to a PT_LOAD Output_segment.
4115
4116 void
4117 Output_segment::add_output_section_to_load(Layout* layout,
4118                                            Output_section* os,
4119                                            elfcpp::Elf_Word seg_flags)
4120 {
4121   gold_assert(this->type() == elfcpp::PT_LOAD);
4122   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4123   gold_assert(!this->is_max_align_known_);
4124   gold_assert(os->is_large_data_section() == this->is_large_data_segment());
4125
4126   this->update_flags_for_output_section(seg_flags);
4127
4128   // We don't want to change the ordering if we have a linker script
4129   // with a SECTIONS clause.
4130   Output_section_order order = os->order();
4131   if (layout->script_options()->saw_sections_clause())
4132     order = static_cast<Output_section_order>(0);
4133   else
4134     gold_assert(order != ORDER_INVALID);
4135
4136   this->output_lists_[order].push_back(os);
4137 }
4138
4139 // Add an Output_section to a non-PT_LOAD Output_segment.
4140
4141 void
4142 Output_segment::add_output_section_to_nonload(Output_section* os,
4143                                               elfcpp::Elf_Word seg_flags)
4144 {
4145   gold_assert(this->type() != elfcpp::PT_LOAD);
4146   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4147   gold_assert(!this->is_max_align_known_);
4148
4149   this->update_flags_for_output_section(seg_flags);
4150
4151   this->output_lists_[0].push_back(os);
4152 }
4153
4154 // Remove an Output_section from this segment.  It is an error if it
4155 // is not present.
4156
4157 void
4158 Output_segment::remove_output_section(Output_section* os)
4159 {
4160   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4161     {
4162       Output_data_list* pdl = &this->output_lists_[i];
4163       for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p)
4164         {
4165           if (*p == os)
4166             {
4167               pdl->erase(p);
4168               return;
4169             }
4170         }
4171     }
4172   gold_unreachable();
4173 }
4174
4175 // Add an Output_data (which need not be an Output_section) to the
4176 // start of a segment.
4177
4178 void
4179 Output_segment::add_initial_output_data(Output_data* od)
4180 {
4181   gold_assert(!this->is_max_align_known_);
4182   Output_data_list::iterator p = this->output_lists_[0].begin();
4183   this->output_lists_[0].insert(p, od);
4184 }
4185
4186 // Return true if this segment has any sections which hold actual
4187 // data, rather than being a BSS section.
4188
4189 bool
4190 Output_segment::has_any_data_sections() const
4191 {
4192   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4193     {
4194       const Output_data_list* pdl = &this->output_lists_[i];
4195       for (Output_data_list::const_iterator p = pdl->begin();
4196            p != pdl->end();
4197            ++p)
4198         {
4199           if (!(*p)->is_section())
4200             return true;
4201           if ((*p)->output_section()->type() != elfcpp::SHT_NOBITS)
4202             return true;
4203         }
4204     }
4205   return false;
4206 }
4207
4208 // Return whether the first data section (not counting TLS sections)
4209 // is a relro section.
4210
4211 bool
4212 Output_segment::is_first_section_relro() const
4213 {
4214   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4215     {
4216       if (i == static_cast<int>(ORDER_TLS_DATA)
4217           || i == static_cast<int>(ORDER_TLS_BSS))
4218         continue;
4219       const Output_data_list* pdl = &this->output_lists_[i];
4220       if (!pdl->empty())
4221         {
4222           Output_data* p = pdl->front();
4223           return p->is_section() && p->output_section()->is_relro();
4224         }
4225     }
4226   return false;
4227 }
4228
4229 // Return the maximum alignment of the Output_data in Output_segment.
4230
4231 uint64_t
4232 Output_segment::maximum_alignment()
4233 {
4234   if (!this->is_max_align_known_)
4235     {
4236       for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4237         {
4238           const Output_data_list* pdl = &this->output_lists_[i];
4239           uint64_t addralign = Output_segment::maximum_alignment_list(pdl);
4240           if (addralign > this->max_align_)
4241             this->max_align_ = addralign;
4242         }
4243       this->is_max_align_known_ = true;
4244     }
4245
4246   return this->max_align_;
4247 }
4248
4249 // Return the maximum alignment of a list of Output_data.
4250
4251 uint64_t
4252 Output_segment::maximum_alignment_list(const Output_data_list* pdl)
4253 {
4254   uint64_t ret = 0;
4255   for (Output_data_list::const_iterator p = pdl->begin();
4256        p != pdl->end();
4257        ++p)
4258     {
4259       uint64_t addralign = (*p)->addralign();
4260       if (addralign > ret)
4261         ret = addralign;
4262     }
4263   return ret;
4264 }
4265
4266 // Return whether this segment has any dynamic relocs.
4267
4268 bool
4269 Output_segment::has_dynamic_reloc() const
4270 {
4271   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4272     if (this->has_dynamic_reloc_list(&this->output_lists_[i]))
4273       return true;
4274   return false;
4275 }
4276
4277 // Return whether this Output_data_list has any dynamic relocs.
4278
4279 bool
4280 Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
4281 {
4282   for (Output_data_list::const_iterator p = pdl->begin();
4283        p != pdl->end();
4284        ++p)
4285     if ((*p)->has_dynamic_reloc())
4286       return true;
4287   return false;
4288 }
4289
4290 // Set the section addresses for an Output_segment.  If RESET is true,
4291 // reset the addresses first.  ADDR is the address and *POFF is the
4292 // file offset.  Set the section indexes starting with *PSHNDX.
4293 // INCREASE_RELRO is the size of the portion of the first non-relro
4294 // section that should be included in the PT_GNU_RELRO segment.
4295 // If this segment has relro sections, and has been aligned for
4296 // that purpose, set *HAS_RELRO to TRUE.  Return the address of
4297 // the immediately following segment.  Update *HAS_RELRO, *POFF,
4298 // and *PSHNDX.
4299
4300 uint64_t
4301 Output_segment::set_section_addresses(const Target* target,
4302                                       Layout* layout, bool reset,
4303                                       uint64_t addr,
4304                                       unsigned int* increase_relro,
4305                                       bool* has_relro,
4306                                       off_t* poff,
4307                                       unsigned int* pshndx)
4308 {
4309   gold_assert(this->type_ == elfcpp::PT_LOAD);
4310
4311   uint64_t last_relro_pad = 0;
4312   off_t orig_off = *poff;
4313
4314   bool in_tls = false;
4315
4316   // If we have relro sections, we need to pad forward now so that the
4317   // relro sections plus INCREASE_RELRO end on an abi page boundary.
4318   if (parameters->options().relro()
4319       && this->is_first_section_relro()
4320       && (!this->are_addresses_set_ || reset))
4321     {
4322       uint64_t relro_size = 0;
4323       off_t off = *poff;
4324       uint64_t max_align = 0;
4325       for (int i = 0; i <= static_cast<int>(ORDER_RELRO_LAST); ++i)
4326         {
4327           Output_data_list* pdl = &this->output_lists_[i];
4328           Output_data_list::iterator p;
4329           for (p = pdl->begin(); p != pdl->end(); ++p)
4330             {
4331               if (!(*p)->is_section())
4332                 break;
4333               uint64_t align = (*p)->addralign();
4334               if (align > max_align)
4335                 max_align = align;
4336               if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
4337                 in_tls = true;
4338               else if (in_tls)
4339                 {
4340                   // Align the first non-TLS section to the alignment
4341                   // of the TLS segment.
4342                   align = max_align;
4343                   in_tls = false;
4344                 }
4345               relro_size = align_address(relro_size, align);
4346               // Ignore the size of the .tbss section.
4347               if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)
4348                   && (*p)->is_section_type(elfcpp::SHT_NOBITS))
4349                 continue;
4350               if ((*p)->is_address_valid())
4351                 relro_size += (*p)->data_size();
4352               else
4353                 {
4354                   // FIXME: This could be faster.
4355                   (*p)->set_address_and_file_offset(addr + relro_size,
4356                                                     off + relro_size);
4357                   relro_size += (*p)->data_size();
4358                   (*p)->reset_address_and_file_offset();
4359                 }
4360             }
4361           if (p != pdl->end())
4362             break;
4363         }
4364       relro_size += *increase_relro;
4365       // Pad the total relro size to a multiple of the maximum
4366       // section alignment seen.
4367       uint64_t aligned_size = align_address(relro_size, max_align);
4368       // Note the amount of padding added after the last relro section.
4369       last_relro_pad = aligned_size - relro_size;
4370       *has_relro = true;
4371
4372       uint64_t page_align = parameters->target().abi_pagesize();
4373
4374       // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
4375       uint64_t desired_align = page_align - (aligned_size % page_align);
4376       if (desired_align < *poff % page_align)
4377         *poff += page_align - *poff % page_align;
4378       *poff += desired_align - *poff % page_align;
4379       addr += *poff - orig_off;
4380       orig_off = *poff;
4381     }
4382
4383   if (!reset && this->are_addresses_set_)
4384     {
4385       gold_assert(this->paddr_ == addr);
4386       addr = this->vaddr_;
4387     }
4388   else
4389     {
4390       this->vaddr_ = addr;
4391       this->paddr_ = addr;
4392       this->are_addresses_set_ = true;
4393     }
4394
4395   in_tls = false;
4396
4397   this->offset_ = orig_off;
4398
4399   off_t off = 0;
4400   uint64_t ret;
4401   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4402     {
4403       if (i == static_cast<int>(ORDER_RELRO_LAST))
4404         {
4405           *poff += last_relro_pad;
4406           addr += last_relro_pad;
4407           if (this->output_lists_[i].empty())
4408             {
4409               // If there is nothing in the ORDER_RELRO_LAST list,
4410               // the padding will occur at the end of the relro
4411               // segment, and we need to add it to *INCREASE_RELRO.
4412               *increase_relro += last_relro_pad;
4413             }
4414         }
4415       addr = this->set_section_list_addresses(layout, reset,
4416                                               &this->output_lists_[i],
4417                                               addr, poff, pshndx, &in_tls);
4418       if (i < static_cast<int>(ORDER_SMALL_BSS))
4419         {
4420           this->filesz_ = *poff - orig_off;
4421           off = *poff;
4422         }
4423
4424       ret = addr;
4425     }
4426
4427   // If the last section was a TLS section, align upward to the
4428   // alignment of the TLS segment, so that the overall size of the TLS
4429   // segment is aligned.
4430   if (in_tls)
4431     {
4432       uint64_t segment_align = layout->tls_segment()->maximum_alignment();
4433       *poff = align_address(*poff, segment_align);
4434     }
4435
4436   this->memsz_ = *poff - orig_off;
4437
4438   // Ignore the file offset adjustments made by the BSS Output_data
4439   // objects.
4440   *poff = off;
4441
4442   // If code segments must contain only code, and this code segment is
4443   // page-aligned in the file, then fill it out to a whole page with
4444   // code fill (the tail of the segment will not be within any section).
4445   // Thus the entire code segment can be mapped from the file as whole
4446   // pages and that mapping will contain only valid instructions.
4447   if (target->isolate_execinstr() && (this->flags() & elfcpp::PF_X) != 0)
4448     {
4449       uint64_t abi_pagesize = target->abi_pagesize();
4450       if (orig_off % abi_pagesize == 0 && off % abi_pagesize != 0)
4451         {
4452           size_t fill_size = abi_pagesize - (off % abi_pagesize);
4453
4454           std::string fill_data;
4455           if (target->has_code_fill())
4456             fill_data = target->code_fill(fill_size);
4457           else
4458             fill_data.resize(fill_size); // Zero fill.
4459
4460           Output_data_const* fill = new Output_data_const(fill_data, 0);
4461           fill->set_address(this->vaddr_ + this->memsz_);
4462           fill->set_file_offset(off);
4463           layout->add_relax_output(fill);
4464
4465           off += fill_size;
4466           gold_assert(off % abi_pagesize == 0);
4467           ret += fill_size;
4468           gold_assert(ret % abi_pagesize == 0);
4469
4470           gold_assert((uint64_t) this->filesz_ == this->memsz_);
4471           this->memsz_ = this->filesz_ += fill_size;
4472
4473           *poff = off;
4474         }
4475     }
4476
4477   return ret;
4478 }
4479
4480 // Set the addresses and file offsets in a list of Output_data
4481 // structures.
4482
4483 uint64_t
4484 Output_segment::set_section_list_addresses(Layout* layout, bool reset,
4485                                            Output_data_list* pdl,
4486                                            uint64_t addr, off_t* poff,
4487                                            unsigned int* pshndx,
4488                                            bool* in_tls)
4489 {
4490   off_t startoff = *poff;
4491   // For incremental updates, we may allocate non-fixed sections from
4492   // free space in the file.  This keeps track of the high-water mark.
4493   off_t maxoff = startoff;
4494
4495   off_t off = startoff;
4496   for (Output_data_list::iterator p = pdl->begin();
4497        p != pdl->end();
4498        ++p)
4499     {
4500       if (reset)
4501         (*p)->reset_address_and_file_offset();
4502
4503       // When doing an incremental update or when using a linker script,
4504       // the section will most likely already have an address.
4505       if (!(*p)->is_address_valid())
4506         {
4507           uint64_t align = (*p)->addralign();
4508
4509           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
4510             {
4511               // Give the first TLS section the alignment of the
4512               // entire TLS segment.  Otherwise the TLS segment as a
4513               // whole may be misaligned.
4514               if (!*in_tls)
4515                 {
4516                   Output_segment* tls_segment = layout->tls_segment();
4517                   gold_assert(tls_segment != NULL);
4518                   uint64_t segment_align = tls_segment->maximum_alignment();
4519                   gold_assert(segment_align >= align);
4520                   align = segment_align;
4521
4522                   *in_tls = true;
4523                 }
4524             }
4525           else
4526             {
4527               // If this is the first section after the TLS segment,
4528               // align it to at least the alignment of the TLS
4529               // segment, so that the size of the overall TLS segment
4530               // is aligned.
4531               if (*in_tls)
4532                 {
4533                   uint64_t segment_align =
4534                       layout->tls_segment()->maximum_alignment();
4535                   if (segment_align > align)
4536                     align = segment_align;
4537
4538                   *in_tls = false;
4539                 }
4540             }
4541
4542           if (!parameters->incremental_update())
4543             {
4544               off = align_address(off, align);
4545               (*p)->set_address_and_file_offset(addr + (off - startoff), off);
4546             }
4547           else
4548             {
4549               // Incremental update: allocate file space from free list.
4550               (*p)->pre_finalize_data_size();
4551               off_t current_size = (*p)->current_data_size();
4552               off = layout->allocate(current_size, align, startoff);
4553               if (off == -1)
4554                 {
4555                   gold_assert((*p)->output_section() != NULL);
4556                   gold_fallback(_("out of patch space for section %s; "
4557                                   "relink with --incremental-full"),
4558                                 (*p)->output_section()->name());
4559                 }
4560               (*p)->set_address_and_file_offset(addr + (off - startoff), off);
4561               if ((*p)->data_size() > current_size)
4562                 {
4563                   gold_assert((*p)->output_section() != NULL);
4564                   gold_fallback(_("%s: section changed size; "
4565                                   "relink with --incremental-full"),
4566                                 (*p)->output_section()->name());
4567                 }
4568             }
4569         }
4570       else if (parameters->incremental_update())
4571         {
4572           // For incremental updates, use the fixed offset for the
4573           // high-water mark computation.
4574           off = (*p)->offset();
4575         }
4576       else
4577         {
4578           // The script may have inserted a skip forward, but it
4579           // better not have moved backward.
4580           if ((*p)->address() >= addr + (off - startoff))
4581             off += (*p)->address() - (addr + (off - startoff));
4582           else
4583             {
4584               if (!layout->script_options()->saw_sections_clause())
4585                 gold_unreachable();
4586               else
4587                 {
4588                   Output_section* os = (*p)->output_section();
4589
4590                   // Cast to unsigned long long to avoid format warnings.
4591                   unsigned long long previous_dot =
4592                     static_cast<unsigned long long>(addr + (off - startoff));
4593                   unsigned long long dot =
4594                     static_cast<unsigned long long>((*p)->address());
4595
4596                   if (os == NULL)
4597                     gold_error(_("dot moves backward in linker script "
4598                                  "from 0x%llx to 0x%llx"), previous_dot, dot);
4599                   else
4600                     gold_error(_("address of section '%s' moves backward "
4601                                  "from 0x%llx to 0x%llx"),
4602                                os->name(), previous_dot, dot);
4603                 }
4604             }
4605           (*p)->set_file_offset(off);
4606           (*p)->finalize_data_size();
4607         }
4608
4609       if (parameters->incremental_update())
4610         gold_debug(DEBUG_INCREMENTAL,
4611                    "set_section_list_addresses: %08lx %08lx %s",
4612                    static_cast<long>(off),
4613                    static_cast<long>((*p)->data_size()),
4614                    ((*p)->output_section() != NULL
4615                     ? (*p)->output_section()->name() : "(special)"));
4616
4617       // We want to ignore the size of a SHF_TLS SHT_NOBITS
4618       // section.  Such a section does not affect the size of a
4619       // PT_LOAD segment.
4620       if (!(*p)->is_section_flag_set(elfcpp::SHF_TLS)
4621           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
4622         off += (*p)->data_size();
4623
4624       if (off > maxoff)
4625         maxoff = off;
4626
4627       if ((*p)->is_section())
4628         {
4629           (*p)->set_out_shndx(*pshndx);
4630           ++*pshndx;
4631         }
4632     }
4633
4634   *poff = maxoff;
4635   return addr + (maxoff - startoff);
4636 }
4637
4638 // For a non-PT_LOAD segment, set the offset from the sections, if
4639 // any.  Add INCREASE to the file size and the memory size.
4640
4641 void
4642 Output_segment::set_offset(unsigned int increase)
4643 {
4644   gold_assert(this->type_ != elfcpp::PT_LOAD);
4645
4646   gold_assert(!this->are_addresses_set_);
4647
4648   // A non-load section only uses output_lists_[0].
4649
4650   Output_data_list* pdl = &this->output_lists_[0];
4651
4652   if (pdl->empty())
4653     {
4654       gold_assert(increase == 0);
4655       this->vaddr_ = 0;
4656       this->paddr_ = 0;
4657       this->are_addresses_set_ = true;
4658       this->memsz_ = 0;
4659       this->min_p_align_ = 0;
4660       this->offset_ = 0;
4661       this->filesz_ = 0;
4662       return;
4663     }
4664
4665   // Find the first and last section by address.
4666   const Output_data* first = NULL;
4667   const Output_data* last_data = NULL;
4668   const Output_data* last_bss = NULL;
4669   for (Output_data_list::const_iterator p = pdl->begin();
4670        p != pdl->end();
4671        ++p)
4672     {
4673       if (first == NULL
4674           || (*p)->address() < first->address()
4675           || ((*p)->address() == first->address()
4676               && (*p)->data_size() < first->data_size()))
4677         first = *p;
4678       const Output_data** plast;
4679       if ((*p)->is_section()
4680           && (*p)->output_section()->type() == elfcpp::SHT_NOBITS)
4681         plast = &last_bss;
4682       else
4683         plast = &last_data;
4684       if (*plast == NULL
4685           || (*p)->address() > (*plast)->address()
4686           || ((*p)->address() == (*plast)->address()
4687               && (*p)->data_size() > (*plast)->data_size()))
4688         *plast = *p;
4689     }
4690
4691   this->vaddr_ = first->address();
4692   this->paddr_ = (first->has_load_address()
4693                   ? first->load_address()
4694                   : this->vaddr_);
4695   this->are_addresses_set_ = true;
4696   this->offset_ = first->offset();
4697
4698   if (last_data == NULL)
4699     this->filesz_ = 0;
4700   else
4701     this->filesz_ = (last_data->address()
4702                      + last_data->data_size()
4703                      - this->vaddr_);
4704
4705   const Output_data* last = last_bss != NULL ? last_bss : last_data;
4706   this->memsz_ = (last->address()
4707                   + last->data_size()
4708                   - this->vaddr_);
4709
4710   this->filesz_ += increase;
4711   this->memsz_ += increase;
4712
4713   // If this is a RELRO segment, verify that the segment ends at a
4714   // page boundary.
4715   if (this->type_ == elfcpp::PT_GNU_RELRO)
4716     {
4717       uint64_t page_align = parameters->target().abi_pagesize();
4718       uint64_t segment_end = this->vaddr_ + this->memsz_;
4719       if (parameters->incremental_update())
4720         {
4721           // The INCREASE_RELRO calculation is bypassed for an incremental
4722           // update, so we need to adjust the segment size manually here.
4723           segment_end = align_address(segment_end, page_align);
4724           this->memsz_ = segment_end - this->vaddr_;
4725         }
4726       else
4727         gold_assert(segment_end == align_address(segment_end, page_align));
4728     }
4729
4730   // If this is a TLS segment, align the memory size.  The code in
4731   // set_section_list ensures that the section after the TLS segment
4732   // is aligned to give us room.
4733   if (this->type_ == elfcpp::PT_TLS)
4734     {
4735       uint64_t segment_align = this->maximum_alignment();
4736       gold_assert(this->vaddr_ == align_address(this->vaddr_, segment_align));
4737       this->memsz_ = align_address(this->memsz_, segment_align);
4738     }
4739 }
4740
4741 // Set the TLS offsets of the sections in the PT_TLS segment.
4742
4743 void
4744 Output_segment::set_tls_offsets()
4745 {
4746   gold_assert(this->type_ == elfcpp::PT_TLS);
4747
4748   for (Output_data_list::iterator p = this->output_lists_[0].begin();
4749        p != this->output_lists_[0].end();
4750        ++p)
4751     (*p)->set_tls_offset(this->vaddr_);
4752 }
4753
4754 // Return the first section.
4755
4756 Output_section*
4757 Output_segment::first_section() const
4758 {
4759   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4760     {
4761       const Output_data_list* pdl = &this->output_lists_[i];
4762       for (Output_data_list::const_iterator p = pdl->begin();
4763            p != pdl->end();
4764            ++p)
4765         {
4766           if ((*p)->is_section())
4767             return (*p)->output_section();
4768         }
4769     }
4770   gold_unreachable();
4771 }
4772
4773 // Return the number of Output_sections in an Output_segment.
4774
4775 unsigned int
4776 Output_segment::output_section_count() const
4777 {
4778   unsigned int ret = 0;
4779   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4780     ret += this->output_section_count_list(&this->output_lists_[i]);
4781   return ret;
4782 }
4783
4784 // Return the number of Output_sections in an Output_data_list.
4785
4786 unsigned int
4787 Output_segment::output_section_count_list(const Output_data_list* pdl) const
4788 {
4789   unsigned int count = 0;
4790   for (Output_data_list::const_iterator p = pdl->begin();
4791        p != pdl->end();
4792        ++p)
4793     {
4794       if ((*p)->is_section())
4795         ++count;
4796     }
4797   return count;
4798 }
4799
4800 // Return the section attached to the list segment with the lowest
4801 // load address.  This is used when handling a PHDRS clause in a
4802 // linker script.
4803
4804 Output_section*
4805 Output_segment::section_with_lowest_load_address() const
4806 {
4807   Output_section* found = NULL;
4808   uint64_t found_lma = 0;
4809   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4810     this->lowest_load_address_in_list(&this->output_lists_[i], &found,
4811                                       &found_lma);
4812   return found;
4813 }
4814
4815 // Look through a list for a section with a lower load address.
4816
4817 void
4818 Output_segment::lowest_load_address_in_list(const Output_data_list* pdl,
4819                                             Output_section** found,
4820                                             uint64_t* found_lma) const
4821 {
4822   for (Output_data_list::const_iterator p = pdl->begin();
4823        p != pdl->end();
4824        ++p)
4825     {
4826       if (!(*p)->is_section())
4827         continue;
4828       Output_section* os = static_cast<Output_section*>(*p);
4829       uint64_t lma = (os->has_load_address()
4830                       ? os->load_address()
4831                       : os->address());
4832       if (*found == NULL || lma < *found_lma)
4833         {
4834           *found = os;
4835           *found_lma = lma;
4836         }
4837     }
4838 }
4839
4840 // Write the segment data into *OPHDR.
4841
4842 template<int size, bool big_endian>
4843 void
4844 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
4845 {
4846   ophdr->put_p_type(this->type_);
4847   ophdr->put_p_offset(this->offset_);
4848   ophdr->put_p_vaddr(this->vaddr_);
4849   ophdr->put_p_paddr(this->paddr_);
4850   ophdr->put_p_filesz(this->filesz_);
4851   ophdr->put_p_memsz(this->memsz_);
4852   ophdr->put_p_flags(this->flags_);
4853   ophdr->put_p_align(std::max(this->min_p_align_, this->maximum_alignment()));
4854 }
4855
4856 // Write the section headers into V.
4857
4858 template<int size, bool big_endian>
4859 unsigned char*
4860 Output_segment::write_section_headers(const Layout* layout,
4861                                       const Stringpool* secnamepool,
4862                                       unsigned char* v,
4863                                       unsigned int* pshndx) const
4864 {
4865   // Every section that is attached to a segment must be attached to a
4866   // PT_LOAD segment, so we only write out section headers for PT_LOAD
4867   // segments.
4868   if (this->type_ != elfcpp::PT_LOAD)
4869     return v;
4870
4871   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4872     {
4873       const Output_data_list* pdl = &this->output_lists_[i];
4874       v = this->write_section_headers_list<size, big_endian>(layout,
4875                                                              secnamepool,
4876                                                              pdl,
4877                                                              v, pshndx);
4878     }
4879
4880   return v;
4881 }
4882
4883 template<int size, bool big_endian>
4884 unsigned char*
4885 Output_segment::write_section_headers_list(const Layout* layout,
4886                                            const Stringpool* secnamepool,
4887                                            const Output_data_list* pdl,
4888                                            unsigned char* v,
4889                                            unsigned int* pshndx) const
4890 {
4891   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
4892   for (Output_data_list::const_iterator p = pdl->begin();
4893        p != pdl->end();
4894        ++p)
4895     {
4896       if ((*p)->is_section())
4897         {
4898           const Output_section* ps = static_cast<const Output_section*>(*p);
4899           gold_assert(*pshndx == ps->out_shndx());
4900           elfcpp::Shdr_write<size, big_endian> oshdr(v);
4901           ps->write_header(layout, secnamepool, &oshdr);
4902           v += shdr_size;
4903           ++*pshndx;
4904         }
4905     }
4906   return v;
4907 }
4908
4909 // Print the output sections to the map file.
4910
4911 void
4912 Output_segment::print_sections_to_mapfile(Mapfile* mapfile) const
4913 {
4914   if (this->type() != elfcpp::PT_LOAD)
4915     return;
4916   for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4917     this->print_section_list_to_mapfile(mapfile, &this->output_lists_[i]);
4918 }
4919
4920 // Print an output section list to the map file.
4921
4922 void
4923 Output_segment::print_section_list_to_mapfile(Mapfile* mapfile,
4924                                               const Output_data_list* pdl) const
4925 {
4926   for (Output_data_list::const_iterator p = pdl->begin();
4927        p != pdl->end();
4928        ++p)
4929     (*p)->print_to_mapfile(mapfile);
4930 }
4931
4932 // Output_file methods.
4933
4934 Output_file::Output_file(const char* name)
4935   : name_(name),
4936     o_(-1),
4937     file_size_(0),
4938     base_(NULL),
4939     map_is_anonymous_(false),
4940     map_is_allocated_(false),
4941     is_temporary_(false)
4942 {
4943 }
4944
4945 // Try to open an existing file.  Returns false if the file doesn't
4946 // exist, has a size of 0 or can't be mmapped.  If BASE_NAME is not
4947 // NULL, open that file as the base for incremental linking, and
4948 // copy its contents to the new output file.  This routine can
4949 // be called for incremental updates, in which case WRITABLE should
4950 // be true, or by the incremental-dump utility, in which case
4951 // WRITABLE should be false.
4952
4953 bool
4954 Output_file::open_base_file(const char* base_name, bool writable)
4955 {
4956   // The name "-" means "stdout".
4957   if (strcmp(this->name_, "-") == 0)
4958     return false;
4959
4960   bool use_base_file = base_name != NULL;
4961   if (!use_base_file)
4962     base_name = this->name_;
4963   else if (strcmp(base_name, this->name_) == 0)
4964     gold_fatal(_("%s: incremental base and output file name are the same"),
4965                base_name);
4966
4967   // Don't bother opening files with a size of zero.
4968   struct stat s;
4969   if (::stat(base_name, &s) != 0)
4970     {
4971       gold_info(_("%s: stat: %s"), base_name, strerror(errno));
4972       return false;
4973     }
4974   if (s.st_size == 0)
4975     {
4976       gold_info(_("%s: incremental base file is empty"), base_name);
4977       return false;
4978     }
4979
4980   // If we're using a base file, we want to open it read-only.
4981   if (use_base_file)
4982     writable = false;
4983
4984   int oflags = writable ? O_RDWR : O_RDONLY;
4985   int o = open_descriptor(-1, base_name, oflags, 0);
4986   if (o < 0)
4987     {
4988       gold_info(_("%s: open: %s"), base_name, strerror(errno));
4989       return false;
4990     }
4991
4992   // If the base file and the output file are different, open a
4993   // new output file and read the contents from the base file into
4994   // the newly-mapped region.
4995   if (use_base_file)
4996     {
4997       this->open(s.st_size);
4998       ssize_t bytes_to_read = s.st_size;
4999       unsigned char* p = this->base_;
5000       while (bytes_to_read > 0)
5001         {
5002           ssize_t len = ::read(o, p, bytes_to_read);
5003           if (len < 0)
5004             {
5005               gold_info(_("%s: read failed: %s"), base_name, strerror(errno));
5006               return false;
5007             }
5008           if (len == 0)
5009             {
5010               gold_info(_("%s: file too short: read only %lld of %lld bytes"),
5011                         base_name,
5012                         static_cast<long long>(s.st_size - bytes_to_read),
5013                         static_cast<long long>(s.st_size));
5014               return false;
5015             }
5016           p += len;
5017           bytes_to_read -= len;
5018         }
5019       ::close(o);
5020       return true;
5021     }
5022
5023   this->o_ = o;
5024   this->file_size_ = s.st_size;
5025
5026   if (!this->map_no_anonymous(writable))
5027     {
5028       release_descriptor(o, true);
5029       this->o_ = -1;
5030       this->file_size_ = 0;
5031       return false;
5032     }
5033
5034   return true;
5035 }
5036
5037 // Open the output file.
5038
5039 void
5040 Output_file::open(off_t file_size)
5041 {
5042   this->file_size_ = file_size;
5043
5044   // Unlink the file first; otherwise the open() may fail if the file
5045   // is busy (e.g. it's an executable that's currently being executed).
5046   //
5047   // However, the linker may be part of a system where a zero-length
5048   // file is created for it to write to, with tight permissions (gcc
5049   // 2.95 did something like this).  Unlinking the file would work
5050   // around those permission controls, so we only unlink if the file
5051   // has a non-zero size.  We also unlink only regular files to avoid
5052   // trouble with directories/etc.
5053   //
5054   // If we fail, continue; this command is merely a best-effort attempt
5055   // to improve the odds for open().
5056
5057   // We let the name "-" mean "stdout"
5058   if (!this->is_temporary_)
5059     {
5060       if (strcmp(this->name_, "-") == 0)
5061         this->o_ = STDOUT_FILENO;
5062       else
5063         {
5064           struct stat s;
5065           if (::stat(this->name_, &s) == 0
5066               && (S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
5067             {
5068               if (s.st_size != 0)
5069                 ::unlink(this->name_);
5070               else if (!parameters->options().relocatable())
5071                 {
5072                   // If we don't unlink the existing file, add execute
5073                   // permission where read permissions already exist
5074                   // and where the umask permits.
5075                   int mask = ::umask(0);
5076                   ::umask(mask);
5077                   s.st_mode |= (s.st_mode & 0444) >> 2;
5078                   ::chmod(this->name_, s.st_mode & ~mask);
5079                 }
5080             }
5081
5082           int mode = parameters->options().relocatable() ? 0666 : 0777;
5083           int o = open_descriptor(-1, this->name_, O_RDWR | O_CREAT | O_TRUNC,
5084                                   mode);
5085           if (o < 0)
5086             gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
5087           this->o_ = o;
5088         }
5089     }
5090
5091   this->map();
5092 }
5093
5094 // Resize the output file.
5095
5096 void
5097 Output_file::resize(off_t file_size)
5098 {
5099   // If the mmap is mapping an anonymous memory buffer, this is easy:
5100   // just mremap to the new size.  If it's mapping to a file, we want
5101   // to unmap to flush to the file, then remap after growing the file.
5102   if (this->map_is_anonymous_)
5103     {
5104       void* base;
5105       if (!this->map_is_allocated_)
5106         {
5107           base = ::mremap(this->base_, this->file_size_, file_size,
5108                           MREMAP_MAYMOVE);
5109           if (base == MAP_FAILED)
5110             gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
5111         }
5112       else
5113         {
5114           base = realloc(this->base_, file_size);
5115           if (base == NULL)
5116             gold_nomem();
5117           if (file_size > this->file_size_)
5118             memset(static_cast<char*>(base) + this->file_size_, 0,
5119                    file_size - this->file_size_);
5120         }
5121       this->base_ = static_cast<unsigned char*>(base);
5122       this->file_size_ = file_size;
5123     }
5124   else
5125     {
5126       this->unmap();
5127       this->file_size_ = file_size;
5128       if (!this->map_no_anonymous(true))
5129         gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
5130     }
5131 }
5132
5133 // Map an anonymous block of memory which will later be written to the
5134 // file.  Return whether the map succeeded.
5135
5136 bool
5137 Output_file::map_anonymous()
5138 {
5139   void* base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
5140                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
5141   if (base == MAP_FAILED)
5142     {
5143       base = malloc(this->file_size_);
5144       if (base == NULL)
5145         return false;
5146       memset(base, 0, this->file_size_);
5147       this->map_is_allocated_ = true;
5148     }
5149   this->base_ = static_cast<unsigned char*>(base);
5150   this->map_is_anonymous_ = true;
5151   return true;
5152 }
5153
5154 // Map the file into memory.  Return whether the mapping succeeded.
5155 // If WRITABLE is true, map with write access.
5156
5157 bool
5158 Output_file::map_no_anonymous(bool writable)
5159 {
5160   const int o = this->o_;
5161
5162   // If the output file is not a regular file, don't try to mmap it;
5163   // instead, we'll mmap a block of memory (an anonymous buffer), and
5164   // then later write the buffer to the file.
5165   void* base;
5166   struct stat statbuf;
5167   if (o == STDOUT_FILENO || o == STDERR_FILENO
5168       || ::fstat(o, &statbuf) != 0
5169       || !S_ISREG(statbuf.st_mode)
5170       || this->is_temporary_)
5171     return false;
5172
5173   // Ensure that we have disk space available for the file.  If we
5174   // don't do this, it is possible that we will call munmap, close,
5175   // and exit with dirty buffers still in the cache with no assigned
5176   // disk blocks.  If the disk is out of space at that point, the
5177   // output file will wind up incomplete, but we will have already
5178   // exited.  The alternative to fallocate would be to use fdatasync,
5179   // but that would be a more significant performance hit.
5180   if (writable)
5181     {
5182       int err = gold_fallocate(o, 0, this->file_size_);
5183       if (err != 0)
5184        gold_fatal(_("%s: %s"), this->name_, strerror(err));
5185     }
5186
5187   // Map the file into memory.
5188   int prot = PROT_READ;
5189   if (writable)
5190     prot |= PROT_WRITE;
5191   base = ::mmap(NULL, this->file_size_, prot, MAP_SHARED, o, 0);
5192
5193   // The mmap call might fail because of file system issues: the file
5194   // system might not support mmap at all, or it might not support
5195   // mmap with PROT_WRITE.
5196   if (base == MAP_FAILED)
5197     return false;
5198
5199   this->map_is_anonymous_ = false;
5200   this->base_ = static_cast<unsigned char*>(base);
5201   return true;
5202 }
5203
5204 // Map the file into memory.
5205
5206 void
5207 Output_file::map()
5208 {
5209   if (parameters->options().mmap_output_file()
5210       && this->map_no_anonymous(true))
5211     return;
5212
5213   // The mmap call might fail because of file system issues: the file
5214   // system might not support mmap at all, or it might not support
5215   // mmap with PROT_WRITE.  I'm not sure which errno values we will
5216   // see in all cases, so if the mmap fails for any reason and we
5217   // don't care about file contents, try for an anonymous map.
5218   if (this->map_anonymous())
5219     return;
5220
5221   gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
5222              this->name_, static_cast<unsigned long>(this->file_size_),
5223              strerror(errno));
5224 }
5225
5226 // Unmap the file from memory.
5227
5228 void
5229 Output_file::unmap()
5230 {
5231   if (this->map_is_anonymous_)
5232     {
5233       // We've already written out the data, so there is no reason to
5234       // waste time unmapping or freeing the memory.
5235     }
5236   else
5237     {
5238       if (::munmap(this->base_, this->file_size_) < 0)
5239         gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
5240     }
5241   this->base_ = NULL;
5242 }
5243
5244 // Close the output file.
5245
5246 void
5247 Output_file::close()
5248 {
5249   // If the map isn't file-backed, we need to write it now.
5250   if (this->map_is_anonymous_ && !this->is_temporary_)
5251     {
5252       size_t bytes_to_write = this->file_size_;
5253       size_t offset = 0;
5254       while (bytes_to_write > 0)
5255         {
5256           ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
5257                                           bytes_to_write);
5258           if (bytes_written == 0)
5259             gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
5260           else if (bytes_written < 0)
5261             gold_error(_("%s: write: %s"), this->name_, strerror(errno));
5262           else
5263             {
5264               bytes_to_write -= bytes_written;
5265               offset += bytes_written;
5266             }
5267         }
5268     }
5269   this->unmap();
5270
5271   // We don't close stdout or stderr
5272   if (this->o_ != STDOUT_FILENO
5273       && this->o_ != STDERR_FILENO
5274       && !this->is_temporary_)
5275     if (::close(this->o_) < 0)
5276       gold_error(_("%s: close: %s"), this->name_, strerror(errno));
5277   this->o_ = -1;
5278 }
5279
5280 // Instantiate the templates we need.  We could use the configure
5281 // script to restrict this to only the ones for implemented targets.
5282
5283 #ifdef HAVE_TARGET_32_LITTLE
5284 template
5285 off_t
5286 Output_section::add_input_section<32, false>(
5287     Layout* layout,
5288     Sized_relobj_file<32, false>* object,
5289     unsigned int shndx,
5290     const char* secname,
5291     const elfcpp::Shdr<32, false>& shdr,
5292     unsigned int reloc_shndx,
5293     bool have_sections_script);
5294 #endif
5295
5296 #ifdef HAVE_TARGET_32_BIG
5297 template
5298 off_t
5299 Output_section::add_input_section<32, true>(
5300     Layout* layout,
5301     Sized_relobj_file<32, true>* object,
5302     unsigned int shndx,
5303     const char* secname,
5304     const elfcpp::Shdr<32, true>& shdr,
5305     unsigned int reloc_shndx,
5306     bool have_sections_script);
5307 #endif
5308
5309 #ifdef HAVE_TARGET_64_LITTLE
5310 template
5311 off_t
5312 Output_section::add_input_section<64, false>(
5313     Layout* layout,
5314     Sized_relobj_file<64, false>* object,
5315     unsigned int shndx,
5316     const char* secname,
5317     const elfcpp::Shdr<64, false>& shdr,
5318     unsigned int reloc_shndx,
5319     bool have_sections_script);
5320 #endif
5321
5322 #ifdef HAVE_TARGET_64_BIG
5323 template
5324 off_t
5325 Output_section::add_input_section<64, true>(
5326     Layout* layout,
5327     Sized_relobj_file<64, true>* object,
5328     unsigned int shndx,
5329     const char* secname,
5330     const elfcpp::Shdr<64, true>& shdr,
5331     unsigned int reloc_shndx,
5332     bool have_sections_script);
5333 #endif
5334
5335 #ifdef HAVE_TARGET_32_LITTLE
5336 template
5337 class Output_reloc<elfcpp::SHT_REL, false, 32, false>;
5338 #endif
5339
5340 #ifdef HAVE_TARGET_32_BIG
5341 template
5342 class Output_reloc<elfcpp::SHT_REL, false, 32, true>;
5343 #endif
5344
5345 #ifdef HAVE_TARGET_64_LITTLE
5346 template
5347 class Output_reloc<elfcpp::SHT_REL, false, 64, false>;
5348 #endif
5349
5350 #ifdef HAVE_TARGET_64_BIG
5351 template
5352 class Output_reloc<elfcpp::SHT_REL, false, 64, true>;
5353 #endif
5354
5355 #ifdef HAVE_TARGET_32_LITTLE
5356 template
5357 class Output_reloc<elfcpp::SHT_REL, true, 32, false>;
5358 #endif
5359
5360 #ifdef HAVE_TARGET_32_BIG
5361 template
5362 class Output_reloc<elfcpp::SHT_REL, true, 32, true>;
5363 #endif
5364
5365 #ifdef HAVE_TARGET_64_LITTLE
5366 template
5367 class Output_reloc<elfcpp::SHT_REL, true, 64, false>;
5368 #endif
5369
5370 #ifdef HAVE_TARGET_64_BIG
5371 template
5372 class Output_reloc<elfcpp::SHT_REL, true, 64, true>;
5373 #endif
5374
5375 #ifdef HAVE_TARGET_32_LITTLE
5376 template
5377 class Output_reloc<elfcpp::SHT_RELA, false, 32, false>;
5378 #endif
5379
5380 #ifdef HAVE_TARGET_32_BIG
5381 template
5382 class Output_reloc<elfcpp::SHT_RELA, false, 32, true>;
5383 #endif
5384
5385 #ifdef HAVE_TARGET_64_LITTLE
5386 template
5387 class Output_reloc<elfcpp::SHT_RELA, false, 64, false>;
5388 #endif
5389
5390 #ifdef HAVE_TARGET_64_BIG
5391 template
5392 class Output_reloc<elfcpp::SHT_RELA, false, 64, true>;
5393 #endif
5394
5395 #ifdef HAVE_TARGET_32_LITTLE
5396 template
5397 class Output_reloc<elfcpp::SHT_RELA, true, 32, false>;
5398 #endif
5399
5400 #ifdef HAVE_TARGET_32_BIG
5401 template
5402 class Output_reloc<elfcpp::SHT_RELA, true, 32, true>;
5403 #endif
5404
5405 #ifdef HAVE_TARGET_64_LITTLE
5406 template
5407 class Output_reloc<elfcpp::SHT_RELA, true, 64, false>;
5408 #endif
5409
5410 #ifdef HAVE_TARGET_64_BIG
5411 template
5412 class Output_reloc<elfcpp::SHT_RELA, true, 64, true>;
5413 #endif
5414
5415 #ifdef HAVE_TARGET_32_LITTLE
5416 template
5417 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
5418 #endif
5419
5420 #ifdef HAVE_TARGET_32_BIG
5421 template
5422 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
5423 #endif
5424
5425 #ifdef HAVE_TARGET_64_LITTLE
5426 template
5427 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
5428 #endif
5429
5430 #ifdef HAVE_TARGET_64_BIG
5431 template
5432 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
5433 #endif
5434
5435 #ifdef HAVE_TARGET_32_LITTLE
5436 template
5437 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
5438 #endif
5439
5440 #ifdef HAVE_TARGET_32_BIG
5441 template
5442 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
5443 #endif
5444
5445 #ifdef HAVE_TARGET_64_LITTLE
5446 template
5447 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
5448 #endif
5449
5450 #ifdef HAVE_TARGET_64_BIG
5451 template
5452 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
5453 #endif
5454
5455 #ifdef HAVE_TARGET_32_LITTLE
5456 template
5457 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
5458 #endif
5459
5460 #ifdef HAVE_TARGET_32_BIG
5461 template
5462 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
5463 #endif
5464
5465 #ifdef HAVE_TARGET_64_LITTLE
5466 template
5467 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
5468 #endif
5469
5470 #ifdef HAVE_TARGET_64_BIG
5471 template
5472 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
5473 #endif
5474
5475 #ifdef HAVE_TARGET_32_LITTLE
5476 template
5477 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
5478 #endif
5479
5480 #ifdef HAVE_TARGET_32_BIG
5481 template
5482 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
5483 #endif
5484
5485 #ifdef HAVE_TARGET_64_LITTLE
5486 template
5487 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
5488 #endif
5489
5490 #ifdef HAVE_TARGET_64_BIG
5491 template
5492 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
5493 #endif
5494
5495 #ifdef HAVE_TARGET_32_LITTLE
5496 template
5497 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, false>;
5498 #endif
5499
5500 #ifdef HAVE_TARGET_32_BIG
5501 template
5502 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, true>;
5503 #endif
5504
5505 #ifdef HAVE_TARGET_64_LITTLE
5506 template
5507 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, false>;
5508 #endif
5509
5510 #ifdef HAVE_TARGET_64_BIG
5511 template
5512 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, true>;
5513 #endif
5514
5515 #ifdef HAVE_TARGET_32_LITTLE
5516 template
5517 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, false>;
5518 #endif
5519
5520 #ifdef HAVE_TARGET_32_BIG
5521 template
5522 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, true>;
5523 #endif
5524
5525 #ifdef HAVE_TARGET_64_LITTLE
5526 template
5527 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, false>;
5528 #endif
5529
5530 #ifdef HAVE_TARGET_64_BIG
5531 template
5532 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, true>;
5533 #endif
5534
5535 #ifdef HAVE_TARGET_32_LITTLE
5536 template
5537 class Output_data_group<32, false>;
5538 #endif
5539
5540 #ifdef HAVE_TARGET_32_BIG
5541 template
5542 class Output_data_group<32, true>;
5543 #endif
5544
5545 #ifdef HAVE_TARGET_64_LITTLE
5546 template
5547 class Output_data_group<64, false>;
5548 #endif
5549
5550 #ifdef HAVE_TARGET_64_BIG
5551 template
5552 class Output_data_group<64, true>;
5553 #endif
5554
5555 template
5556 class Output_data_got<32, false>;
5557
5558 template
5559 class Output_data_got<32, true>;
5560
5561 template
5562 class Output_data_got<64, false>;
5563
5564 template
5565 class Output_data_got<64, true>;
5566
5567 } // End namespace gold.