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       off_t 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   off_t 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   off_t 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.
1351
1352 bool
1353 Output_section::Input_section::output_offset(const Relobj* object,
1354                                              unsigned int shndx,
1355                                              off_t offset,
1356                                              off_t *poutput) const
1357 {
1358   if (!this->is_input_section())
1359     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
1360   else
1361     {
1362       if (this->shndx_ != shndx || this->u2_.object != object)
1363         return false;
1364       off_t output_offset;
1365       Output_section* os = object->output_section(shndx, &output_offset);
1366       gold_assert(os != NULL);
1367       gold_assert(output_offset != -1);
1368       *poutput = output_offset + offset;
1369       return true;
1370     }
1371 }
1372
1373 // Write out the data.  We don't have to do anything for an input
1374 // section--they are handled via Object::relocate--but this is where
1375 // we write out the data for an Output_section_data.
1376
1377 void
1378 Output_section::Input_section::write(Output_file* of)
1379 {
1380   if (!this->is_input_section())
1381     this->u2_.posd->write(of);
1382 }
1383
1384 // Write the data to a buffer.  As for write(), we don't have to do
1385 // anything for an input section.
1386
1387 void
1388 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
1389 {
1390   if (!this->is_input_section())
1391     this->u2_.posd->write_to_buffer(buffer);
1392 }
1393
1394 // Output_section methods.
1395
1396 // Construct an Output_section.  NAME will point into a Stringpool.
1397
1398 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
1399                                elfcpp::Elf_Xword flags)
1400   : name_(name),
1401     addralign_(0),
1402     entsize_(0),
1403     link_section_(NULL),
1404     link_(0),
1405     info_section_(NULL),
1406     info_(0),
1407     type_(type),
1408     flags_(flags),
1409     out_shndx_(-1U),
1410     symtab_index_(0),
1411     dynsym_index_(0),
1412     input_sections_(),
1413     first_input_offset_(0),
1414     fills_(),
1415     postprocessing_buffer_(NULL),
1416     needs_symtab_index_(false),
1417     needs_dynsym_index_(false),
1418     should_link_to_symtab_(false),
1419     should_link_to_dynsym_(false),
1420     after_input_sections_(false),
1421     requires_postprocessing_(false),
1422     tls_offset_(0)
1423 {
1424   // An unallocated section has no address.  Forcing this means that
1425   // we don't need special treatment for symbols defined in debug
1426   // sections.
1427   if ((flags & elfcpp::SHF_ALLOC) == 0)
1428     this->set_address(0);
1429 }
1430
1431 Output_section::~Output_section()
1432 {
1433 }
1434
1435 // Set the entry size.
1436
1437 void
1438 Output_section::set_entsize(uint64_t v)
1439 {
1440   if (this->entsize_ == 0)
1441     this->entsize_ = v;
1442   else
1443     gold_assert(this->entsize_ == v);
1444 }
1445
1446 // Add the input section SHNDX, with header SHDR, named SECNAME, in
1447 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
1448 // relocation section which applies to this section, or 0 if none, or
1449 // -1U if more than one.  Return the offset of the input section
1450 // within the output section.  Return -1 if the input section will
1451 // receive special handling.  In the normal case we don't always keep
1452 // track of input sections for an Output_section.  Instead, each
1453 // Object keeps track of the Output_section for each of its input
1454 // sections.
1455
1456 template<int size, bool big_endian>
1457 off_t
1458 Output_section::add_input_section(Sized_relobj<size, big_endian>* object,
1459                                   unsigned int shndx,
1460                                   const char* secname,
1461                                   const elfcpp::Shdr<size, big_endian>& shdr,
1462                                   unsigned int reloc_shndx)
1463 {
1464   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
1465   if ((addralign & (addralign - 1)) != 0)
1466     {
1467       object->error(_("invalid alignment %lu for section \"%s\""),
1468                     static_cast<unsigned long>(addralign), secname);
1469       addralign = 1;
1470     }
1471
1472   if (addralign > this->addralign_)
1473     this->addralign_ = addralign;
1474
1475   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
1476   uint64_t entsize = shdr.get_sh_entsize();
1477
1478   // .debug_str is a mergeable string section, but is not always so
1479   // marked by compilers.  Mark manually here so we can optimize.
1480   if (strcmp(secname, ".debug_str") == 0)
1481     {
1482       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
1483       entsize = 1;
1484     }
1485
1486   // If this is a SHF_MERGE section, we pass all the input sections to
1487   // a Output_data_merge.  We don't try to handle relocations for such
1488   // a section.
1489   if ((sh_flags & elfcpp::SHF_MERGE) != 0
1490       && reloc_shndx == 0)
1491     {
1492       if (this->add_merge_input_section(object, shndx, sh_flags,
1493                                         entsize, addralign))
1494         {
1495           // Tell the relocation routines that they need to call the
1496           // output_offset method to determine the final address.
1497           return -1;
1498         }
1499     }
1500
1501   off_t offset_in_section = this->current_data_size_for_child();
1502   off_t aligned_offset_in_section = align_address(offset_in_section,
1503                                                   addralign);
1504
1505   if (aligned_offset_in_section > offset_in_section
1506       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
1507       && object->target()->has_code_fill())
1508     {
1509       // We need to add some fill data.  Using fill_list_ when
1510       // possible is an optimization, since we will often have fill
1511       // sections without input sections.
1512       off_t fill_len = aligned_offset_in_section - offset_in_section;
1513       if (this->input_sections_.empty())
1514         this->fills_.push_back(Fill(offset_in_section, fill_len));
1515       else
1516         {
1517           // FIXME: When relaxing, the size needs to adjust to
1518           // maintain a constant alignment.
1519           std::string fill_data(object->target()->code_fill(fill_len));
1520           Output_data_const* odc = new Output_data_const(fill_data, 1);
1521           this->input_sections_.push_back(Input_section(odc));
1522         }
1523     }
1524
1525   this->set_current_data_size_for_child(aligned_offset_in_section
1526                                         + shdr.get_sh_size());
1527
1528   // We need to keep track of this section if we are already keeping
1529   // track of sections, or if we are relaxing.  FIXME: Add test for
1530   // relaxing.
1531   if (!this->input_sections_.empty())
1532     this->input_sections_.push_back(Input_section(object, shndx,
1533                                                   shdr.get_sh_size(),
1534                                                   addralign));
1535
1536   return aligned_offset_in_section;
1537 }
1538
1539 // Add arbitrary data to an output section.
1540
1541 void
1542 Output_section::add_output_section_data(Output_section_data* posd)
1543 {
1544   Input_section inp(posd);
1545   this->add_output_section_data(&inp);
1546 }
1547
1548 // Add arbitrary data to an output section by Input_section.
1549
1550 void
1551 Output_section::add_output_section_data(Input_section* inp)
1552 {
1553   if (this->input_sections_.empty())
1554     this->first_input_offset_ = this->current_data_size_for_child();
1555
1556   this->input_sections_.push_back(*inp);
1557
1558   uint64_t addralign = inp->addralign();
1559   if (addralign > this->addralign_)
1560     this->addralign_ = addralign;
1561
1562   inp->set_output_section(this);
1563 }
1564
1565 // Add a merge section to an output section.
1566
1567 void
1568 Output_section::add_output_merge_section(Output_section_data* posd,
1569                                          bool is_string, uint64_t entsize)
1570 {
1571   Input_section inp(posd, is_string, entsize);
1572   this->add_output_section_data(&inp);
1573 }
1574
1575 // Add an input section to a SHF_MERGE section.
1576
1577 bool
1578 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
1579                                         uint64_t flags, uint64_t entsize,
1580                                         uint64_t addralign)
1581 {
1582   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
1583
1584   // We only merge strings if the alignment is not more than the
1585   // character size.  This could be handled, but it's unusual.
1586   if (is_string && addralign > entsize)
1587     return false;
1588
1589   Input_section_list::iterator p;
1590   for (p = this->input_sections_.begin();
1591        p != this->input_sections_.end();
1592        ++p)
1593     if (p->is_merge_section(is_string, entsize, addralign))
1594       {
1595         p->add_input_section(object, shndx);
1596         return true;
1597       }
1598
1599   // We handle the actual constant merging in Output_merge_data or
1600   // Output_merge_string_data.
1601   Output_section_data* posd;
1602   if (!is_string)
1603     posd = new Output_merge_data(entsize, addralign);
1604   else
1605     {
1606       switch (entsize)
1607         {
1608         case 1:
1609           posd = new Output_merge_string<char>(addralign);
1610           break;
1611         case 2:
1612           posd = new Output_merge_string<uint16_t>(addralign);
1613           break;
1614         case 4:
1615           posd = new Output_merge_string<uint32_t>(addralign);
1616           break;
1617         default:
1618           return false;
1619         }
1620     }
1621
1622   this->add_output_merge_section(posd, is_string, entsize);
1623   posd->add_input_section(object, shndx);
1624
1625   return true;
1626 }
1627
1628 // Given an address OFFSET relative to the start of input section
1629 // SHNDX in OBJECT, return whether this address is being included in
1630 // the final link.  This should only be called if SHNDX in OBJECT has
1631 // a special mapping.
1632
1633 bool
1634 Output_section::is_input_address_mapped(const Relobj* object,
1635                                         unsigned int shndx,
1636                                         off_t offset) const
1637 {
1638   gold_assert(object->is_section_specially_mapped(shndx));
1639
1640   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1641        p != this->input_sections_.end();
1642        ++p)
1643     {
1644       off_t output_offset;
1645       if (p->output_offset(object, shndx, offset, &output_offset))
1646         return output_offset != -1;
1647     }
1648
1649   // By default we assume that the address is mapped.  This should
1650   // only be called after we have passed all sections to Layout.  At
1651   // that point we should know what we are discarding.
1652   return true;
1653 }
1654
1655 // Given an address OFFSET relative to the start of input section
1656 // SHNDX in object OBJECT, return the output offset relative to the
1657 // start of the section.  This should only be called if SHNDX in
1658 // OBJECT has a special mapping.
1659
1660 off_t
1661 Output_section::output_offset(const Relobj* object, unsigned int shndx,
1662                               off_t offset) const
1663 {
1664   gold_assert(object->is_section_specially_mapped(shndx));
1665   // This can only be called meaningfully when layout is complete.
1666   gold_assert(Output_data::is_layout_complete());
1667
1668   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1669        p != this->input_sections_.end();
1670        ++p)
1671     {
1672       off_t output_offset;
1673       if (p->output_offset(object, shndx, offset, &output_offset))
1674         return output_offset;
1675     }
1676   gold_unreachable();
1677 }
1678
1679 // Return the output virtual address of OFFSET relative to the start
1680 // of input section SHNDX in object OBJECT.
1681
1682 uint64_t
1683 Output_section::output_address(const Relobj* object, unsigned int shndx,
1684                                off_t offset) const
1685 {
1686   gold_assert(object->is_section_specially_mapped(shndx));
1687   // This can only be called meaningfully when layout is complete.
1688   gold_assert(Output_data::is_layout_complete());
1689
1690   uint64_t addr = this->address() + this->first_input_offset_;
1691   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1692        p != this->input_sections_.end();
1693        ++p)
1694     {
1695       addr = align_address(addr, p->addralign());
1696       off_t output_offset;
1697       if (p->output_offset(object, shndx, offset, &output_offset))
1698         {
1699           if (output_offset == -1)
1700             return -1U;
1701           return addr + output_offset;
1702         }
1703       addr += p->data_size();
1704     }
1705
1706   // If we get here, it means that we don't know the mapping for this
1707   // input section.  This might happen in principle if
1708   // add_input_section were called before add_output_section_data.
1709   // But it should never actually happen.
1710
1711   gold_unreachable();
1712 }
1713
1714 // Set the data size of an Output_section.  This is where we handle
1715 // setting the addresses of any Output_section_data objects.
1716
1717 void
1718 Output_section::set_final_data_size()
1719 {
1720   if (this->input_sections_.empty())
1721     {
1722       this->set_data_size(this->current_data_size_for_child());
1723       return;
1724     }
1725
1726   uint64_t address = this->address();
1727   off_t startoff = this->offset();
1728   off_t off = startoff + this->first_input_offset_;
1729   for (Input_section_list::iterator p = this->input_sections_.begin();
1730        p != this->input_sections_.end();
1731        ++p)
1732     {
1733       off = align_address(off, p->addralign());
1734       p->set_address_and_file_offset(address + (off - startoff), off,
1735                                      startoff);
1736       off += p->data_size();
1737     }
1738
1739   this->set_data_size(off - startoff);
1740 }
1741
1742 // Set the TLS offset.  Called only for SHT_TLS sections.
1743
1744 void
1745 Output_section::do_set_tls_offset(uint64_t tls_base)
1746 {
1747   this->tls_offset_ = this->address() - tls_base;
1748 }
1749
1750 // Write the section header to *OSHDR.
1751
1752 template<int size, bool big_endian>
1753 void
1754 Output_section::write_header(const Layout* layout,
1755                              const Stringpool* secnamepool,
1756                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
1757 {
1758   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
1759   oshdr->put_sh_type(this->type_);
1760   oshdr->put_sh_flags(this->flags_);
1761   oshdr->put_sh_addr(this->address());
1762   oshdr->put_sh_offset(this->offset());
1763   oshdr->put_sh_size(this->data_size());
1764   if (this->link_section_ != NULL)
1765     oshdr->put_sh_link(this->link_section_->out_shndx());
1766   else if (this->should_link_to_symtab_)
1767     oshdr->put_sh_link(layout->symtab_section()->out_shndx());
1768   else if (this->should_link_to_dynsym_)
1769     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
1770   else
1771     oshdr->put_sh_link(this->link_);
1772   if (this->info_section_ != NULL)
1773     oshdr->put_sh_info(this->info_section_->out_shndx());
1774   else
1775     oshdr->put_sh_info(this->info_);
1776   oshdr->put_sh_addralign(this->addralign_);
1777   oshdr->put_sh_entsize(this->entsize_);
1778 }
1779
1780 // Write out the data.  For input sections the data is written out by
1781 // Object::relocate, but we have to handle Output_section_data objects
1782 // here.
1783
1784 void
1785 Output_section::do_write(Output_file* of)
1786 {
1787   gold_assert(!this->requires_postprocessing());
1788
1789   off_t output_section_file_offset = this->offset();
1790   for (Fill_list::iterator p = this->fills_.begin();
1791        p != this->fills_.end();
1792        ++p)
1793     {
1794       std::string fill_data(of->target()->code_fill(p->length()));
1795       of->write(output_section_file_offset + p->section_offset(),
1796                 fill_data.data(), fill_data.size());
1797     }
1798
1799   for (Input_section_list::iterator p = this->input_sections_.begin();
1800        p != this->input_sections_.end();
1801        ++p)
1802     p->write(of);
1803 }
1804
1805 // If a section requires postprocessing, create the buffer to use.
1806
1807 void
1808 Output_section::create_postprocessing_buffer()
1809 {
1810   gold_assert(this->requires_postprocessing());
1811   gold_assert(this->postprocessing_buffer_ == NULL);
1812
1813   if (!this->input_sections_.empty())
1814     {
1815       off_t off = this->first_input_offset_;
1816       for (Input_section_list::iterator p = this->input_sections_.begin();
1817            p != this->input_sections_.end();
1818            ++p)
1819         {
1820           off = align_address(off, p->addralign());
1821           p->finalize_data_size();
1822           off += p->data_size();
1823         }
1824       this->set_current_data_size_for_child(off);
1825     }
1826
1827   off_t buffer_size = this->current_data_size_for_child();
1828   this->postprocessing_buffer_ = new unsigned char[buffer_size];
1829 }
1830
1831 // Write all the data of an Output_section into the postprocessing
1832 // buffer.  This is used for sections which require postprocessing,
1833 // such as compression.  Input sections are handled by
1834 // Object::Relocate.
1835
1836 void
1837 Output_section::write_to_postprocessing_buffer()
1838 {
1839   gold_assert(this->requires_postprocessing());
1840
1841   Target* target = parameters->target();
1842   unsigned char* buffer = this->postprocessing_buffer();
1843   for (Fill_list::iterator p = this->fills_.begin();
1844        p != this->fills_.end();
1845        ++p)
1846     {
1847       std::string fill_data(target->code_fill(p->length()));
1848       memcpy(buffer + p->section_offset(), fill_data.data(), fill_data.size());
1849     }
1850
1851   off_t off = this->first_input_offset_;
1852   for (Input_section_list::iterator p = this->input_sections_.begin();
1853        p != this->input_sections_.end();
1854        ++p)
1855     {
1856       off = align_address(off, p->addralign());
1857       p->write_to_buffer(buffer + off);
1858       off += p->data_size();
1859     }
1860 }
1861
1862 // Output segment methods.
1863
1864 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
1865   : output_data_(),
1866     output_bss_(),
1867     vaddr_(0),
1868     paddr_(0),
1869     memsz_(0),
1870     align_(0),
1871     offset_(0),
1872     filesz_(0),
1873     type_(type),
1874     flags_(flags),
1875     is_align_known_(false)
1876 {
1877 }
1878
1879 // Add an Output_section to an Output_segment.
1880
1881 void
1882 Output_segment::add_output_section(Output_section* os,
1883                                    elfcpp::Elf_Word seg_flags,
1884                                    bool front)
1885 {
1886   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
1887   gold_assert(!this->is_align_known_);
1888
1889   // Update the segment flags.
1890   this->flags_ |= seg_flags;
1891
1892   Output_segment::Output_data_list* pdl;
1893   if (os->type() == elfcpp::SHT_NOBITS)
1894     pdl = &this->output_bss_;
1895   else
1896     pdl = &this->output_data_;
1897
1898   // So that PT_NOTE segments will work correctly, we need to ensure
1899   // that all SHT_NOTE sections are adjacent.  This will normally
1900   // happen automatically, because all the SHT_NOTE input sections
1901   // will wind up in the same output section.  However, it is possible
1902   // for multiple SHT_NOTE input sections to have different section
1903   // flags, and thus be in different output sections, but for the
1904   // different section flags to map into the same segment flags and
1905   // thus the same output segment.
1906
1907   // Note that while there may be many input sections in an output
1908   // section, there are normally only a few output sections in an
1909   // output segment.  This loop is expected to be fast.
1910
1911   if (os->type() == elfcpp::SHT_NOTE && !pdl->empty())
1912     {
1913       Output_segment::Output_data_list::iterator p = pdl->end();
1914       do
1915         {
1916           --p;
1917           if ((*p)->is_section_type(elfcpp::SHT_NOTE))
1918             {
1919               // We don't worry about the FRONT parameter.
1920               ++p;
1921               pdl->insert(p, os);
1922               return;
1923             }
1924         }
1925       while (p != pdl->begin());
1926     }
1927
1928   // Similarly, so that PT_TLS segments will work, we need to group
1929   // SHF_TLS sections.  An SHF_TLS/SHT_NOBITS section is a special
1930   // case: we group the SHF_TLS/SHT_NOBITS sections right after the
1931   // SHF_TLS/SHT_PROGBITS sections.  This lets us set up PT_TLS
1932   // correctly.  SHF_TLS sections get added to both a PT_LOAD segment
1933   // and the PT_TLS segment -- we do this grouping only for the
1934   // PT_LOAD segment.
1935   if (this->type_ != elfcpp::PT_TLS
1936       && (os->flags() & elfcpp::SHF_TLS) != 0
1937       && !this->output_data_.empty())
1938     {
1939       pdl = &this->output_data_;
1940       bool nobits = os->type() == elfcpp::SHT_NOBITS;
1941       bool sawtls = false;
1942       Output_segment::Output_data_list::iterator p = pdl->end();
1943       do
1944         {
1945           --p;
1946           bool insert;
1947           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
1948             {
1949               sawtls = true;
1950               // Put a NOBITS section after the first TLS section.
1951               // But a PROGBITS section after the first TLS/PROGBITS
1952               // section.
1953               insert = nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS);
1954             }
1955           else
1956             {
1957               // If we've gone past the TLS sections, but we've seen a
1958               // TLS section, then we need to insert this section now.
1959               insert = sawtls;
1960             }
1961
1962           if (insert)
1963             {
1964               // We don't worry about the FRONT parameter.
1965               ++p;
1966               pdl->insert(p, os);
1967               return;
1968             }
1969         }
1970       while (p != pdl->begin());
1971
1972       // There are no TLS sections yet; put this one at the requested
1973       // location in the section list.
1974     }
1975
1976   if (front)
1977     pdl->push_front(os);
1978   else
1979     pdl->push_back(os);
1980 }
1981
1982 // Add an Output_data (which is not an Output_section) to the start of
1983 // a segment.
1984
1985 void
1986 Output_segment::add_initial_output_data(Output_data* od)
1987 {
1988   gold_assert(!this->is_align_known_);
1989   this->output_data_.push_front(od);
1990 }
1991
1992 // Return the maximum alignment of the Output_data in Output_segment.
1993 // Once we compute this, we prohibit new sections from being added.
1994
1995 uint64_t
1996 Output_segment::addralign()
1997 {
1998   if (!this->is_align_known_)
1999     {
2000       uint64_t addralign;
2001
2002       addralign = Output_segment::maximum_alignment(&this->output_data_);
2003       if (addralign > this->align_)
2004         this->align_ = addralign;
2005
2006       addralign = Output_segment::maximum_alignment(&this->output_bss_);
2007       if (addralign > this->align_)
2008         this->align_ = addralign;
2009
2010       this->is_align_known_ = true;
2011     }
2012
2013   return this->align_;
2014 }
2015
2016 // Return the maximum alignment of a list of Output_data.
2017
2018 uint64_t
2019 Output_segment::maximum_alignment(const Output_data_list* pdl)
2020 {
2021   uint64_t ret = 0;
2022   for (Output_data_list::const_iterator p = pdl->begin();
2023        p != pdl->end();
2024        ++p)
2025     {
2026       uint64_t addralign = (*p)->addralign();
2027       if (addralign > ret)
2028         ret = addralign;
2029     }
2030   return ret;
2031 }
2032
2033 // Return the number of dynamic relocs applied to this segment.
2034
2035 unsigned int
2036 Output_segment::dynamic_reloc_count() const
2037 {
2038   return (this->dynamic_reloc_count_list(&this->output_data_)
2039           + this->dynamic_reloc_count_list(&this->output_bss_));
2040 }
2041
2042 // Return the number of dynamic relocs applied to an Output_data_list.
2043
2044 unsigned int
2045 Output_segment::dynamic_reloc_count_list(const Output_data_list* pdl) const
2046 {
2047   unsigned int count = 0;
2048   for (Output_data_list::const_iterator p = pdl->begin();
2049        p != pdl->end();
2050        ++p)
2051     count += (*p)->dynamic_reloc_count();
2052   return count;
2053 }
2054
2055 // Set the section addresses for an Output_segment.  ADDR is the
2056 // address and *POFF is the file offset.  Set the section indexes
2057 // starting with *PSHNDX.  Return the address of the immediately
2058 // following segment.  Update *POFF and *PSHNDX.
2059
2060 uint64_t
2061 Output_segment::set_section_addresses(uint64_t addr, off_t* poff,
2062                                       unsigned int* pshndx)
2063 {
2064   gold_assert(this->type_ == elfcpp::PT_LOAD);
2065
2066   this->vaddr_ = addr;
2067   this->paddr_ = addr;
2068
2069   off_t orig_off = *poff;
2070   this->offset_ = orig_off;
2071
2072   *poff = align_address(*poff, this->addralign());
2073
2074   addr = this->set_section_list_addresses(&this->output_data_, addr, poff,
2075                                           pshndx);
2076   this->filesz_ = *poff - orig_off;
2077
2078   off_t off = *poff;
2079
2080   uint64_t ret = this->set_section_list_addresses(&this->output_bss_, addr,
2081                                                   poff, pshndx);
2082   this->memsz_ = *poff - orig_off;
2083
2084   // Ignore the file offset adjustments made by the BSS Output_data
2085   // objects.
2086   *poff = off;
2087
2088   return ret;
2089 }
2090
2091 // Set the addresses and file offsets in a list of Output_data
2092 // structures.
2093
2094 uint64_t
2095 Output_segment::set_section_list_addresses(Output_data_list* pdl,
2096                                            uint64_t addr, off_t* poff,
2097                                            unsigned int* pshndx)
2098 {
2099   off_t startoff = *poff;
2100
2101   off_t off = startoff;
2102   for (Output_data_list::iterator p = pdl->begin();
2103        p != pdl->end();
2104        ++p)
2105     {
2106       off = align_address(off, (*p)->addralign());
2107       (*p)->set_address_and_file_offset(addr + (off - startoff), off);
2108
2109       // Unless this is a PT_TLS segment, we want to ignore the size
2110       // of a SHF_TLS/SHT_NOBITS section.  Such a section does not
2111       // affect the size of a PT_LOAD segment.
2112       if (this->type_ == elfcpp::PT_TLS
2113           || !(*p)->is_section_flag_set(elfcpp::SHF_TLS)
2114           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
2115         off += (*p)->data_size();
2116
2117       if ((*p)->is_section())
2118         {
2119           (*p)->set_out_shndx(*pshndx);
2120           ++*pshndx;
2121         }
2122     }
2123
2124   *poff = off;
2125   return addr + (off - startoff);
2126 }
2127
2128 // For a non-PT_LOAD segment, set the offset from the sections, if
2129 // any.
2130
2131 void
2132 Output_segment::set_offset()
2133 {
2134   gold_assert(this->type_ != elfcpp::PT_LOAD);
2135
2136   if (this->output_data_.empty() && this->output_bss_.empty())
2137     {
2138       this->vaddr_ = 0;
2139       this->paddr_ = 0;
2140       this->memsz_ = 0;
2141       this->align_ = 0;
2142       this->offset_ = 0;
2143       this->filesz_ = 0;
2144       return;
2145     }
2146
2147   const Output_data* first;
2148   if (this->output_data_.empty())
2149     first = this->output_bss_.front();
2150   else
2151     first = this->output_data_.front();
2152   this->vaddr_ = first->address();
2153   this->paddr_ = this->vaddr_;
2154   this->offset_ = first->offset();
2155
2156   if (this->output_data_.empty())
2157     this->filesz_ = 0;
2158   else
2159     {
2160       const Output_data* last_data = this->output_data_.back();
2161       this->filesz_ = (last_data->address()
2162                        + last_data->data_size()
2163                        - this->vaddr_);
2164     }
2165
2166   const Output_data* last;
2167   if (this->output_bss_.empty())
2168     last = this->output_data_.back();
2169   else
2170     last = this->output_bss_.back();
2171   this->memsz_ = (last->address()
2172                   + last->data_size()
2173                   - this->vaddr_);
2174 }
2175
2176 // Set the TLS offsets of the sections in the PT_TLS segment.
2177
2178 void
2179 Output_segment::set_tls_offsets()
2180 {
2181   gold_assert(this->type_ == elfcpp::PT_TLS);
2182
2183   for (Output_data_list::iterator p = this->output_data_.begin();
2184        p != this->output_data_.end();
2185        ++p)
2186     (*p)->set_tls_offset(this->vaddr_);
2187
2188   for (Output_data_list::iterator p = this->output_bss_.begin();
2189        p != this->output_bss_.end();
2190        ++p)
2191     (*p)->set_tls_offset(this->vaddr_);
2192 }
2193
2194 // Return the number of Output_sections in an Output_segment.
2195
2196 unsigned int
2197 Output_segment::output_section_count() const
2198 {
2199   return (this->output_section_count_list(&this->output_data_)
2200           + this->output_section_count_list(&this->output_bss_));
2201 }
2202
2203 // Return the number of Output_sections in an Output_data_list.
2204
2205 unsigned int
2206 Output_segment::output_section_count_list(const Output_data_list* pdl) const
2207 {
2208   unsigned int count = 0;
2209   for (Output_data_list::const_iterator p = pdl->begin();
2210        p != pdl->end();
2211        ++p)
2212     {
2213       if ((*p)->is_section())
2214         ++count;
2215     }
2216   return count;
2217 }
2218
2219 // Write the segment data into *OPHDR.
2220
2221 template<int size, bool big_endian>
2222 void
2223 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
2224 {
2225   ophdr->put_p_type(this->type_);
2226   ophdr->put_p_offset(this->offset_);
2227   ophdr->put_p_vaddr(this->vaddr_);
2228   ophdr->put_p_paddr(this->paddr_);
2229   ophdr->put_p_filesz(this->filesz_);
2230   ophdr->put_p_memsz(this->memsz_);
2231   ophdr->put_p_flags(this->flags_);
2232   ophdr->put_p_align(this->addralign());
2233 }
2234
2235 // Write the section headers into V.
2236
2237 template<int size, bool big_endian>
2238 unsigned char*
2239 Output_segment::write_section_headers(const Layout* layout,
2240                                       const Stringpool* secnamepool,
2241                                       unsigned char* v,
2242                                       unsigned int *pshndx
2243                                       ACCEPT_SIZE_ENDIAN) const
2244 {
2245   // Every section that is attached to a segment must be attached to a
2246   // PT_LOAD segment, so we only write out section headers for PT_LOAD
2247   // segments.
2248   if (this->type_ != elfcpp::PT_LOAD)
2249     return v;
2250
2251   v = this->write_section_headers_list
2252       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
2253           layout, secnamepool, &this->output_data_, v, pshndx
2254           SELECT_SIZE_ENDIAN(size, big_endian));
2255   v = this->write_section_headers_list
2256       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
2257           layout, secnamepool, &this->output_bss_, v, pshndx
2258           SELECT_SIZE_ENDIAN(size, big_endian));
2259   return v;
2260 }
2261
2262 template<int size, bool big_endian>
2263 unsigned char*
2264 Output_segment::write_section_headers_list(const Layout* layout,
2265                                            const Stringpool* secnamepool,
2266                                            const Output_data_list* pdl,
2267                                            unsigned char* v,
2268                                            unsigned int* pshndx
2269                                            ACCEPT_SIZE_ENDIAN) const
2270 {
2271   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
2272   for (Output_data_list::const_iterator p = pdl->begin();
2273        p != pdl->end();
2274        ++p)
2275     {
2276       if ((*p)->is_section())
2277         {
2278           const Output_section* ps = static_cast<const Output_section*>(*p);
2279           gold_assert(*pshndx == ps->out_shndx());
2280           elfcpp::Shdr_write<size, big_endian> oshdr(v);
2281           ps->write_header(layout, secnamepool, &oshdr);
2282           v += shdr_size;
2283           ++*pshndx;
2284         }
2285     }
2286   return v;
2287 }
2288
2289 // Output_file methods.
2290
2291 Output_file::Output_file(const General_options& options, Target* target)
2292   : options_(options),
2293     target_(target),
2294     name_(options.output_file_name()),
2295     o_(-1),
2296     file_size_(0),
2297     base_(NULL),
2298     map_is_anonymous_(false)
2299 {
2300 }
2301
2302 // Open the output file.
2303
2304 void
2305 Output_file::open(off_t file_size)
2306 {
2307   this->file_size_ = file_size;
2308
2309   // Unlink the file first; otherwise the open() may fail if the file
2310   // is busy (e.g. it's an executable that's currently being executed).
2311   //
2312   // However, the linker may be part of a system where a zero-length
2313   // file is created for it to write to, with tight permissions (gcc
2314   // 2.95 did something like this).  Unlinking the file would work
2315   // around those permission controls, so we only unlink if the file
2316   // has a non-zero size.  We also unlink only regular files to avoid
2317   // trouble with directories/etc.
2318   //
2319   // If we fail, continue; this command is merely a best-effort attempt
2320   // to improve the odds for open().
2321
2322   // We let the name "-" mean "stdout"
2323   if (strcmp(this->name_, "-") == 0)
2324     this->o_ = STDOUT_FILENO;
2325   else
2326     {
2327       struct stat s;
2328       if (::stat(this->name_, &s) == 0 && s.st_size != 0)
2329         unlink_if_ordinary(this->name_);
2330
2331       int mode = parameters->output_is_object() ? 0666 : 0777;
2332       int o = ::open(this->name_, O_RDWR | O_CREAT | O_TRUNC, mode);
2333       if (o < 0)
2334         gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
2335       this->o_ = o;
2336     }
2337
2338   this->map();
2339 }
2340
2341 // Resize the output file.
2342
2343 void
2344 Output_file::resize(off_t file_size)
2345 {
2346   // If the mmap is mapping an anonymous memory buffer, this is easy:
2347   // just mremap to the new size.  If it's mapping to a file, we want
2348   // to unmap to flush to the file, then remap after growing the file.
2349   if (this->map_is_anonymous_)
2350     {
2351       void* base = ::mremap(this->base_, this->file_size_, file_size,
2352                             MREMAP_MAYMOVE);
2353       if (base == MAP_FAILED)
2354         gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
2355       this->base_ = static_cast<unsigned char*>(base);
2356       this->file_size_ = file_size;
2357     }
2358   else
2359     {
2360       this->unmap();
2361       this->file_size_ = file_size;
2362       this->map();
2363     }
2364 }
2365
2366 // Map the file into memory.
2367
2368 void
2369 Output_file::map()
2370 {
2371   const int o = this->o_;
2372
2373   // If the output file is not a regular file, don't try to mmap it;
2374   // instead, we'll mmap a block of memory (an anonymous buffer), and
2375   // then later write the buffer to the file.
2376   void* base;
2377   struct stat statbuf;
2378   if (o == STDOUT_FILENO || o == STDERR_FILENO
2379       || ::fstat(o, &statbuf) != 0
2380       || !S_ISREG(statbuf.st_mode))
2381     {
2382       this->map_is_anonymous_ = true;
2383       base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
2384                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2385     }
2386   else
2387     {
2388       // Write out one byte to make the file the right size.
2389       if (::lseek(o, this->file_size_ - 1, SEEK_SET) < 0)
2390         gold_fatal(_("%s: lseek: %s"), this->name_, strerror(errno));
2391       char b = 0;
2392       if (::write(o, &b, 1) != 1)
2393         gold_fatal(_("%s: write: %s"), this->name_, strerror(errno));
2394
2395       // Map the file into memory.
2396       this->map_is_anonymous_ = false;
2397       base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
2398                     MAP_SHARED, o, 0);
2399     }
2400   if (base == MAP_FAILED)
2401     gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
2402   this->base_ = static_cast<unsigned char*>(base);
2403 }
2404
2405 // Unmap the file from memory.
2406
2407 void
2408 Output_file::unmap()
2409 {
2410   if (::munmap(this->base_, this->file_size_) < 0)
2411     gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
2412   this->base_ = NULL;
2413 }
2414
2415 // Close the output file.
2416
2417 void
2418 Output_file::close()
2419 {
2420   // If the map isn't file-backed, we need to write it now.
2421   if (this->map_is_anonymous_)
2422     {
2423       size_t bytes_to_write = this->file_size_;
2424       while (bytes_to_write > 0)
2425         {
2426           ssize_t bytes_written = ::write(this->o_, this->base_, bytes_to_write);
2427           if (bytes_written == 0)
2428             gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
2429           else if (bytes_written < 0)
2430             gold_error(_("%s: write: %s"), this->name_, strerror(errno));
2431           else
2432             bytes_to_write -= bytes_written;
2433         }
2434     }
2435   this->unmap();
2436
2437   // We don't close stdout or stderr
2438   if (this->o_ != STDOUT_FILENO && this->o_ != STDERR_FILENO)
2439     if (::close(this->o_) < 0)
2440       gold_error(_("%s: close: %s"), this->name_, strerror(errno));
2441   this->o_ = -1;
2442 }
2443
2444 // Instantiate the templates we need.  We could use the configure
2445 // script to restrict this to only the ones for implemented targets.
2446
2447 #ifdef HAVE_TARGET_32_LITTLE
2448 template
2449 off_t
2450 Output_section::add_input_section<32, false>(
2451     Sized_relobj<32, false>* object,
2452     unsigned int shndx,
2453     const char* secname,
2454     const elfcpp::Shdr<32, false>& shdr,
2455     unsigned int reloc_shndx);
2456 #endif
2457
2458 #ifdef HAVE_TARGET_32_BIG
2459 template
2460 off_t
2461 Output_section::add_input_section<32, true>(
2462     Sized_relobj<32, true>* object,
2463     unsigned int shndx,
2464     const char* secname,
2465     const elfcpp::Shdr<32, true>& shdr,
2466     unsigned int reloc_shndx);
2467 #endif
2468
2469 #ifdef HAVE_TARGET_64_LITTLE
2470 template
2471 off_t
2472 Output_section::add_input_section<64, false>(
2473     Sized_relobj<64, false>* object,
2474     unsigned int shndx,
2475     const char* secname,
2476     const elfcpp::Shdr<64, false>& shdr,
2477     unsigned int reloc_shndx);
2478 #endif
2479
2480 #ifdef HAVE_TARGET_64_BIG
2481 template
2482 off_t
2483 Output_section::add_input_section<64, true>(
2484     Sized_relobj<64, true>* object,
2485     unsigned int shndx,
2486     const char* secname,
2487     const elfcpp::Shdr<64, true>& shdr,
2488     unsigned int reloc_shndx);
2489 #endif
2490
2491 #ifdef HAVE_TARGET_32_LITTLE
2492 template
2493 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
2494 #endif
2495
2496 #ifdef HAVE_TARGET_32_BIG
2497 template
2498 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
2499 #endif
2500
2501 #ifdef HAVE_TARGET_64_LITTLE
2502 template
2503 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
2504 #endif
2505
2506 #ifdef HAVE_TARGET_64_BIG
2507 template
2508 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
2509 #endif
2510
2511 #ifdef HAVE_TARGET_32_LITTLE
2512 template
2513 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
2514 #endif
2515
2516 #ifdef HAVE_TARGET_32_BIG
2517 template
2518 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
2519 #endif
2520
2521 #ifdef HAVE_TARGET_64_LITTLE
2522 template
2523 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
2524 #endif
2525
2526 #ifdef HAVE_TARGET_64_BIG
2527 template
2528 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
2529 #endif
2530
2531 #ifdef HAVE_TARGET_32_LITTLE
2532 template
2533 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
2534 #endif
2535
2536 #ifdef HAVE_TARGET_32_BIG
2537 template
2538 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
2539 #endif
2540
2541 #ifdef HAVE_TARGET_64_LITTLE
2542 template
2543 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
2544 #endif
2545
2546 #ifdef HAVE_TARGET_64_BIG
2547 template
2548 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
2549 #endif
2550
2551 #ifdef HAVE_TARGET_32_LITTLE
2552 template
2553 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
2554 #endif
2555
2556 #ifdef HAVE_TARGET_32_BIG
2557 template
2558 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
2559 #endif
2560
2561 #ifdef HAVE_TARGET_64_LITTLE
2562 template
2563 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
2564 #endif
2565
2566 #ifdef HAVE_TARGET_64_BIG
2567 template
2568 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
2569 #endif
2570
2571 #ifdef HAVE_TARGET_32_LITTLE
2572 template
2573 class Output_data_got<32, false>;
2574 #endif
2575
2576 #ifdef HAVE_TARGET_32_BIG
2577 template
2578 class Output_data_got<32, true>;
2579 #endif
2580
2581 #ifdef HAVE_TARGET_64_LITTLE
2582 template
2583 class Output_data_got<64, false>;
2584 #endif
2585
2586 #ifdef HAVE_TARGET_64_BIG
2587 template
2588 class Output_data_got<64, true>;
2589 #endif
2590
2591 } // End namespace gold.