gold/output.cc

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