gold/output.cc

   1 // output.cc -- manage the output file for gold
   2
   3 // Copyright 2006, 2007 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 <cerrno>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <sys/mman.h>
  30 #include <sys/stat.h>
  31 #include <algorithm>
  32 #include "libiberty.h"   // for unlink_if_ordinary()
  33
  34 #include "parameters.h"
  35 #include "object.h"
  36 #include "symtab.h"
  37 #include "reloc.h"
  38 #include "merge.h"
  39 #include "output.h"
  40
  41 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
  42 #ifndef MAP_ANONYMOUS
  43 # define MAP_ANONYMOUS  MAP_ANON
  44 #endif
  45
  46 namespace gold
  47 {
  48
  49 // Output_data variables.
  50
  51 bool Output_data::allocated_sizes_are_fixed;
  52
  53 // Output_data methods.
  54
  55 Output_data::~Output_data()
  56 {
  57 }
  58
  59 // Return the default alignment for the target size.
  60
  61 uint64_t
  62 Output_data::default_alignment()
  63 {
  64   return Output_data::default_alignment_for_size(parameters->get_size());
  65 }
  66
  67 // Return the default alignment for a size--32 or 64.
  68
  69 uint64_t
  70 Output_data::default_alignment_for_size(int size)
  71 {
  72   if (size == 32)
  73     return 4;
  74   else if (size == 64)
  75     return 8;
  76   else
  77     gold_unreachable();
  78 }
  79
  80 // Output_section_header methods.  This currently assumes that the
  81 // segment and section lists are complete at construction time.
  82
  83 Output_section_headers::Output_section_headers(
  84     const Layout* layout,
  85     const Layout::Segment_list* segment_list,
  86     const Layout::Section_list* unattached_section_list,
  87     const Stringpool* secnamepool)
  88   : layout_(layout),
  89     segment_list_(segment_list),
  90     unattached_section_list_(unattached_section_list),
  91     secnamepool_(secnamepool)
  92 {
  93   // Count all the sections.  Start with 1 for the null section.
  94   off_t count = 1;
  95   for (Layout::Segment_list::const_iterator p = segment_list->begin();
  96        p != segment_list->end();
  97        ++p)
  98     if ((*p)->type() == elfcpp::PT_LOAD)
  99       count += (*p)->output_section_count();
 100   count += unattached_section_list->size();
 101
 102   const int size = parameters->get_size();
 103   int shdr_size;
 104   if (size == 32)
 105     shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
 106   else if (size == 64)
 107     shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
 108   else
 109     gold_unreachable();
 110
 111   this->set_data_size(count * shdr_size);
 112 }
 113
 114 // Write out the section headers.
 115
 116 void
 117 Output_section_headers::do_write(Output_file* of)
 118 {
 119   if (parameters->get_size() == 32)
 120     {
 121       if (parameters->is_big_endian())
 122         {
 123 #ifdef HAVE_TARGET_32_BIG
 124           this->do_sized_write<32, true>(of);
 125 #else
 126           gold_unreachable();
 127 #endif
 128         }
 129       else
 130         {
 131 #ifdef HAVE_TARGET_32_LITTLE
 132           this->do_sized_write<32, false>(of);
 133 #else
 134           gold_unreachable();
 135 #endif
 136         }
 137     }
 138   else if (parameters->get_size() == 64)
 139     {
 140       if (parameters->is_big_endian())
 141         {
 142 #ifdef HAVE_TARGET_64_BIG
 143           this->do_sized_write<64, true>(of);
 144 #else
 145           gold_unreachable();
 146 #endif
 147         }
 148       else
 149         {
 150 #ifdef HAVE_TARGET_64_LITTLE
 151           this->do_sized_write<64, false>(of);
 152 #else
 153           gold_unreachable();
 154 #endif
 155         }
 156     }
 157   else
 158     gold_unreachable();
 159 }
 160
 161 template<int size, bool big_endian>
 162 void
 163 Output_section_headers::do_sized_write(Output_file* of)
 164 {
 165   off_t all_shdrs_size = this->data_size();
 166   unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
 167
 168   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 169   unsigned char* v = view;
 170
 171   {
 172     typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
 173     oshdr.put_sh_name(0);
 174     oshdr.put_sh_type(elfcpp::SHT_NULL);
 175     oshdr.put_sh_flags(0);
 176     oshdr.put_sh_addr(0);
 177     oshdr.put_sh_offset(0);
 178     oshdr.put_sh_size(0);
 179     oshdr.put_sh_link(0);
 180     oshdr.put_sh_info(0);
 181     oshdr.put_sh_addralign(0);
 182     oshdr.put_sh_entsize(0);
 183   }
 184
 185   v += shdr_size;
 186
 187   unsigned shndx = 1;
 188   for (Layout::Segment_list::const_iterator p = this->segment_list_->begin();
 189        p != this->segment_list_->end();
 190        ++p)
 191     v = (*p)->write_section_headers SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
 192             this->layout_, this->secnamepool_, v, &shndx
 193             SELECT_SIZE_ENDIAN(size, big_endian));
 194   for (Layout::Section_list::const_iterator p =
 195          this->unattached_section_list_->begin();
 196        p != this->unattached_section_list_->end();
 197        ++p)
 198     {
 199       gold_assert(shndx == (*p)->out_shndx());
 200       elfcpp::Shdr_write<size, big_endian> oshdr(v);
 201       (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
 202       v += shdr_size;
 203       ++shndx;
 204     }
 205
 206   of->write_output_view(this->offset(), all_shdrs_size, view);
 207 }
 208
 209 // Output_segment_header methods.
 210
 211 Output_segment_headers::Output_segment_headers(
 212     const Layout::Segment_list& segment_list)
 213   : segment_list_(segment_list)
 214 {
 215   const int size = parameters->get_size();
 216   int phdr_size;
 217   if (size == 32)
 218     phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
 219   else if (size == 64)
 220     phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
 221   else
 222     gold_unreachable();
 223
 224   this->set_data_size(segment_list.size() * phdr_size);
 225 }
 226
 227 void
 228 Output_segment_headers::do_write(Output_file* of)
 229 {
 230   if (parameters->get_size() == 32)
 231     {
 232       if (parameters->is_big_endian())
 233         {
 234 #ifdef HAVE_TARGET_32_BIG
 235           this->do_sized_write<32, true>(of);
 236 #else
 237           gold_unreachable();
 238 #endif
 239         }
 240       else
 241         {
 242 #ifdef HAVE_TARGET_32_LITTLE
 243         this->do_sized_write<32, false>(of);
 244 #else
 245         gold_unreachable();
 246 #endif
 247         }
 248     }
 249   else if (parameters->get_size() == 64)
 250     {
 251       if (parameters->is_big_endian())
 252         {
 253 #ifdef HAVE_TARGET_64_BIG
 254           this->do_sized_write<64, true>(of);
 255 #else
 256           gold_unreachable();
 257 #endif
 258         }
 259       else
 260         {
 261 #ifdef HAVE_TARGET_64_LITTLE
 262           this->do_sized_write<64, false>(of);
 263 #else
 264           gold_unreachable();
 265 #endif
 266         }
 267     }
 268   else
 269     gold_unreachable();
 270 }
 271
 272 template<int size, bool big_endian>
 273 void
 274 Output_segment_headers::do_sized_write(Output_file* of)
 275 {
 276   const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
 277   off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
 278   unsigned char* view = of->get_output_view(this->offset(),
 279                                             all_phdrs_size);
 280   unsigned char* v = view;
 281   for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
 282        p != this->segment_list_.end();
 283        ++p)
 284     {
 285       elfcpp::Phdr_write<size, big_endian> ophdr(v);
 286       (*p)->write_header(&ophdr);
 287       v += phdr_size;
 288     }
 289
 290   of->write_output_view(this->offset(), all_phdrs_size, view);
 291 }
 292
 293 // Output_file_header methods.
 294
 295 Output_file_header::Output_file_header(const Target* target,
 296                                        const Symbol_table* symtab,
 297                                        const Output_segment_headers* osh)
 298   : target_(target),
 299     symtab_(symtab),
 300     segment_header_(osh),
 301     section_header_(NULL),
 302     shstrtab_(NULL)
 303 {
 304   const int size = parameters->get_size();
 305   int ehdr_size;
 306   if (size == 32)
 307     ehdr_size = elfcpp::Elf_sizes<32>::ehdr_size;
 308   else if (size == 64)
 309     ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size;
 310   else
 311     gold_unreachable();
 312
 313   this->set_data_size(ehdr_size);
 314 }
 315
 316 // Set the section table information for a file header.
 317
 318 void
 319 Output_file_header::set_section_info(const Output_section_headers* shdrs,
 320                                      const Output_section* shstrtab)
 321 {
 322   this->section_header_ = shdrs;
 323   this->shstrtab_ = shstrtab;
 324 }
 325
 326 // Write out the file header.
 327
 328 void
 329 Output_file_header::do_write(Output_file* of)
 330 {
 331   gold_assert(this->offset() == 0);
 332
 333   if (parameters->get_size() == 32)
 334     {
 335       if (parameters->is_big_endian())
 336         {
 337 #ifdef HAVE_TARGET_32_BIG
 338           this->do_sized_write<32, true>(of);
 339 #else
 340           gold_unreachable();
 341 #endif
 342         }
 343       else
 344         {
 345 #ifdef HAVE_TARGET_32_LITTLE
 346           this->do_sized_write<32, false>(of);
 347 #else
 348           gold_unreachable();
 349 #endif
 350         }
 351     }
 352   else if (parameters->get_size() == 64)
 353     {
 354       if (parameters->is_big_endian())
 355         {
 356 #ifdef HAVE_TARGET_64_BIG
 357           this->do_sized_write<64, true>(of);
 358 #else
 359           gold_unreachable();
 360 #endif
 361         }
 362       else
 363         {
 364 #ifdef HAVE_TARGET_64_LITTLE
 365           this->do_sized_write<64, false>(of);
 366 #else
 367           gold_unreachable();
 368 #endif
 369         }
 370     }
 371   else
 372     gold_unreachable();
 373 }
 374
 375 // Write out the file header with appropriate size and endianess.
 376
 377 template<int size, bool big_endian>
 378 void
 379 Output_file_header::do_sized_write(Output_file* of)
 380 {
 381   gold_assert(this->offset() == 0);
 382
 383   int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
 384   unsigned char* view = of->get_output_view(0, ehdr_size);
 385   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
 386
 387   unsigned char e_ident[elfcpp::EI_NIDENT];
 388   memset(e_ident, 0, elfcpp::EI_NIDENT);
 389   e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
 390   e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
 391   e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
 392   e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
 393   if (size == 32)
 394     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
 395   else if (size == 64)
 396     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
 397   else
 398     gold_unreachable();
 399   e_ident[elfcpp::EI_DATA] = (big_endian
 400                               ? elfcpp::ELFDATA2MSB
 401                               : elfcpp::ELFDATA2LSB);
 402   e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
 403   // FIXME: Some targets may need to set EI_OSABI and EI_ABIVERSION.
 404   oehdr.put_e_ident(e_ident);
 405
 406   elfcpp::ET e_type;
 407   if (parameters->output_is_object())
 408     e_type = elfcpp::ET_REL;
 409   else if (parameters->output_is_shared())
 410     e_type = elfcpp::ET_DYN;
 411   else
 412     e_type = elfcpp::ET_EXEC;
 413   oehdr.put_e_type(e_type);
 414
 415   oehdr.put_e_machine(this->target_->machine_code());
 416   oehdr.put_e_version(elfcpp::EV_CURRENT);
 417
 418   // FIXME: Need to support -e, and target specific entry symbol.
 419   Symbol* sym = this->symtab_->lookup("_start");
 420   typename Sized_symbol<size>::Value_type v;
 421   if (sym == NULL)
 422     v = 0;
 423   else
 424     {
 425       Sized_symbol<size>* ssym;
 426       ssym = this->symtab_->get_sized_symbol SELECT_SIZE_NAME(size) (
 427         sym SELECT_SIZE(size));
 428       v = ssym->value();
 429     }
 430   oehdr.put_e_entry(v);
 431
 432   oehdr.put_e_phoff(this->segment_header_->offset());
 433   oehdr.put_e_shoff(this->section_header_->offset());
 434
 435   // FIXME: The target needs to set the flags.
 436   oehdr.put_e_flags(0);
 437
 438   oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
 439   oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
 440   oehdr.put_e_phnum(this->segment_header_->data_size()
 441                      / elfcpp::Elf_sizes<size>::phdr_size);
 442   oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
 443   oehdr.put_e_shnum(this->section_header_->data_size()
 444                      / elfcpp::Elf_sizes<size>::shdr_size);
 445   oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
 446
 447   of->write_output_view(0, ehdr_size, view);
 448 }
 449
 450 // Output_data_const methods.
 451
 452 void
 453 Output_data_const::do_write(Output_file* of)
 454 {
 455   of->write(this->offset(), this->data_.data(), this->data_.size());
 456 }
 457
 458 // Output_data_const_buffer methods.
 459
 460 void
 461 Output_data_const_buffer::do_write(Output_file* of)
 462 {
 463   of->write(this->offset(), this->p_, this->data_size());
 464 }
 465
 466 // Output_section_data methods.
 467
 468 // Record the output section, and set the entry size and such.
 469
 470 void
 471 Output_section_data::set_output_section(Output_section* os)
 472 {
 473   gold_assert(this->output_section_ == NULL);
 474   this->output_section_ = os;
 475   this->do_adjust_output_section(os);
 476 }
 477
 478 // Return the section index of the output section.
 479
 480 unsigned int
 481 Output_section_data::do_out_shndx() const
 482 {
 483   gold_assert(this->output_section_ != NULL);
 484   return this->output_section_->out_shndx();
 485 }
 486
 487 // Output_data_strtab methods.
 488
 489 // Set the final data size.
 490
 491 void
 492 Output_data_strtab::set_final_data_size()
 493 {
 494   this->strtab_->set_string_offsets();
 495   this->set_data_size(this->strtab_->get_strtab_size());
 496 }
 497
 498 // Write out a string table.
 499
 500 void
 501 Output_data_strtab::do_write(Output_file* of)
 502 {
 503   this->strtab_->write(of, this->offset());
 504 }
 505
 506 // Output_reloc methods.
 507
 508 // A reloc against a global symbol.
 509
 510 template<bool dynamic, int size, bool big_endian>
 511 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 512     Symbol* gsym,
 513     unsigned int type,
 514     Output_data* od,
 515     Address address,
 516     bool is_relative)
 517   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
 518     is_relative_(is_relative), shndx_(INVALID_CODE)
 519 {
 520   this->u1_.gsym = gsym;
 521   this->u2_.od = od;
 522   if (dynamic && !is_relative)
 523     gsym->set_needs_dynsym_entry();
 524 }
 525
 526 template<bool dynamic, int size, bool big_endian>
 527 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 528     Symbol* gsym,
 529     unsigned int type,
 530     Relobj* relobj,
 531     unsigned int shndx,
 532     Address address,
 533     bool is_relative)
 534   : address_(address), local_sym_index_(GSYM_CODE), type_(type),
 535     is_relative_(is_relative), shndx_(shndx)
 536 {
 537   gold_assert(shndx != INVALID_CODE);
 538   this->u1_.gsym = gsym;
 539   this->u2_.relobj = relobj;
 540   if (dynamic && !is_relative)
 541     gsym->set_needs_dynsym_entry();
 542 }
 543
 544 // A reloc against a local symbol.
 545
 546 template<bool dynamic, int size, bool big_endian>
 547 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 548     Sized_relobj<size, big_endian>* relobj,
 549     unsigned int local_sym_index,
 550     unsigned int type,
 551     Output_data* od,
 552     Address address,
 553     bool is_relative)
 554   : address_(address), local_sym_index_(local_sym_index), type_(type),
 555     is_relative_(is_relative), shndx_(INVALID_CODE)
 556 {
 557   gold_assert(local_sym_index != GSYM_CODE
 558               && local_sym_index != INVALID_CODE);
 559   this->u1_.relobj = relobj;
 560   this->u2_.od = od;
 561   if (dynamic && !is_relative)
 562     relobj->set_needs_output_dynsym_entry(local_sym_index);
 563 }
 564
 565 template<bool dynamic, int size, bool big_endian>
 566 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 567     Sized_relobj<size, big_endian>* relobj,
 568     unsigned int local_sym_index,
 569     unsigned int type,
 570     unsigned int shndx,
 571     Address address,
 572     bool is_relative)
 573   : address_(address), local_sym_index_(local_sym_index), type_(type),
 574     is_relative_(is_relative), shndx_(shndx)
 575 {
 576   gold_assert(local_sym_index != GSYM_CODE
 577               && local_sym_index != INVALID_CODE);
 578   gold_assert(shndx != INVALID_CODE);
 579   this->u1_.relobj = relobj;
 580   this->u2_.relobj = relobj;
 581   if (dynamic && !is_relative)
 582     relobj->set_needs_output_dynsym_entry(local_sym_index);
 583 }
 584
 585 // A reloc against the STT_SECTION symbol of an output section.
 586
 587 template<bool dynamic, int size, bool big_endian>
 588 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 589     Output_section* os,
 590     unsigned int type,
 591     Output_data* od,
 592     Address address)
 593   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
 594     is_relative_(false), shndx_(INVALID_CODE)
 595 {
 596   this->u1_.os = os;
 597   this->u2_.od = od;
 598   if (dynamic)
 599     os->set_needs_dynsym_index();
 600 }
 601
 602 template<bool dynamic, int size, bool big_endian>
 603 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
 604     Output_section* os,
 605     unsigned int type,
 606     Relobj* relobj,
 607     unsigned int shndx,
 608     Address address)
 609   : address_(address), local_sym_index_(SECTION_CODE), type_(type),
 610     is_relative_(false), shndx_(shndx)
 611 {
 612   gold_assert(shndx != INVALID_CODE);
 613   this->u1_.os = os;
 614   this->u2_.relobj = relobj;
 615   if (dynamic)
 616     os->set_needs_dynsym_index();
 617 }
 618
 619 // Get the symbol index of a relocation.
 620
 621 template<bool dynamic, int size, bool big_endian>
 622 unsigned int
 623 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 624   const
 625 {
 626   unsigned int index;
 627   switch (this->local_sym_index_)
 628     {
 629     case INVALID_CODE:
 630       gold_unreachable();
 631
 632     case GSYM_CODE:
 633       if (this->u1_.gsym == NULL)
 634         index = 0;
 635       else if (dynamic)
 636         index = this->u1_.gsym->dynsym_index();
 637       else
 638         index = this->u1_.gsym->symtab_index();
 639       break;
 640
 641     case SECTION_CODE:
 642       if (dynamic)
 643         index = this->u1_.os->dynsym_index();
 644       else
 645         index = this->u1_.os->symtab_index();
 646       break;
 647
 648     case 0:
 649       // Relocations without symbols use a symbol index of 0.
 650       index = 0;
 651       break;
 652
 653     default:
 654       if (dynamic)
 655         index = this->u1_.relobj->dynsym_index(this->local_sym_index_);
 656       else
 657         index = this->u1_.relobj->symtab_index(this->local_sym_index_);
 658       break;
 659     }
 660   gold_assert(index != -1U);
 661   return index;
 662 }
 663
 664 // Write out the offset and info fields of a Rel or Rela relocation
 665 // entry.
 666
 667 template<bool dynamic, int size, bool big_endian>
 668 template<typename Write_rel>
 669 void
 670 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
 671     Write_rel* wr) const
 672 {
 673   Address address = this->address_;
 674   if (this->shndx_ != INVALID_CODE)
 675     {
 676       section_offset_type off;
 677       Output_section* os = this->u2_.relobj->output_section(this->shndx_,
 678                                                             &off);
 679       gold_assert(os != NULL);
 680       if (off != -1)
 681         address += os->address() + off;
 682       else
 683         {
 684           address = os->output_address(this->u2_.relobj, this->shndx_,
 685                                        address);
 686           gold_assert(address != -1U);
 687         }
 688     }
 689   else if (this->u2_.od != NULL)
 690     address += this->u2_.od->address();
 691   wr->put_r_offset(address);
 692   unsigned int sym_index = this->is_relative_ ? 0 : this->get_symbol_index();
 693   wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
 694 }
 695
 696 // Write out a Rel relocation.
 697
 698 template<bool dynamic, int size, bool big_endian>
 699 void
 700 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
 701     unsigned char* pov) const
 702 {
 703   elfcpp::Rel_write<size, big_endian> orel(pov);
 704   this->write_rel(&orel);
 705 }
 706
 707 // Get the value of the symbol referred to by a Rel relocation.
 708
 709 template<bool dynamic, int size, bool big_endian>
 710 typename elfcpp::Elf_types<size>::Elf_Addr
 711 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value() const
 712 {
 713   if (this->local_sym_index_ == GSYM_CODE)
 714     {
 715       const Sized_symbol<size>* sym;
 716       sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
 717       return sym->value();
 718     }
 719   gold_assert(this->local_sym_index_ != SECTION_CODE
 720               && this->local_sym_index_ != INVALID_CODE);
 721   const Sized_relobj<size, big_endian>* relobj = this->u1_.relobj;
 722   return relobj->local_symbol_value(this->local_sym_index_);
 723 }
 724
 725 // Write out a Rela relocation.
 726
 727 template<bool dynamic, int size, bool big_endian>
 728 void
 729 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
 730     unsigned char* pov) const
 731 {
 732   elfcpp::Rela_write<size, big_endian> orel(pov);
 733   this->rel_.write_rel(&orel);
 734   Addend addend = this->addend_;
 735   if (rel_.is_relative())
 736     addend += rel_.symbol_value();
 737   orel.put_r_addend(addend);
 738 }
 739
 740 // Output_data_reloc_base methods.
 741
 742 // Adjust the output section.
 743
 744 template<int sh_type, bool dynamic, int size, bool big_endian>
 745 void
 746 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
 747     ::do_adjust_output_section(Output_section* os)
 748 {
 749   if (sh_type == elfcpp::SHT_REL)
 750     os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
 751   else if (sh_type == elfcpp::SHT_RELA)
 752     os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
 753   else
 754     gold_unreachable();
 755   if (dynamic)
 756     os->set_should_link_to_dynsym();
 757   else
 758     os->set_should_link_to_symtab();
 759 }
 760
 761 // Write out relocation data.
 762
 763 template<int sh_type, bool dynamic, int size, bool big_endian>
 764 void
 765 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
 766     Output_file* of)
 767 {
 768   const off_t off = this->offset();
 769   const off_t oview_size = this->data_size();
 770   unsigned char* const oview = of->get_output_view(off, oview_size);
 771
 772   unsigned char* pov = oview;
 773   for (typename Relocs::const_iterator p = this->relocs_.begin();
 774        p != this->relocs_.end();
 775        ++p)
 776     {
 777       p->write(pov);
 778       pov += reloc_size;
 779     }
 780
 781   gold_assert(pov - oview == oview_size);
 782
 783   of->write_output_view(off, oview_size, oview);
 784
 785   // We no longer need the relocation entries.
 786   this->relocs_.clear();
 787 }
 788
 789 // Output_data_got::Got_entry methods.
 790
 791 // Write out the entry.
 792
 793 template<int size, bool big_endian>
 794 void
 795 Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov) const
 796 {
 797   Valtype val = 0;
 798
 799   switch (this->local_sym_index_)
 800     {
 801     case GSYM_CODE:
 802       {
 803         // If the symbol is resolved locally, we need to write out the
 804         // link-time value, which will be relocated dynamically by a
 805         // RELATIVE relocation.
 806         Symbol* gsym = this->u_.gsym;
 807         Sized_symbol<size>* sgsym;
 808         // This cast is a bit ugly.  We don't want to put a
 809         // virtual method in Symbol, because we want Symbol to be
 810         // as small as possible.
 811         sgsym = static_cast<Sized_symbol<size>*>(gsym);
 812         val = sgsym->value();
 813       }
 814       break;
 815
 816     case CONSTANT_CODE:
 817       val = this->u_.constant;
 818       break;
 819
 820     default:
 821       val = this->u_.object->local_symbol_value(this->local_sym_index_);
 822       break;
 823     }
 824
 825   elfcpp::Swap<size, big_endian>::writeval(pov, val);
 826 }
 827
 828 // Output_data_got methods.
 829
 830 // Add an entry for a global symbol to the GOT.  This returns true if
 831 // this is a new GOT entry, false if the symbol already had a GOT
 832 // entry.
 833
 834 template<int size, bool big_endian>
 835 bool
 836 Output_data_got<size, big_endian>::add_global(Symbol* gsym)
 837 {
 838   if (gsym->has_got_offset())
 839     return false;
 840
 841   this->entries_.push_back(Got_entry(gsym));
 842   this->set_got_size();
 843   gsym->set_got_offset(this->last_got_offset());
 844   return true;
 845 }
 846
 847 // Add an entry for a global symbol to the GOT, and add a dynamic
 848 // relocation of type R_TYPE for the GOT entry.
 849 template<int size, bool big_endian>
 850 void
 851 Output_data_got<size, big_endian>::add_global_with_rel(
 852     Symbol* gsym,
 853     Rel_dyn* rel_dyn,
 854     unsigned int r_type)
 855 {
 856   if (gsym->has_got_offset())
 857     return;
 858
 859   this->entries_.push_back(Got_entry());
 860   this->set_got_size();
 861   unsigned int got_offset = this->last_got_offset();
 862   gsym->set_got_offset(got_offset);
 863   rel_dyn->add_global(gsym, r_type, this, got_offset);
 864 }
 865
 866 template<int size, bool big_endian>
 867 void
 868 Output_data_got<size, big_endian>::add_global_with_rela(
 869     Symbol* gsym,
 870     Rela_dyn* rela_dyn,
 871     unsigned int r_type)
 872 {
 873   if (gsym->has_got_offset())
 874     return;
 875
 876   this->entries_.push_back(Got_entry());
 877   this->set_got_size();
 878   unsigned int got_offset = this->last_got_offset();
 879   gsym->set_got_offset(got_offset);
 880   rela_dyn->add_global(gsym, r_type, this, got_offset, 0);
 881 }
 882
 883 // Add an entry for a local symbol to the GOT.  This returns true if
 884 // this is a new GOT entry, false if the symbol already has a GOT
 885 // entry.
 886
 887 template<int size, bool big_endian>
 888 bool
 889 Output_data_got<size, big_endian>::add_local(
 890     Sized_relobj<size, big_endian>* object,
 891     unsigned int symndx)
 892 {
 893   if (object->local_has_got_offset(symndx))
 894     return false;
 895
 896   this->entries_.push_back(Got_entry(object, symndx));
 897   this->set_got_size();
 898   object->set_local_got_offset(symndx, this->last_got_offset());
 899   return true;
 900 }
 901
 902 // Add an entry for a local symbol to the GOT, and add a dynamic
 903 // relocation of type R_TYPE for the GOT entry.
 904 template<int size, bool big_endian>
 905 void
 906 Output_data_got<size, big_endian>::add_local_with_rel(
 907     Sized_relobj<size, big_endian>* object,
 908     unsigned int symndx,
 909     Rel_dyn* rel_dyn,
 910     unsigned int r_type)
 911 {
 912   if (object->local_has_got_offset(symndx))
 913     return;
 914
 915   this->entries_.push_back(Got_entry());
 916   this->set_got_size();
 917   unsigned int got_offset = this->last_got_offset();
 918   object->set_local_got_offset(symndx, got_offset);
 919   rel_dyn->add_local(object, symndx, r_type, this, got_offset);
 920 }
 921
 922 template<int size, bool big_endian>
 923 void
 924 Output_data_got<size, big_endian>::add_local_with_rela(
 925     Sized_relobj<size, big_endian>* object,
 926     unsigned int symndx,
 927     Rela_dyn* rela_dyn,
 928     unsigned int r_type)
 929 {
 930   if (object->local_has_got_offset(symndx))
 931     return;
 932
 933   this->entries_.push_back(Got_entry());
 934   this->set_got_size();
 935   unsigned int got_offset = this->last_got_offset();
 936   object->set_local_got_offset(symndx, got_offset);
 937   rela_dyn->add_local(object, symndx, r_type, this, got_offset, 0);
 938 }
 939
 940 // Add an entry (or a pair of entries) for a global TLS symbol to the GOT.
 941 // In a pair of entries, the first value in the pair will be used for the
 942 // module index, and the second value will be used for the dtv-relative
 943 // offset. This returns true if this is a new GOT entry, false if the symbol
 944 // already has a GOT entry.
 945
 946 template<int size, bool big_endian>
 947 bool
 948 Output_data_got<size, big_endian>::add_global_tls(Symbol* gsym, bool need_pair)
 949 {
 950   if (gsym->has_tls_got_offset(need_pair))
 951     return false;
 952
 953   this->entries_.push_back(Got_entry(gsym));
 954   gsym->set_tls_got_offset(this->last_got_offset(), need_pair);
 955   if (need_pair)
 956     this->entries_.push_back(Got_entry(gsym));
 957   this->set_got_size();
 958   return true;
 959 }
 960
 961 // Add an entry for a global TLS symbol to the GOT, and add a dynamic
 962 // relocation of type R_TYPE.
 963 template<int size, bool big_endian>
 964 void
 965 Output_data_got<size, big_endian>::add_global_tls_with_rel(
 966     Symbol* gsym,
 967     Rel_dyn* rel_dyn,
 968     unsigned int r_type)
 969 {
 970   if (gsym->has_tls_got_offset(false))
 971     return;
 972
 973   this->entries_.push_back(Got_entry());
 974   this->set_got_size();
 975   unsigned int got_offset = this->last_got_offset();
 976   gsym->set_tls_got_offset(got_offset, false);
 977   rel_dyn->add_global(gsym, r_type, this, got_offset);
 978 }
 979
 980 template<int size, bool big_endian>
 981 void
 982 Output_data_got<size, big_endian>::add_global_tls_with_rela(
 983     Symbol* gsym,
 984     Rela_dyn* rela_dyn,
 985     unsigned int r_type)
 986 {
 987   if (gsym->has_tls_got_offset(false))
 988     return;
 989
 990   this->entries_.push_back(Got_entry());
 991   this->set_got_size();
 992   unsigned int got_offset = this->last_got_offset();
 993   gsym->set_tls_got_offset(got_offset, false);
 994   rela_dyn->add_global(gsym, r_type, this, got_offset, 0);
 995 }
 996
 997 // Add a pair of entries for a global TLS symbol to the GOT, and add
 998 // dynamic relocations of type MOD_R_TYPE and DTV_R_TYPE, respectively.
 999 template<int size, bool big_endian>
1000 void
1001 Output_data_got<size, big_endian>::add_global_tls_with_rel(
1002     Symbol* gsym,
1003     Rel_dyn* rel_dyn,
1004     unsigned int mod_r_type,
1005     unsigned int dtv_r_type)
1006 {
1007   if (gsym->has_tls_got_offset(true))
1008     return;
1009
1010   this->entries_.push_back(Got_entry());
1011   unsigned int got_offset = this->last_got_offset();
1012   gsym->set_tls_got_offset(got_offset, true);
1013   rel_dyn->add_global(gsym, mod_r_type, this, got_offset);
1014
1015   this->entries_.push_back(Got_entry());
1016   this->set_got_size();
1017   got_offset = this->last_got_offset();
1018   rel_dyn->add_global(gsym, dtv_r_type, this, got_offset);
1019 }
1020
1021 template<int size, bool big_endian>
1022 void
1023 Output_data_got<size, big_endian>::add_global_tls_with_rela(
1024     Symbol* gsym,
1025     Rela_dyn* rela_dyn,
1026     unsigned int mod_r_type,
1027     unsigned int dtv_r_type)
1028 {
1029   if (gsym->has_tls_got_offset(true))
1030     return;
1031
1032   this->entries_.push_back(Got_entry());
1033   unsigned int got_offset = this->last_got_offset();
1034   gsym->set_tls_got_offset(got_offset, true);
1035   rela_dyn->add_global(gsym, mod_r_type, this, got_offset, 0);
1036
1037   this->entries_.push_back(Got_entry());
1038   this->set_got_size();
1039   got_offset = this->last_got_offset();
1040   rela_dyn->add_global(gsym, dtv_r_type, this, got_offset, 0);
1041 }
1042
1043 // Add an entry (or a pair of entries) for a local TLS symbol to the GOT.
1044 // In a pair of entries, the first value in the pair will be used for the
1045 // module index, and the second value will be used for the dtv-relative
1046 // offset. This returns true if this is a new GOT entry, false if the symbol
1047 // already has a GOT entry.
1048
1049 template<int size, bool big_endian>
1050 bool
1051 Output_data_got<size, big_endian>::add_local_tls(
1052     Sized_relobj<size, big_endian>* object,
1053     unsigned int symndx,
1054     bool need_pair)
1055 {
1056   if (object->local_has_tls_got_offset(symndx, need_pair))
1057     return false;
1058
1059   this->entries_.push_back(Got_entry(object, symndx));
1060   object->set_local_tls_got_offset(symndx, this->last_got_offset(), need_pair);
1061   if (need_pair)
1062     this->entries_.push_back(Got_entry(object, symndx));
1063   this->set_got_size();
1064   return true;
1065 }
1066
1067 // Add an entry (or pair of entries) for a local TLS symbol to the GOT,
1068 // and add a dynamic relocation of type R_TYPE for the first GOT entry.
1069 // Because this is a local symbol, the first GOT entry can be relocated
1070 // relative to a section symbol, and the second GOT entry will have an
1071 // dtv-relative value that can be computed at link time.
1072 template<int size, bool big_endian>
1073 void
1074 Output_data_got<size, big_endian>::add_local_tls_with_rel(
1075     Sized_relobj<size, big_endian>* object,
1076     unsigned int symndx,
1077     unsigned int shndx,
1078     bool need_pair,
1079     Rel_dyn* rel_dyn,
1080     unsigned int r_type)
1081 {
1082   if (object->local_has_tls_got_offset(symndx, need_pair))
1083     return;
1084
1085   this->entries_.push_back(Got_entry());
1086   unsigned int got_offset = this->last_got_offset();
1087   object->set_local_tls_got_offset(symndx, got_offset, need_pair);
1088   section_offset_type off;
1089   Output_section* os = object->output_section(shndx, &off);
1090   rel_dyn->add_output_section(os, r_type, this, got_offset);
1091
1092   // The second entry of the pair will be statically initialized
1093   // with the TLS offset of the symbol.
1094   if (need_pair)
1095     this->entries_.push_back(Got_entry(object, symndx));
1096
1097   this->set_got_size();
1098 }
1099
1100 template<int size, bool big_endian>
1101 void
1102 Output_data_got<size, big_endian>::add_local_tls_with_rela(
1103     Sized_relobj<size, big_endian>* object,
1104     unsigned int symndx,
1105     unsigned int shndx,
1106     bool need_pair,
1107     Rela_dyn* rela_dyn,
1108     unsigned int r_type)
1109 {
1110   if (object->local_has_tls_got_offset(symndx, need_pair))
1111     return;
1112
1113   this->entries_.push_back(Got_entry());
1114   unsigned int got_offset = this->last_got_offset();
1115   object->set_local_tls_got_offset(symndx, got_offset, need_pair);
1116   section_offset_type off;
1117   Output_section* os = object->output_section(shndx, &off);
1118   rela_dyn->add_output_section(os, r_type, this, got_offset, 0);
1119
1120   // The second entry of the pair will be statically initialized
1121   // with the TLS offset of the symbol.
1122   if (need_pair)
1123     this->entries_.push_back(Got_entry(object, symndx));
1124
1125   this->set_got_size();
1126 }
1127
1128 // Write out the GOT.
1129
1130 template<int size, bool big_endian>
1131 void
1132 Output_data_got<size, big_endian>::do_write(Output_file* of)
1133 {
1134   const int add = size / 8;
1135
1136   const off_t off = this->offset();
1137   const off_t oview_size = this->data_size();
1138   unsigned char* const oview = of->get_output_view(off, oview_size);
1139
1140   unsigned char* pov = oview;
1141   for (typename Got_entries::const_iterator p = this->entries_.begin();
1142        p != this->entries_.end();
1143        ++p)
1144     {
1145       p->write(pov);
1146       pov += add;
1147     }
1148
1149   gold_assert(pov - oview == oview_size);
1150
1151   of->write_output_view(off, oview_size, oview);
1152
1153   // We no longer need the GOT entries.
1154   this->entries_.clear();
1155 }
1156
1157 // Output_data_dynamic::Dynamic_entry methods.
1158
1159 // Write out the entry.
1160
1161 template<int size, bool big_endian>
1162 void
1163 Output_data_dynamic::Dynamic_entry::write(
1164     unsigned char* pov,
1165     const Stringpool* pool
1166     ACCEPT_SIZE_ENDIAN) const
1167 {
1168   typename elfcpp::Elf_types<size>::Elf_WXword val;
1169   switch (this->classification_)
1170     {
1171     case DYNAMIC_NUMBER:
1172       val = this->u_.val;
1173       break;
1174
1175     case DYNAMIC_SECTION_ADDRESS:
1176       val = this->u_.od->address();
1177       break;
1178
1179     case DYNAMIC_SECTION_SIZE:
1180       val = this->u_.od->data_size();
1181       break;
1182
1183     case DYNAMIC_SYMBOL:
1184       {
1185         const Sized_symbol<size>* s =
1186           static_cast<const Sized_symbol<size>*>(this->u_.sym);
1187         val = s->value();
1188       }
1189       break;
1190
1191     case DYNAMIC_STRING:
1192       val = pool->get_offset(this->u_.str);
1193       break;
1194
1195     default:
1196       gold_unreachable();
1197     }
1198
1199   elfcpp::Dyn_write<size, big_endian> dw(pov);
1200   dw.put_d_tag(this->tag_);
1201   dw.put_d_val(val);
1202 }
1203
1204 // Output_data_dynamic methods.
1205
1206 // Adjust the output section to set the entry size.
1207
1208 void
1209 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1210 {
1211   if (parameters->get_size() == 32)
1212     os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1213   else if (parameters->get_size() == 64)
1214     os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1215   else
1216     gold_unreachable();
1217 }
1218
1219 // Set the final data size.
1220
1221 void
1222 Output_data_dynamic::set_final_data_size()
1223 {
1224   // Add the terminating entry.
1225   this->add_constant(elfcpp::DT_NULL, 0);
1226
1227   int dyn_size;
1228   if (parameters->get_size() == 32)
1229     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1230   else if (parameters->get_size() == 64)
1231     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1232   else
1233     gold_unreachable();
1234   this->set_data_size(this->entries_.size() * dyn_size);
1235 }
1236
1237 // Write out the dynamic entries.
1238
1239 void
1240 Output_data_dynamic::do_write(Output_file* of)
1241 {
1242   if (parameters->get_size() == 32)
1243     {
1244       if (parameters->is_big_endian())
1245         {
1246 #ifdef HAVE_TARGET_32_BIG
1247           this->sized_write<32, true>(of);
1248 #else
1249           gold_unreachable();
1250 #endif
1251         }
1252       else
1253         {
1254 #ifdef HAVE_TARGET_32_LITTLE
1255           this->sized_write<32, false>(of);
1256 #else
1257           gold_unreachable();
1258 #endif
1259         }
1260     }
1261   else if (parameters->get_size() == 64)
1262     {
1263       if (parameters->is_big_endian())
1264         {
1265 #ifdef HAVE_TARGET_64_BIG
1266           this->sized_write<64, true>(of);
1267 #else
1268           gold_unreachable();
1269 #endif
1270         }
1271       else
1272         {
1273 #ifdef HAVE_TARGET_64_LITTLE
1274           this->sized_write<64, false>(of);
1275 #else
1276           gold_unreachable();
1277 #endif
1278         }
1279     }
1280   else
1281     gold_unreachable();
1282 }
1283
1284 template<int size, bool big_endian>
1285 void
1286 Output_data_dynamic::sized_write(Output_file* of)
1287 {
1288   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1289
1290   const off_t offset = this->offset();
1291   const off_t oview_size = this->data_size();
1292   unsigned char* const oview = of->get_output_view(offset, oview_size);
1293
1294   unsigned char* pov = oview;
1295   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
1296        p != this->entries_.end();
1297        ++p)
1298     {
1299       p->write SELECT_SIZE_ENDIAN_NAME(size, big_endian)(
1300           pov, this->pool_ SELECT_SIZE_ENDIAN(size, big_endian));
1301       pov += dyn_size;
1302     }
1303
1304   gold_assert(pov - oview == oview_size);
1305
1306   of->write_output_view(offset, oview_size, oview);
1307
1308   // We no longer need the dynamic entries.
1309   this->entries_.clear();
1310 }
1311
1312 // Output_section::Input_section methods.
1313
1314 // Return the data size.  For an input section we store the size here.
1315 // For an Output_section_data, we have to ask it for the size.
1316
1317 off_t
1318 Output_section::Input_section::data_size() const
1319 {
1320   if (this->is_input_section())
1321     return this->u1_.data_size;
1322   else
1323     return this->u2_.posd->data_size();
1324 }
1325
1326 // Set the address and file offset.
1327
1328 void
1329 Output_section::Input_section::set_address_and_file_offset(
1330     uint64_t address,
1331     off_t file_offset,
1332     off_t section_file_offset)
1333 {
1334   if (this->is_input_section())
1335     this->u2_.object->set_section_offset(this->shndx_,
1336                                          file_offset - section_file_offset);
1337   else
1338     this->u2_.posd->set_address_and_file_offset(address, file_offset);
1339 }
1340
1341 // Finalize the data size.
1342
1343 void
1344 Output_section::Input_section::finalize_data_size()
1345 {
1346   if (!this->is_input_section())
1347     this->u2_.posd->finalize_data_size();
1348 }
1349
1350 // Try to turn an input offset into an output offset.  We want to
1351 // return the output offset relative to the start of this
1352 // Input_section in the output section.
1353
1354 inline bool
1355 Output_section::Input_section::output_offset(
1356     const Relobj* object,
1357     unsigned int shndx,
1358     section_offset_type offset,
1359     section_offset_type *poutput) const
1360 {
1361   if (!this->is_input_section())
1362     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
1363   else
1364     {
1365       if (this->shndx_ != shndx || this->u2_.object != object)
1366         return false;
1367       *poutput = offset;
1368       return true;
1369     }
1370 }
1371
1372 // Return whether this is the merge section for the input section
1373 // SHNDX in OBJECT.
1374
1375 inline bool
1376 Output_section::Input_section::is_merge_section_for(const Relobj* object,
1377                                                     unsigned int shndx) const
1378 {
1379   if (this->is_input_section())
1380     return false;
1381   return this->u2_.posd->is_merge_section_for(object, shndx);
1382 }
1383
1384 // Write out the data.  We don't have to do anything for an input
1385 // section--they are handled via Object::relocate--but this is where
1386 // we write out the data for an Output_section_data.
1387
1388 void
1389 Output_section::Input_section::write(Output_file* of)
1390 {
1391   if (!this->is_input_section())
1392     this->u2_.posd->write(of);
1393 }
1394
1395 // Write the data to a buffer.  As for write(), we don't have to do
1396 // anything for an input section.
1397
1398 void
1399 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
1400 {
1401   if (!this->is_input_section())
1402     this->u2_.posd->write_to_buffer(buffer);
1403 }
1404
1405 // Output_section methods.
1406
1407 // Construct an Output_section.  NAME will point into a Stringpool.
1408
1409 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
1410                                elfcpp::Elf_Xword flags)
1411   : name_(name),
1412     addralign_(0),
1413     entsize_(0),
1414     link_section_(NULL),
1415     link_(0),
1416     info_section_(NULL),
1417     info_(0),
1418     type_(type),
1419     flags_(flags),
1420     out_shndx_(-1U),
1421     symtab_index_(0),
1422     dynsym_index_(0),
1423     input_sections_(),
1424     first_input_offset_(0),
1425     fills_(),
1426     postprocessing_buffer_(NULL),
1427     needs_symtab_index_(false),
1428     needs_dynsym_index_(false),
1429     should_link_to_symtab_(false),
1430     should_link_to_dynsym_(false),
1431     after_input_sections_(false),
1432     requires_postprocessing_(false),
1433     tls_offset_(0)
1434 {
1435   // An unallocated section has no address.  Forcing this means that
1436   // we don't need special treatment for symbols defined in debug
1437   // sections.
1438   if ((flags & elfcpp::SHF_ALLOC) == 0)
1439     this->set_address(0);
1440 }
1441
1442 Output_section::~Output_section()
1443 {
1444 }
1445
1446 // Set the entry size.
1447
1448 void
1449 Output_section::set_entsize(uint64_t v)
1450 {
1451   if (this->entsize_ == 0)
1452     this->entsize_ = v;
1453   else
1454     gold_assert(this->entsize_ == v);
1455 }
1456
1457 // Add the input section SHNDX, with header SHDR, named SECNAME, in
1458 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
1459 // relocation section which applies to this section, or 0 if none, or
1460 // -1U if more than one.  Return the offset of the input section
1461 // within the output section.  Return -1 if the input section will
1462 // receive special handling.  In the normal case we don't always keep
1463 // track of input sections for an Output_section.  Instead, each
1464 // Object keeps track of the Output_section for each of its input
1465 // sections.
1466
1467 template<int size, bool big_endian>
1468 off_t
1469 Output_section::add_input_section(Sized_relobj<size, big_endian>* object,
1470                                   unsigned int shndx,
1471                                   const char* secname,
1472                                   const elfcpp::Shdr<size, big_endian>& shdr,
1473                                   unsigned int reloc_shndx)
1474 {
1475   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
1476   if ((addralign & (addralign - 1)) != 0)
1477     {
1478       object->error(_("invalid alignment %lu for section \"%s\""),
1479                     static_cast<unsigned long>(addralign), secname);
1480       addralign = 1;
1481     }
1482
1483   if (addralign > this->addralign_)
1484     this->addralign_ = addralign;
1485
1486   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
1487   uint64_t entsize = shdr.get_sh_entsize();
1488
1489   // .debug_str is a mergeable string section, but is not always so
1490   // marked by compilers.  Mark manually here so we can optimize.
1491   if (strcmp(secname, ".debug_str") == 0)
1492     {
1493       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
1494       entsize = 1;
1495     }
1496
1497   // If this is a SHF_MERGE section, we pass all the input sections to
1498   // a Output_data_merge.  We don't try to handle relocations for such
1499   // a section.
1500   if ((sh_flags & elfcpp::SHF_MERGE) != 0
1501       && reloc_shndx == 0)
1502     {
1503       if (this->add_merge_input_section(object, shndx, sh_flags,
1504                                         entsize, addralign))
1505         {
1506           // Tell the relocation routines that they need to call the
1507           // output_offset method to determine the final address.
1508           return -1;
1509         }
1510     }
1511
1512   off_t offset_in_section = this->current_data_size_for_child();
1513   off_t aligned_offset_in_section = align_address(offset_in_section,
1514                                                   addralign);
1515
1516   if (aligned_offset_in_section > offset_in_section
1517       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
1518       && object->target()->has_code_fill())
1519     {
1520       // We need to add some fill data.  Using fill_list_ when
1521       // possible is an optimization, since we will often have fill
1522       // sections without input sections.
1523       off_t fill_len = aligned_offset_in_section - offset_in_section;
1524       if (this->input_sections_.empty())
1525         this->fills_.push_back(Fill(offset_in_section, fill_len));
1526       else
1527         {
1528           // FIXME: When relaxing, the size needs to adjust to
1529           // maintain a constant alignment.
1530           std::string fill_data(object->target()->code_fill(fill_len));
1531           Output_data_const* odc = new Output_data_const(fill_data, 1);
1532           this->input_sections_.push_back(Input_section(odc));
1533         }
1534     }
1535
1536   this->set_current_data_size_for_child(aligned_offset_in_section
1537                                         + shdr.get_sh_size());
1538
1539   // We need to keep track of this section if we are already keeping
1540   // track of sections, or if we are relaxing.  FIXME: Add test for
1541   // relaxing.
1542   if (!this->input_sections_.empty())
1543     this->input_sections_.push_back(Input_section(object, shndx,
1544                                                   shdr.get_sh_size(),
1545                                                   addralign));
1546
1547   return aligned_offset_in_section;
1548 }
1549
1550 // Add arbitrary data to an output section.
1551
1552 void
1553 Output_section::add_output_section_data(Output_section_data* posd)
1554 {
1555   Input_section inp(posd);
1556   this->add_output_section_data(&inp);
1557 }
1558
1559 // Add arbitrary data to an output section by Input_section.
1560
1561 void
1562 Output_section::add_output_section_data(Input_section* inp)
1563 {
1564   if (this->input_sections_.empty())
1565     this->first_input_offset_ = this->current_data_size_for_child();
1566
1567   this->input_sections_.push_back(*inp);
1568
1569   uint64_t addralign = inp->addralign();
1570   if (addralign > this->addralign_)
1571     this->addralign_ = addralign;
1572
1573   inp->set_output_section(this);
1574 }
1575
1576 // Add a merge section to an output section.
1577
1578 void
1579 Output_section::add_output_merge_section(Output_section_data* posd,
1580                                          bool is_string, uint64_t entsize)
1581 {
1582   Input_section inp(posd, is_string, entsize);
1583   this->add_output_section_data(&inp);
1584 }
1585
1586 // Add an input section to a SHF_MERGE section.
1587
1588 bool
1589 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
1590                                         uint64_t flags, uint64_t entsize,
1591                                         uint64_t addralign)
1592 {
1593   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
1594
1595   // We only merge strings if the alignment is not more than the
1596   // character size.  This could be handled, but it's unusual.
1597   if (is_string && addralign > entsize)
1598     return false;
1599
1600   Input_section_list::iterator p;
1601   for (p = this->input_sections_.begin();
1602        p != this->input_sections_.end();
1603        ++p)
1604     if (p->is_merge_section(is_string, entsize, addralign))
1605       {
1606         p->add_input_section(object, shndx);
1607         return true;
1608       }
1609
1610   // We handle the actual constant merging in Output_merge_data or
1611   // Output_merge_string_data.
1612   Output_section_data* posd;
1613   if (!is_string)
1614     posd = new Output_merge_data(entsize, addralign);
1615   else
1616     {
1617       switch (entsize)
1618         {
1619         case 1:
1620           posd = new Output_merge_string<char>(addralign);
1621           break;
1622         case 2:
1623           posd = new Output_merge_string<uint16_t>(addralign);
1624           break;
1625         case 4:
1626           posd = new Output_merge_string<uint32_t>(addralign);
1627           break;
1628         default:
1629           return false;
1630         }
1631     }
1632
1633   this->add_output_merge_section(posd, is_string, entsize);
1634   posd->add_input_section(object, shndx);
1635
1636   return true;
1637 }
1638
1639 // Given an address OFFSET relative to the start of input section
1640 // SHNDX in OBJECT, return whether this address is being included in
1641 // the final link.  This should only be called if SHNDX in OBJECT has
1642 // a special mapping.
1643
1644 bool
1645 Output_section::is_input_address_mapped(const Relobj* object,
1646                                         unsigned int shndx,
1647                                         off_t offset) const
1648 {
1649   gold_assert(object->is_section_specially_mapped(shndx));
1650
1651   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1652        p != this->input_sections_.end();
1653        ++p)
1654     {
1655       section_offset_type output_offset;
1656       if (p->output_offset(object, shndx, offset, &output_offset))
1657         return output_offset != -1;
1658     }
1659
1660   // By default we assume that the address is mapped.  This should
1661   // only be called after we have passed all sections to Layout.  At
1662   // that point we should know what we are discarding.
1663   return true;
1664 }
1665
1666 // Given an address OFFSET relative to the start of input section
1667 // SHNDX in object OBJECT, return the output offset relative to the
1668 // start of the input section in the output section.  This should only
1669 // be called if SHNDX in OBJECT has a special mapping.
1670
1671 section_offset_type
1672 Output_section::output_offset(const Relobj* object, unsigned int shndx,
1673                               section_offset_type offset) const
1674 {
1675   gold_assert(object->is_section_specially_mapped(shndx));
1676   // This can only be called meaningfully when layout is complete.
1677   gold_assert(Output_data::is_layout_complete());
1678
1679   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1680        p != this->input_sections_.end();
1681        ++p)
1682     {
1683       section_offset_type output_offset;
1684       if (p->output_offset(object, shndx, offset, &output_offset))
1685         return output_offset;
1686     }
1687   gold_unreachable();
1688 }
1689
1690 // Return the output virtual address of OFFSET relative to the start
1691 // of input section SHNDX in object OBJECT.
1692
1693 uint64_t
1694 Output_section::output_address(const Relobj* object, unsigned int shndx,
1695                                off_t offset) const
1696 {
1697   gold_assert(object->is_section_specially_mapped(shndx));
1698
1699   uint64_t addr = this->address() + this->first_input_offset_;
1700   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1701        p != this->input_sections_.end();
1702        ++p)
1703     {
1704       addr = align_address(addr, p->addralign());
1705       section_offset_type output_offset;
1706       if (p->output_offset(object, shndx, offset, &output_offset))
1707         {
1708           if (output_offset == -1)
1709             return -1U;
1710           return addr + output_offset;
1711         }
1712       addr += p->data_size();
1713     }
1714
1715   // If we get here, it means that we don't know the mapping for this
1716   // input section.  This might happen in principle if
1717   // add_input_section were called before add_output_section_data.
1718   // But it should never actually happen.
1719
1720   gold_unreachable();
1721 }
1722
1723 // Return the output address of the start of the merged section for
1724 // input section SHNDX in object OBJECT.
1725
1726 uint64_t
1727 Output_section::starting_output_address(const Relobj* object,
1728                                         unsigned int shndx) const
1729 {
1730   gold_assert(object->is_section_specially_mapped(shndx));
1731
1732   uint64_t addr = this->address() + this->first_input_offset_;
1733   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1734        p != this->input_sections_.end();
1735        ++p)
1736     {
1737       addr = align_address(addr, p->addralign());
1738
1739       // It would be nice if we could use the existing output_offset
1740       // method to get the output offset of input offset 0.
1741       // Unfortunately we don't know for sure that input offset 0 is
1742       // mapped at all.
1743       if (p->is_merge_section_for(object, shndx))
1744         return addr;
1745
1746       addr += p->data_size();
1747     }
1748   gold_unreachable();
1749 }
1750
1751 // Set the data size of an Output_section.  This is where we handle
1752 // setting the addresses of any Output_section_data objects.
1753
1754 void
1755 Output_section::set_final_data_size()
1756 {
1757   if (this->input_sections_.empty())
1758     {
1759       this->set_data_size(this->current_data_size_for_child());
1760       return;
1761     }
1762
1763   uint64_t address = this->address();
1764   off_t startoff = this->offset();
1765   off_t off = startoff + this->first_input_offset_;
1766   for (Input_section_list::iterator p = this->input_sections_.begin();
1767        p != this->input_sections_.end();
1768        ++p)
1769     {
1770       off = align_address(off, p->addralign());
1771       p->set_address_and_file_offset(address + (off - startoff), off,
1772                                      startoff);
1773       off += p->data_size();
1774     }
1775
1776   this->set_data_size(off - startoff);
1777 }
1778
1779 // Set the TLS offset.  Called only for SHT_TLS sections.
1780
1781 void
1782 Output_section::do_set_tls_offset(uint64_t tls_base)
1783 {
1784   this->tls_offset_ = this->address() - tls_base;
1785 }
1786
1787 // Write the section header to *OSHDR.
1788
1789 template<int size, bool big_endian>
1790 void
1791 Output_section::write_header(const Layout* layout,
1792                              const Stringpool* secnamepool,
1793                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
1794 {
1795   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
1796   oshdr->put_sh_type(this->type_);
1797   oshdr->put_sh_flags(this->flags_);
1798   oshdr->put_sh_addr(this->address());
1799   oshdr->put_sh_offset(this->offset());
1800   oshdr->put_sh_size(this->data_size());
1801   if (this->link_section_ != NULL)
1802     oshdr->put_sh_link(this->link_section_->out_shndx());
1803   else if (this->should_link_to_symtab_)
1804     oshdr->put_sh_link(layout->symtab_section()->out_shndx());
1805   else if (this->should_link_to_dynsym_)
1806     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
1807   else
1808     oshdr->put_sh_link(this->link_);
1809   if (this->info_section_ != NULL)
1810     oshdr->put_sh_info(this->info_section_->out_shndx());
1811   else
1812     oshdr->put_sh_info(this->info_);
1813   oshdr->put_sh_addralign(this->addralign_);
1814   oshdr->put_sh_entsize(this->entsize_);
1815 }
1816
1817 // Write out the data.  For input sections the data is written out by
1818 // Object::relocate, but we have to handle Output_section_data objects
1819 // here.
1820
1821 void
1822 Output_section::do_write(Output_file* of)
1823 {
1824   gold_assert(!this->requires_postprocessing());
1825
1826   off_t output_section_file_offset = this->offset();
1827   for (Fill_list::iterator p = this->fills_.begin();
1828        p != this->fills_.end();
1829        ++p)
1830     {
1831       std::string fill_data(of->target()->code_fill(p->length()));
1832       of->write(output_section_file_offset + p->section_offset(),
1833                 fill_data.data(), fill_data.size());
1834     }
1835
1836   for (Input_section_list::iterator p = this->input_sections_.begin();
1837        p != this->input_sections_.end();
1838        ++p)
1839     p->write(of);
1840 }
1841
1842 // If a section requires postprocessing, create the buffer to use.
1843
1844 void
1845 Output_section::create_postprocessing_buffer()
1846 {
1847   gold_assert(this->requires_postprocessing());
1848   gold_assert(this->postprocessing_buffer_ == NULL);
1849
1850   if (!this->input_sections_.empty())
1851     {
1852       off_t off = this->first_input_offset_;
1853       for (Input_section_list::iterator p = this->input_sections_.begin();
1854            p != this->input_sections_.end();
1855            ++p)
1856         {
1857           off = align_address(off, p->addralign());
1858           p->finalize_data_size();
1859           off += p->data_size();
1860         }
1861       this->set_current_data_size_for_child(off);
1862     }
1863
1864   off_t buffer_size = this->current_data_size_for_child();
1865   this->postprocessing_buffer_ = new unsigned char[buffer_size];
1866 }
1867
1868 // Write all the data of an Output_section into the postprocessing
1869 // buffer.  This is used for sections which require postprocessing,
1870 // such as compression.  Input sections are handled by
1871 // Object::Relocate.
1872
1873 void
1874 Output_section::write_to_postprocessing_buffer()
1875 {
1876   gold_assert(this->requires_postprocessing());
1877
1878   Target* target = parameters->target();
1879   unsigned char* buffer = this->postprocessing_buffer();
1880   for (Fill_list::iterator p = this->fills_.begin();
1881        p != this->fills_.end();
1882        ++p)
1883     {
1884       std::string fill_data(target->code_fill(p->length()));
1885       memcpy(buffer + p->section_offset(), fill_data.data(), fill_data.size());
1886     }
1887
1888   off_t off = this->first_input_offset_;
1889   for (Input_section_list::iterator p = this->input_sections_.begin();
1890        p != this->input_sections_.end();
1891        ++p)
1892     {
1893       off = align_address(off, p->addralign());
1894       p->write_to_buffer(buffer + off);
1895       off += p->data_size();
1896     }
1897 }
1898
1899 // Print stats for merge sections to stderr.
1900
1901 void
1902 Output_section::print_merge_stats()
1903 {
1904   Input_section_list::iterator p;
1905   for (p = this->input_sections_.begin();
1906        p != this->input_sections_.end();
1907        ++p)
1908     p->print_merge_stats(this->name_);
1909 }
1910
1911 // Output segment methods.
1912
1913 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
1914   : output_data_(),
1915     output_bss_(),
1916     vaddr_(0),
1917     paddr_(0),
1918     memsz_(0),
1919     align_(0),
1920     offset_(0),
1921     filesz_(0),
1922     type_(type),
1923     flags_(flags),
1924     is_align_known_(false)
1925 {
1926 }
1927
1928 // Add an Output_section to an Output_segment.
1929
1930 void
1931 Output_segment::add_output_section(Output_section* os,
1932                                    elfcpp::Elf_Word seg_flags,
1933                                    bool front)
1934 {
1935   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
1936   gold_assert(!this->is_align_known_);
1937
1938   // Update the segment flags.
1939   this->flags_ |= seg_flags;
1940
1941   Output_segment::Output_data_list* pdl;
1942   if (os->type() == elfcpp::SHT_NOBITS)
1943     pdl = &this->output_bss_;
1944   else
1945     pdl = &this->output_data_;
1946
1947   // So that PT_NOTE segments will work correctly, we need to ensure
1948   // that all SHT_NOTE sections are adjacent.  This will normally
1949   // happen automatically, because all the SHT_NOTE input sections
1950   // will wind up in the same output section.  However, it is possible
1951   // for multiple SHT_NOTE input sections to have different section
1952   // flags, and thus be in different output sections, but for the
1953   // different section flags to map into the same segment flags and
1954   // thus the same output segment.
1955
1956   // Note that while there may be many input sections in an output
1957   // section, there are normally only a few output sections in an
1958   // output segment.  This loop is expected to be fast.
1959
1960   if (os->type() == elfcpp::SHT_NOTE && !pdl->empty())
1961     {
1962       Output_segment::Output_data_list::iterator p = pdl->end();
1963       do
1964         {
1965           --p;
1966           if ((*p)->is_section_type(elfcpp::SHT_NOTE))
1967             {
1968               // We don't worry about the FRONT parameter.
1969               ++p;
1970               pdl->insert(p, os);
1971               return;
1972             }
1973         }
1974       while (p != pdl->begin());
1975     }
1976
1977   // Similarly, so that PT_TLS segments will work, we need to group
1978   // SHF_TLS sections.  An SHF_TLS/SHT_NOBITS section is a special
1979   // case: we group the SHF_TLS/SHT_NOBITS sections right after the
1980   // SHF_TLS/SHT_PROGBITS sections.  This lets us set up PT_TLS
1981   // correctly.  SHF_TLS sections get added to both a PT_LOAD segment
1982   // and the PT_TLS segment -- we do this grouping only for the
1983   // PT_LOAD segment.
1984   if (this->type_ != elfcpp::PT_TLS
1985       && (os->flags() & elfcpp::SHF_TLS) != 0
1986       && !this->output_data_.empty())
1987     {
1988       pdl = &this->output_data_;
1989       bool nobits = os->type() == elfcpp::SHT_NOBITS;
1990       bool sawtls = false;
1991       Output_segment::Output_data_list::iterator p = pdl->end();
1992       do
1993         {
1994           --p;
1995           bool insert;
1996           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
1997             {
1998               sawtls = true;
1999               // Put a NOBITS section after the first TLS section.
2000               // But a PROGBITS section after the first TLS/PROGBITS
2001               // section.
2002               insert = nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS);
2003             }
2004           else
2005             {
2006               // If we've gone past the TLS sections, but we've seen a
2007               // TLS section, then we need to insert this section now.
2008               insert = sawtls;
2009             }
2010
2011           if (insert)
2012             {
2013               // We don't worry about the FRONT parameter.
2014               ++p;
2015               pdl->insert(p, os);
2016               return;
2017             }
2018         }
2019       while (p != pdl->begin());
2020
2021       // There are no TLS sections yet; put this one at the requested
2022       // location in the section list.
2023     }
2024
2025   if (front)
2026     pdl->push_front(os);
2027   else
2028     pdl->push_back(os);
2029 }
2030
2031 // Add an Output_data (which is not an Output_section) to the start of
2032 // a segment.
2033
2034 void
2035 Output_segment::add_initial_output_data(Output_data* od)
2036 {
2037   gold_assert(!this->is_align_known_);
2038   this->output_data_.push_front(od);
2039 }
2040
2041 // Return the maximum alignment of the Output_data in Output_segment.
2042 // Once we compute this, we prohibit new sections from being added.
2043
2044 uint64_t
2045 Output_segment::addralign()
2046 {
2047   if (!this->is_align_known_)
2048     {
2049       uint64_t addralign;
2050
2051       addralign = Output_segment::maximum_alignment(&this->output_data_);
2052       if (addralign > this->align_)
2053         this->align_ = addralign;
2054
2055       addralign = Output_segment::maximum_alignment(&this->output_bss_);
2056       if (addralign > this->align_)
2057         this->align_ = addralign;
2058
2059       this->is_align_known_ = true;
2060     }
2061
2062   return this->align_;
2063 }
2064
2065 // Return the maximum alignment of a list of Output_data.
2066
2067 uint64_t
2068 Output_segment::maximum_alignment(const Output_data_list* pdl)
2069 {
2070   uint64_t ret = 0;
2071   for (Output_data_list::const_iterator p = pdl->begin();
2072        p != pdl->end();
2073        ++p)
2074     {
2075       uint64_t addralign = (*p)->addralign();
2076       if (addralign > ret)
2077         ret = addralign;
2078     }
2079   return ret;
2080 }
2081
2082 // Return the number of dynamic relocs applied to this segment.
2083
2084 unsigned int
2085 Output_segment::dynamic_reloc_count() const
2086 {
2087   return (this->dynamic_reloc_count_list(&this->output_data_)
2088           + this->dynamic_reloc_count_list(&this->output_bss_));
2089 }
2090
2091 // Return the number of dynamic relocs applied to an Output_data_list.
2092
2093 unsigned int
2094 Output_segment::dynamic_reloc_count_list(const Output_data_list* pdl) const
2095 {
2096   unsigned int count = 0;
2097   for (Output_data_list::const_iterator p = pdl->begin();
2098        p != pdl->end();
2099        ++p)
2100     count += (*p)->dynamic_reloc_count();
2101   return count;
2102 }
2103
2104 // Set the section addresses for an Output_segment.  ADDR is the
2105 // address and *POFF is the file offset.  Set the section indexes
2106 // starting with *PSHNDX.  Return the address of the immediately
2107 // following segment.  Update *POFF and *PSHNDX.
2108
2109 uint64_t
2110 Output_segment::set_section_addresses(uint64_t addr, off_t* poff,
2111                                       unsigned int* pshndx)
2112 {
2113   gold_assert(this->type_ == elfcpp::PT_LOAD);
2114
2115   this->vaddr_ = addr;
2116   this->paddr_ = addr;
2117
2118   off_t orig_off = *poff;
2119   this->offset_ = orig_off;
2120
2121   *poff = align_address(*poff, this->addralign());
2122
2123   addr = this->set_section_list_addresses(&this->output_data_, addr, poff,
2124                                           pshndx);
2125   this->filesz_ = *poff - orig_off;
2126
2127   off_t off = *poff;
2128
2129   uint64_t ret = this->set_section_list_addresses(&this->output_bss_, addr,
2130                                                   poff, pshndx);
2131   this->memsz_ = *poff - orig_off;
2132
2133   // Ignore the file offset adjustments made by the BSS Output_data
2134   // objects.
2135   *poff = off;
2136
2137   return ret;
2138 }
2139
2140 // Set the addresses and file offsets in a list of Output_data
2141 // structures.
2142
2143 uint64_t
2144 Output_segment::set_section_list_addresses(Output_data_list* pdl,
2145                                            uint64_t addr, off_t* poff,
2146                                            unsigned int* pshndx)
2147 {
2148   off_t startoff = *poff;
2149
2150   off_t off = startoff;
2151   for (Output_data_list::iterator p = pdl->begin();
2152        p != pdl->end();
2153        ++p)
2154     {
2155       off = align_address(off, (*p)->addralign());
2156       (*p)->set_address_and_file_offset(addr + (off - startoff), off);
2157
2158       // Unless this is a PT_TLS segment, we want to ignore the size
2159       // of a SHF_TLS/SHT_NOBITS section.  Such a section does not
2160       // affect the size of a PT_LOAD segment.
2161       if (this->type_ == elfcpp::PT_TLS
2162           || !(*p)->is_section_flag_set(elfcpp::SHF_TLS)
2163           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
2164         off += (*p)->data_size();
2165
2166       if ((*p)->is_section())
2167         {
2168           (*p)->set_out_shndx(*pshndx);
2169           ++*pshndx;
2170         }
2171     }
2172
2173   *poff = off;
2174   return addr + (off - startoff);
2175 }
2176
2177 // For a non-PT_LOAD segment, set the offset from the sections, if
2178 // any.
2179
2180 void
2181 Output_segment::set_offset()
2182 {
2183   gold_assert(this->type_ != elfcpp::PT_LOAD);
2184
2185   if (this->output_data_.empty() && this->output_bss_.empty())
2186     {
2187       this->vaddr_ = 0;
2188       this->paddr_ = 0;
2189       this->memsz_ = 0;
2190       this->align_ = 0;
2191       this->offset_ = 0;
2192       this->filesz_ = 0;
2193       return;
2194     }
2195
2196   const Output_data* first;
2197   if (this->output_data_.empty())
2198     first = this->output_bss_.front();
2199   else
2200     first = this->output_data_.front();
2201   this->vaddr_ = first->address();
2202   this->paddr_ = this->vaddr_;
2203   this->offset_ = first->offset();
2204
2205   if (this->output_data_.empty())
2206     this->filesz_ = 0;
2207   else
2208     {
2209       const Output_data* last_data = this->output_data_.back();
2210       this->filesz_ = (last_data->address()
2211                        + last_data->data_size()
2212                        - this->vaddr_);
2213     }
2214
2215   const Output_data* last;
2216   if (this->output_bss_.empty())
2217     last = this->output_data_.back();
2218   else
2219     last = this->output_bss_.back();
2220   this->memsz_ = (last->address()
2221                   + last->data_size()
2222                   - this->vaddr_);
2223 }
2224
2225 // Set the TLS offsets of the sections in the PT_TLS segment.
2226
2227 void
2228 Output_segment::set_tls_offsets()
2229 {
2230   gold_assert(this->type_ == elfcpp::PT_TLS);
2231
2232   for (Output_data_list::iterator p = this->output_data_.begin();
2233        p != this->output_data_.end();
2234        ++p)
2235     (*p)->set_tls_offset(this->vaddr_);
2236
2237   for (Output_data_list::iterator p = this->output_bss_.begin();
2238        p != this->output_bss_.end();
2239        ++p)
2240     (*p)->set_tls_offset(this->vaddr_);
2241 }
2242
2243 // Return the number of Output_sections in an Output_segment.
2244
2245 unsigned int
2246 Output_segment::output_section_count() const
2247 {
2248   return (this->output_section_count_list(&this->output_data_)
2249           + this->output_section_count_list(&this->output_bss_));
2250 }
2251
2252 // Return the number of Output_sections in an Output_data_list.
2253
2254 unsigned int
2255 Output_segment::output_section_count_list(const Output_data_list* pdl) const
2256 {
2257   unsigned int count = 0;
2258   for (Output_data_list::const_iterator p = pdl->begin();
2259        p != pdl->end();
2260        ++p)
2261     {
2262       if ((*p)->is_section())
2263         ++count;
2264     }
2265   return count;
2266 }
2267
2268 // Write the segment data into *OPHDR.
2269
2270 template<int size, bool big_endian>
2271 void
2272 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
2273 {
2274   ophdr->put_p_type(this->type_);
2275   ophdr->put_p_offset(this->offset_);
2276   ophdr->put_p_vaddr(this->vaddr_);
2277   ophdr->put_p_paddr(this->paddr_);
2278   ophdr->put_p_filesz(this->filesz_);
2279   ophdr->put_p_memsz(this->memsz_);
2280   ophdr->put_p_flags(this->flags_);
2281   ophdr->put_p_align(this->addralign());
2282 }
2283
2284 // Write the section headers into V.
2285
2286 template<int size, bool big_endian>
2287 unsigned char*
2288 Output_segment::write_section_headers(const Layout* layout,
2289                                       const Stringpool* secnamepool,
2290                                       unsigned char* v,
2291                                       unsigned int *pshndx
2292                                       ACCEPT_SIZE_ENDIAN) const
2293 {
2294   // Every section that is attached to a segment must be attached to a
2295   // PT_LOAD segment, so we only write out section headers for PT_LOAD
2296   // segments.
2297   if (this->type_ != elfcpp::PT_LOAD)
2298     return v;
2299
2300   v = this->write_section_headers_list
2301       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
2302           layout, secnamepool, &this->output_data_, v, pshndx
2303           SELECT_SIZE_ENDIAN(size, big_endian));
2304   v = this->write_section_headers_list
2305       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
2306           layout, secnamepool, &this->output_bss_, v, pshndx
2307           SELECT_SIZE_ENDIAN(size, big_endian));
2308   return v;
2309 }
2310
2311 template<int size, bool big_endian>
2312 unsigned char*
2313 Output_segment::write_section_headers_list(const Layout* layout,
2314                                            const Stringpool* secnamepool,
2315                                            const Output_data_list* pdl,
2316                                            unsigned char* v,
2317                                            unsigned int* pshndx
2318                                            ACCEPT_SIZE_ENDIAN) const
2319 {
2320   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2321   for (Output_data_list::const_iterator p = pdl->begin();
2322        p != pdl->end();
2323        ++p)
2324     {
2325       if ((*p)->is_section())
2326         {
2327           const Output_section* ps = static_cast<const Output_section*>(*p);
2328           gold_assert(*pshndx == ps->out_shndx());
2329           elfcpp::Shdr_write<size, big_endian> oshdr(v);
2330           ps->write_header(layout, secnamepool, &oshdr);
2331           v += shdr_size;
2332           ++*pshndx;
2333         }
2334     }
2335   return v;
2336 }
2337
2338 // Output_file methods.
2339
2340 Output_file::Output_file(const General_options& options, Target* target)
2341   : options_(options),
2342     target_(target),
2343     name_(options.output_file_name()),
2344     o_(-1),
2345     file_size_(0),
2346     base_(NULL),
2347     map_is_anonymous_(false)
2348 {
2349 }
2350
2351 // Open the output file.
2352
2353 void
2354 Output_file::open(off_t file_size)
2355 {
2356   this->file_size_ = file_size;
2357
2358   // Unlink the file first; otherwise the open() may fail if the file
2359   // is busy (e.g. it's an executable that's currently being executed).
2360   //
2361   // However, the linker may be part of a system where a zero-length
2362   // file is created for it to write to, with tight permissions (gcc
2363   // 2.95 did something like this).  Unlinking the file would work
2364   // around those permission controls, so we only unlink if the file
2365   // has a non-zero size.  We also unlink only regular files to avoid
2366   // trouble with directories/etc.
2367   //
2368   // If we fail, continue; this command is merely a best-effort attempt
2369   // to improve the odds for open().
2370
2371   // We let the name "-" mean "stdout"
2372   if (strcmp(this->name_, "-") == 0)
2373     this->o_ = STDOUT_FILENO;
2374   else
2375     {
2376       struct stat s;
2377       if (::stat(this->name_, &s) == 0 && s.st_size != 0)
2378         unlink_if_ordinary(this->name_);
2379
2380       int mode = parameters->output_is_object() ? 0666 : 0777;
2381       int o = ::open(this->name_, O_RDWR | O_CREAT | O_TRUNC, mode);
2382       if (o < 0)
2383         gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
2384       this->o_ = o;
2385     }
2386
2387   this->map();
2388 }
2389
2390 // Resize the output file.
2391
2392 void
2393 Output_file::resize(off_t file_size)
2394 {
2395   // If the mmap is mapping an anonymous memory buffer, this is easy:
2396   // just mremap to the new size.  If it's mapping to a file, we want
2397   // to unmap to flush to the file, then remap after growing the file.
2398   if (this->map_is_anonymous_)
2399     {
2400       void* base = ::mremap(this->base_, this->file_size_, file_size,
2401                             MREMAP_MAYMOVE);
2402       if (base == MAP_FAILED)
2403         gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
2404       this->base_ = static_cast<unsigned char*>(base);
2405       this->file_size_ = file_size;
2406     }
2407   else
2408     {
2409       this->unmap();
2410       this->file_size_ = file_size;
2411       this->map();
2412     }
2413 }
2414
2415 // Map the file into memory.
2416
2417 void
2418 Output_file::map()
2419 {
2420   const int o = this->o_;
2421
2422   // If the output file is not a regular file, don't try to mmap it;
2423   // instead, we'll mmap a block of memory (an anonymous buffer), and
2424   // then later write the buffer to the file.
2425   void* base;
2426   struct stat statbuf;
2427   if (o == STDOUT_FILENO || o == STDERR_FILENO
2428       || ::fstat(o, &statbuf) != 0
2429       || !S_ISREG(statbuf.st_mode))
2430     {
2431       this->map_is_anonymous_ = true;
2432       base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
2433                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2434     }
2435   else
2436     {
2437       // Write out one byte to make the file the right size.
2438       if (::lseek(o, this->file_size_ - 1, SEEK_SET) < 0)
2439         gold_fatal(_("%s: lseek: %s"), this->name_, strerror(errno));
2440       char b = 0;
2441       if (::write(o, &b, 1) != 1)
2442         gold_fatal(_("%s: write: %s"), this->name_, strerror(errno));
2443
2444       // Map the file into memory.
2445       this->map_is_anonymous_ = false;
2446       base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
2447                     MAP_SHARED, o, 0);
2448     }
2449   if (base == MAP_FAILED)
2450     gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
2451   this->base_ = static_cast<unsigned char*>(base);
2452 }
2453
2454 // Unmap the file from memory.
2455
2456 void
2457 Output_file::unmap()
2458 {
2459   if (::munmap(this->base_, this->file_size_) < 0)
2460     gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
2461   this->base_ = NULL;
2462 }
2463
2464 // Close the output file.
2465
2466 void
2467 Output_file::close()
2468 {
2469   // If the map isn't file-backed, we need to write it now.
2470   if (this->map_is_anonymous_)
2471     {
2472       size_t bytes_to_write = this->file_size_;
2473       while (bytes_to_write > 0)
2474         {
2475           ssize_t bytes_written = ::write(this->o_, this->base_, bytes_to_write);
2476           if (bytes_written == 0)
2477             gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
2478           else if (bytes_written < 0)
2479             gold_error(_("%s: write: %s"), this->name_, strerror(errno));
2480           else
2481             bytes_to_write -= bytes_written;
2482         }
2483     }
2484   this->unmap();
2485
2486   // We don't close stdout or stderr
2487   if (this->o_ != STDOUT_FILENO && this->o_ != STDERR_FILENO)
2488     if (::close(this->o_) < 0)
2489       gold_error(_("%s: close: %s"), this->name_, strerror(errno));
2490   this->o_ = -1;
2491 }
2492
2493 // Instantiate the templates we need.  We could use the configure
2494 // script to restrict this to only the ones for implemented targets.
2495
2496 #ifdef HAVE_TARGET_32_LITTLE
2497 template
2498 off_t
2499 Output_section::add_input_section<32, false>(
2500     Sized_relobj<32, false>* object,
2501     unsigned int shndx,
2502     const char* secname,
2503     const elfcpp::Shdr<32, false>& shdr,
2504     unsigned int reloc_shndx);
2505 #endif
2506
2507 #ifdef HAVE_TARGET_32_BIG
2508 template
2509 off_t
2510 Output_section::add_input_section<32, true>(
2511     Sized_relobj<32, true>* object,
2512     unsigned int shndx,
2513     const char* secname,
2514     const elfcpp::Shdr<32, true>& shdr,
2515     unsigned int reloc_shndx);
2516 #endif
2517
2518 #ifdef HAVE_TARGET_64_LITTLE
2519 template
2520 off_t
2521 Output_section::add_input_section<64, false>(
2522     Sized_relobj<64, false>* object,
2523     unsigned int shndx,
2524     const char* secname,
2525     const elfcpp::Shdr<64, false>& shdr,
2526     unsigned int reloc_shndx);
2527 #endif
2528
2529 #ifdef HAVE_TARGET_64_BIG
2530 template
2531 off_t
2532 Output_section::add_input_section<64, true>(
2533     Sized_relobj<64, true>* object,
2534     unsigned int shndx,
2535     const char* secname,
2536     const elfcpp::Shdr<64, true>& shdr,
2537     unsigned int reloc_shndx);
2538 #endif
2539
2540 #ifdef HAVE_TARGET_32_LITTLE
2541 template
2542 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
2543 #endif
2544
2545 #ifdef HAVE_TARGET_32_BIG
2546 template
2547 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
2548 #endif
2549
2550 #ifdef HAVE_TARGET_64_LITTLE
2551 template
2552 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
2553 #endif
2554
2555 #ifdef HAVE_TARGET_64_BIG
2556 template
2557 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
2558 #endif
2559
2560 #ifdef HAVE_TARGET_32_LITTLE
2561 template
2562 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
2563 #endif
2564
2565 #ifdef HAVE_TARGET_32_BIG
2566 template
2567 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
2568 #endif
2569
2570 #ifdef HAVE_TARGET_64_LITTLE
2571 template
2572 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
2573 #endif
2574
2575 #ifdef HAVE_TARGET_64_BIG
2576 template
2577 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
2578 #endif
2579
2580 #ifdef HAVE_TARGET_32_LITTLE
2581 template
2582 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
2583 #endif
2584
2585 #ifdef HAVE_TARGET_32_BIG
2586 template
2587 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
2588 #endif
2589
2590 #ifdef HAVE_TARGET_64_LITTLE
2591 template
2592 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
2593 #endif
2594
2595 #ifdef HAVE_TARGET_64_BIG
2596 template
2597 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
2598 #endif
2599
2600 #ifdef HAVE_TARGET_32_LITTLE
2601 template
2602 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
2603 #endif
2604
2605 #ifdef HAVE_TARGET_32_BIG
2606 template
2607 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
2608 #endif
2609
2610 #ifdef HAVE_TARGET_64_LITTLE
2611 template
2612 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
2613 #endif
2614
2615 #ifdef HAVE_TARGET_64_BIG
2616 template
2617 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
2618 #endif
2619
2620 #ifdef HAVE_TARGET_32_LITTLE
2621 template
2622 class Output_data_got<32, false>;
2623 #endif
2624
2625 #ifdef HAVE_TARGET_32_BIG
2626 template
2627 class Output_data_got<32, true>;
2628 #endif
2629
2630 #ifdef HAVE_TARGET_64_LITTLE
2631 template
2632 class Output_data_got<64, false>;
2633 #endif
2634
2635 #ifdef HAVE_TARGET_64_BIG
2636 template
2637 class Output_data_got<64, true>;
2638 #endif
2639
2640 } // End namespace gold.