gold/output.cc

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