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 <[email protected]>.
   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 // Get the symbol index of a relocation.
 509
 510 template<bool dynamic, int size, bool big_endian>
 511 unsigned int
 512 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 513   const
 514 {
 515   unsigned int index;
 516   switch (this->local_sym_index_)
 517     {
 518     case INVALID_CODE:
 519       gold_unreachable();
 520
 521     case GSYM_CODE:
 522       if (this->u1_.gsym == NULL)
 523         index = 0;
 524       else if (dynamic)
 525         index = this->u1_.gsym->dynsym_index();
 526       else
 527         index = this->u1_.gsym->symtab_index();
 528       break;
 529
 530     case SECTION_CODE:
 531       if (dynamic)
 532         index = this->u1_.os->dynsym_index();
 533       else
 534         index = this->u1_.os->symtab_index();
 535       break;
 536
 537     case 0:
 538       // Relocations without symbols use a symbol index of 0.
 539       index = 0;
 540       break;
 541
 542     default:
 543       if (dynamic)
 544         {
 545           // FIXME: It seems that some targets may need to generate
 546           // dynamic relocations against local symbols for some
 547           // reasons.  This will have to be addressed at some point.
 548           gold_unreachable();
 549         }
 550       else
 551         index = this->u1_.relobj->symtab_index(this->local_sym_index_);
 552       break;
 553     }
 554   gold_assert(index != -1U);
 555   return index;
 556 }
 557
 558 // Write out the offset and info fields of a Rel or Rela relocation
 559 // entry.
 560
 561 template<bool dynamic, int size, bool big_endian>
 562 template<typename Write_rel>
 563 void
 564 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
 565     Write_rel* wr) const
 566 {
 567   Address address = this->address_;
 568   if (this->shndx_ != INVALID_CODE)
 569     {
 570       off_t off;
 571       Output_section* os = this->u2_.relobj->output_section(this->shndx_,
 572                                                             &off);
 573       gold_assert(os != NULL);
 574       if (off != -1)
 575         address += os->address() + off;
 576       else
 577         {
 578           address = os->output_address(this->u2_.relobj, this->shndx_,
 579                                        address);
 580           gold_assert(address != -1U);
 581         }
 582     }
 583   else if (this->u2_.od != NULL)
 584     address += this->u2_.od->address();
 585   wr->put_r_offset(address);
 586   wr->put_r_info(elfcpp::elf_r_info<size>(this->get_symbol_index(),
 587                                           this->type_));
 588 }
 589
 590 // Write out a Rel relocation.
 591
 592 template<bool dynamic, int size, bool big_endian>
 593 void
 594 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
 595     unsigned char* pov) const
 596 {
 597   elfcpp::Rel_write<size, big_endian> orel(pov);
 598   this->write_rel(&orel);
 599 }
 600
 601 // Write out a Rela relocation.
 602
 603 template<bool dynamic, int size, bool big_endian>
 604 void
 605 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
 606     unsigned char* pov) const
 607 {
 608   elfcpp::Rela_write<size, big_endian> orel(pov);
 609   this->rel_.write_rel(&orel);
 610   orel.put_r_addend(this->addend_);
 611 }
 612
 613 // Output_data_reloc_base methods.
 614
 615 // Adjust the output section.
 616
 617 template<int sh_type, bool dynamic, int size, bool big_endian>
 618 void
 619 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
 620     ::do_adjust_output_section(Output_section* os)
 621 {
 622   if (sh_type == elfcpp::SHT_REL)
 623     os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
 624   else if (sh_type == elfcpp::SHT_RELA)
 625     os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
 626   else
 627     gold_unreachable();
 628   if (dynamic)
 629     os->set_should_link_to_dynsym();
 630   else
 631     os->set_should_link_to_symtab();
 632 }
 633
 634 // Write out relocation data.
 635
 636 template<int sh_type, bool dynamic, int size, bool big_endian>
 637 void
 638 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
 639     Output_file* of)
 640 {
 641   const off_t off = this->offset();
 642   const off_t oview_size = this->data_size();
 643   unsigned char* const oview = of->get_output_view(off, oview_size);
 644
 645   unsigned char* pov = oview;
 646   for (typename Relocs::const_iterator p = this->relocs_.begin();
 647        p != this->relocs_.end();
 648        ++p)
 649     {
 650       p->write(pov);
 651       pov += reloc_size;
 652     }
 653
 654   gold_assert(pov - oview == oview_size);
 655
 656   of->write_output_view(off, oview_size, oview);
 657
 658   // We no longer need the relocation entries.
 659   this->relocs_.clear();
 660 }
 661
 662 // Output_data_got::Got_entry methods.
 663
 664 // Write out the entry.
 665
 666 template<int size, bool big_endian>
 667 void
 668 Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov) const
 669 {
 670   Valtype val = 0;
 671
 672   switch (this->local_sym_index_)
 673     {
 674     case GSYM_CODE:
 675       {
 676         Symbol* gsym = this->u_.gsym;
 677
 678         // If the symbol is resolved locally, we need to write out its
 679         // value.  Otherwise we just write zero.  The target code is
 680         // responsible for creating a relocation entry to fill in the
 681         // value at runtime. For non-preemptible symbols in a shared
 682         // library, the target will need to record whether or not the
 683         // value should be written (e.g., it may use a RELATIVE
 684         // relocation type).
 685         if (gsym->final_value_is_known() || gsym->needs_value_in_got())
 686           {
 687             Sized_symbol<size>* sgsym;
 688             // This cast is a bit ugly.  We don't want to put a
 689             // virtual method in Symbol, because we want Symbol to be
 690             // as small as possible.
 691             sgsym = static_cast<Sized_symbol<size>*>(gsym);
 692             val = sgsym->value();
 693           }
 694       }
 695       break;
 696
 697     case CONSTANT_CODE:
 698       val = this->u_.constant;
 699       break;
 700
 701     default:
 702       val = this->u_.object->local_symbol_value(this->local_sym_index_);
 703       break;
 704     }
 705
 706   elfcpp::Swap<size, big_endian>::writeval(pov, val);
 707 }
 708
 709 // Output_data_got methods.
 710
 711 // Add an entry for a global symbol to the GOT.  This returns true if
 712 // this is a new GOT entry, false if the symbol already had a GOT
 713 // entry.
 714
 715 template<int size, bool big_endian>
 716 bool
 717 Output_data_got<size, big_endian>::add_global(Symbol* gsym)
 718 {
 719   if (gsym->has_got_offset())
 720     return false;
 721
 722   this->entries_.push_back(Got_entry(gsym));
 723   this->set_got_size();
 724   gsym->set_got_offset(this->last_got_offset());
 725   return true;
 726 }
 727
 728 // Add an entry for a local symbol to the GOT.  This returns true if
 729 // this is a new GOT entry, false if the symbol already has a GOT
 730 // entry.
 731
 732 template<int size, bool big_endian>
 733 bool
 734 Output_data_got<size, big_endian>::add_local(
 735     Sized_relobj<size, big_endian>* object,
 736     unsigned int symndx)
 737 {
 738   if (object->local_has_got_offset(symndx))
 739     return false;
 740
 741   this->entries_.push_back(Got_entry(object, symndx));
 742   this->set_got_size();
 743   object->set_local_got_offset(symndx, this->last_got_offset());
 744   return true;
 745 }
 746
 747 // Add an entry (or a pair of entries) for a global TLS symbol to the GOT.
 748 // In a pair of entries, the first value in the pair will be used for the
 749 // module index, and the second value will be used for the dtv-relative
 750 // offset. This returns true if this is a new GOT entry, false if the symbol
 751 // already has a GOT entry.
 752
 753 template<int size, bool big_endian>
 754 bool
 755 Output_data_got<size, big_endian>::add_global_tls(Symbol* gsym,
 756                                                   bool need_pair)
 757 {
 758   if (gsym->has_tls_got_offset(need_pair))
 759     return false;
 760
 761   this->entries_.push_back(Got_entry(gsym));
 762   gsym->set_tls_got_offset(this->last_got_offset(), need_pair);
 763   if (need_pair)
 764     this->entries_.push_back(Got_entry(gsym));
 765   this->set_got_size();
 766   return true;
 767 }
 768
 769 // Add an entry (or a pair of entries) for a local TLS symbol to the GOT.
 770 // In a pair of entries, the first value in the pair will be used for the
 771 // module index, and the second value will be used for the dtv-relative
 772 // offset. This returns true if this is a new GOT entry, false if the symbol
 773 // already has a GOT entry.
 774
 775 template<int size, bool big_endian>
 776 bool
 777 Output_data_got<size, big_endian>::add_local_tls(
 778     Sized_relobj<size, big_endian>* object,
 779     unsigned int symndx,
 780     bool need_pair)
 781 {
 782   if (object->local_has_tls_got_offset(symndx, need_pair))
 783     return false;
 784
 785   this->entries_.push_back(Got_entry(object, symndx));
 786   object->set_local_tls_got_offset(symndx, this->last_got_offset(), need_pair);
 787   if (need_pair)
 788     this->entries_.push_back(Got_entry(object, symndx));
 789   this->set_got_size();
 790   return true;
 791 }
 792
 793 // Write out the GOT.
 794
 795 template<int size, bool big_endian>
 796 void
 797 Output_data_got<size, big_endian>::do_write(Output_file* of)
 798 {
 799   const int add = size / 8;
 800
 801   const off_t off = this->offset();
 802   const off_t oview_size = this->data_size();
 803   unsigned char* const oview = of->get_output_view(off, oview_size);
 804
 805   unsigned char* pov = oview;
 806   for (typename Got_entries::const_iterator p = this->entries_.begin();
 807        p != this->entries_.end();
 808        ++p)
 809     {
 810       p->write(pov);
 811       pov += add;
 812     }
 813
 814   gold_assert(pov - oview == oview_size);
 815
 816   of->write_output_view(off, oview_size, oview);
 817
 818   // We no longer need the GOT entries.
 819   this->entries_.clear();
 820 }
 821
 822 // Output_data_dynamic::Dynamic_entry methods.
 823
 824 // Write out the entry.
 825
 826 template<int size, bool big_endian>
 827 void
 828 Output_data_dynamic::Dynamic_entry::write(
 829     unsigned char* pov,
 830     const Stringpool* pool
 831     ACCEPT_SIZE_ENDIAN) const
 832 {
 833   typename elfcpp::Elf_types<size>::Elf_WXword val;
 834   switch (this->classification_)
 835     {
 836     case DYNAMIC_NUMBER:
 837       val = this->u_.val;
 838       break;
 839
 840     case DYNAMIC_SECTION_ADDRESS:
 841       val = this->u_.od->address();
 842       break;
 843
 844     case DYNAMIC_SECTION_SIZE:
 845       val = this->u_.od->data_size();
 846       break;
 847
 848     case DYNAMIC_SYMBOL:
 849       {
 850         const Sized_symbol<size>* s =
 851           static_cast<const Sized_symbol<size>*>(this->u_.sym);
 852         val = s->value();
 853       }
 854       break;
 855
 856     case DYNAMIC_STRING:
 857       val = pool->get_offset(this->u_.str);
 858       break;
 859
 860     default:
 861       gold_unreachable();
 862     }
 863
 864   elfcpp::Dyn_write<size, big_endian> dw(pov);
 865   dw.put_d_tag(this->tag_);
 866   dw.put_d_val(val);
 867 }
 868
 869 // Output_data_dynamic methods.
 870
 871 // Adjust the output section to set the entry size.
 872
 873 void
 874 Output_data_dynamic::do_adjust_output_section(Output_section* os)
 875 {
 876   if (parameters->get_size() == 32)
 877     os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
 878   else if (parameters->get_size() == 64)
 879     os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
 880   else
 881     gold_unreachable();
 882 }
 883
 884 // Set the final data size.
 885
 886 void
 887 Output_data_dynamic::set_final_data_size()
 888 {
 889   // Add the terminating entry.
 890   this->add_constant(elfcpp::DT_NULL, 0);
 891
 892   int dyn_size;
 893   if (parameters->get_size() == 32)
 894     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
 895   else if (parameters->get_size() == 64)
 896     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
 897   else
 898     gold_unreachable();
 899   this->set_data_size(this->entries_.size() * dyn_size);
 900 }
 901
 902 // Write out the dynamic entries.
 903
 904 void
 905 Output_data_dynamic::do_write(Output_file* of)
 906 {
 907   if (parameters->get_size() == 32)
 908     {
 909       if (parameters->is_big_endian())
 910         {
 911 #ifdef HAVE_TARGET_32_BIG
 912           this->sized_write<32, true>(of);
 913 #else
 914           gold_unreachable();
 915 #endif
 916         }
 917       else
 918         {
 919 #ifdef HAVE_TARGET_32_LITTLE
 920           this->sized_write<32, false>(of);
 921 #else
 922           gold_unreachable();
 923 #endif
 924         }
 925     }
 926   else if (parameters->get_size() == 64)
 927     {
 928       if (parameters->is_big_endian())
 929         {
 930 #ifdef HAVE_TARGET_64_BIG
 931           this->sized_write<64, true>(of);
 932 #else
 933           gold_unreachable();
 934 #endif
 935         }
 936       else
 937         {
 938 #ifdef HAVE_TARGET_64_LITTLE
 939           this->sized_write<64, false>(of);
 940 #else
 941           gold_unreachable();
 942 #endif
 943         }
 944     }
 945   else
 946     gold_unreachable();
 947 }
 948
 949 template<int size, bool big_endian>
 950 void
 951 Output_data_dynamic::sized_write(Output_file* of)
 952 {
 953   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
 954
 955   const off_t offset = this->offset();
 956   const off_t oview_size = this->data_size();
 957   unsigned char* const oview = of->get_output_view(offset, oview_size);
 958
 959   unsigned char* pov = oview;
 960   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
 961        p != this->entries_.end();
 962        ++p)
 963     {
 964       p->write SELECT_SIZE_ENDIAN_NAME(size, big_endian)(
 965           pov, this->pool_ SELECT_SIZE_ENDIAN(size, big_endian));
 966       pov += dyn_size;
 967     }
 968
 969   gold_assert(pov - oview == oview_size);
 970
 971   of->write_output_view(offset, oview_size, oview);
 972
 973   // We no longer need the dynamic entries.
 974   this->entries_.clear();
 975 }
 976
 977 // Output_section::Input_section methods.
 978
 979 // Return the data size.  For an input section we store the size here.
 980 // For an Output_section_data, we have to ask it for the size.
 981
 982 off_t
 983 Output_section::Input_section::data_size() const
 984 {
 985   if (this->is_input_section())
 986     return this->u1_.data_size;
 987   else
 988     return this->u2_.posd->data_size();
 989 }
 990
 991 // Set the address and file offset.
 992
 993 void
 994 Output_section::Input_section::set_address_and_file_offset(
 995     uint64_t address,
 996     off_t file_offset,
 997     off_t section_file_offset)
 998 {
 999   if (this->is_input_section())
1000     this->u2_.object->set_section_offset(this->shndx_,
1001                                          file_offset - section_file_offset);
1002   else
1003     this->u2_.posd->set_address_and_file_offset(address, file_offset);
1004 }
1005
1006 // Finalize the data size.
1007
1008 void
1009 Output_section::Input_section::finalize_data_size()
1010 {
1011   if (!this->is_input_section())
1012     this->u2_.posd->finalize_data_size();
1013 }
1014
1015 // Try to turn an input offset into an output offset.
1016
1017 bool
1018 Output_section::Input_section::output_offset(const Relobj* object,
1019                                              unsigned int shndx,
1020                                              off_t offset,
1021                                              off_t *poutput) const
1022 {
1023   if (!this->is_input_section())
1024     return this->u2_.posd->output_offset(object, shndx, offset, poutput);
1025   else
1026     {
1027       if (this->shndx_ != shndx || this->u2_.object != object)
1028         return false;
1029       off_t output_offset;
1030       Output_section* os = object->output_section(shndx, &output_offset);
1031       gold_assert(os != NULL);
1032       gold_assert(output_offset != -1);
1033       *poutput = output_offset + offset;
1034       return true;
1035     }
1036 }
1037
1038 // Write out the data.  We don't have to do anything for an input
1039 // section--they are handled via Object::relocate--but this is where
1040 // we write out the data for an Output_section_data.
1041
1042 void
1043 Output_section::Input_section::write(Output_file* of)
1044 {
1045   if (!this->is_input_section())
1046     this->u2_.posd->write(of);
1047 }
1048
1049 // Write the data to a buffer.  As for write(), we don't have to do
1050 // anything for an input section.
1051
1052 void
1053 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
1054 {
1055   if (!this->is_input_section())
1056     this->u2_.posd->write_to_buffer(buffer);
1057 }
1058
1059 // Output_section methods.
1060
1061 // Construct an Output_section.  NAME will point into a Stringpool.
1062
1063 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
1064                                elfcpp::Elf_Xword flags)
1065   : name_(name),
1066     addralign_(0),
1067     entsize_(0),
1068     link_section_(NULL),
1069     link_(0),
1070     info_section_(NULL),
1071     info_(0),
1072     type_(type),
1073     flags_(flags),
1074     out_shndx_(-1U),
1075     symtab_index_(0),
1076     dynsym_index_(0),
1077     input_sections_(),
1078     first_input_offset_(0),
1079     fills_(),
1080     postprocessing_buffer_(NULL),
1081     needs_symtab_index_(false),
1082     needs_dynsym_index_(false),
1083     should_link_to_symtab_(false),
1084     should_link_to_dynsym_(false),
1085     after_input_sections_(false),
1086     requires_postprocessing_(false)
1087 {
1088   // An unallocated section has no address.  Forcing this means that
1089   // we don't need special treatment for symbols defined in debug
1090   // sections.
1091   if ((flags & elfcpp::SHF_ALLOC) == 0)
1092     this->set_address(0);
1093 }
1094
1095 Output_section::~Output_section()
1096 {
1097 }
1098
1099 // Set the entry size.
1100
1101 void
1102 Output_section::set_entsize(uint64_t v)
1103 {
1104   if (this->entsize_ == 0)
1105     this->entsize_ = v;
1106   else
1107     gold_assert(this->entsize_ == v);
1108 }
1109
1110 // Add the input section SHNDX, with header SHDR, named SECNAME, in
1111 // OBJECT, to the Output_section.  RELOC_SHNDX is the index of a
1112 // relocation section which applies to this section, or 0 if none, or
1113 // -1U if more than one.  Return the offset of the input section
1114 // within the output section.  Return -1 if the input section will
1115 // receive special handling.  In the normal case we don't always keep
1116 // track of input sections for an Output_section.  Instead, each
1117 // Object keeps track of the Output_section for each of its input
1118 // sections.
1119
1120 template<int size, bool big_endian>
1121 off_t
1122 Output_section::add_input_section(Sized_relobj<size, big_endian>* object,
1123                                   unsigned int shndx,
1124                                   const char* secname,
1125                                   const elfcpp::Shdr<size, big_endian>& shdr,
1126                                   unsigned int reloc_shndx)
1127 {
1128   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
1129   if ((addralign & (addralign - 1)) != 0)
1130     {
1131       object->error(_("invalid alignment %lu for section \"%s\""),
1132                     static_cast<unsigned long>(addralign), secname);
1133       addralign = 1;
1134     }
1135
1136   if (addralign > this->addralign_)
1137     this->addralign_ = addralign;
1138
1139   typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
1140   uint64_t entsize = shdr.get_sh_entsize();
1141
1142   // .debug_str is a mergeable string section, but is not always so
1143   // marked by compilers.  Mark manually here so we can optimize.
1144   if (strcmp(secname, ".debug_str") == 0)
1145     {
1146       sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
1147       entsize = 1;
1148     }
1149
1150   // If this is a SHF_MERGE section, we pass all the input sections to
1151   // a Output_data_merge.  We don't try to handle relocations for such
1152   // a section.
1153   if ((sh_flags & elfcpp::SHF_MERGE) != 0
1154       && reloc_shndx == 0)
1155     {
1156       if (this->add_merge_input_section(object, shndx, sh_flags,
1157                                         entsize, addralign))
1158         {
1159           // Tell the relocation routines that they need to call the
1160           // output_offset method to determine the final address.
1161           return -1;
1162         }
1163     }
1164
1165   off_t offset_in_section = this->current_data_size_for_child();
1166   off_t aligned_offset_in_section = align_address(offset_in_section,
1167                                                   addralign);
1168
1169   if (aligned_offset_in_section > offset_in_section
1170       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
1171       && object->target()->has_code_fill())
1172     {
1173       // We need to add some fill data.  Using fill_list_ when
1174       // possible is an optimization, since we will often have fill
1175       // sections without input sections.
1176       off_t fill_len = aligned_offset_in_section - offset_in_section;
1177       if (this->input_sections_.empty())
1178         this->fills_.push_back(Fill(offset_in_section, fill_len));
1179       else
1180         {
1181           // FIXME: When relaxing, the size needs to adjust to
1182           // maintain a constant alignment.
1183           std::string fill_data(object->target()->code_fill(fill_len));
1184           Output_data_const* odc = new Output_data_const(fill_data, 1);
1185           this->input_sections_.push_back(Input_section(odc));
1186         }
1187     }
1188
1189   this->set_current_data_size_for_child(aligned_offset_in_section
1190                                         + shdr.get_sh_size());
1191
1192   // We need to keep track of this section if we are already keeping
1193   // track of sections, or if we are relaxing.  FIXME: Add test for
1194   // relaxing.
1195   if (!this->input_sections_.empty())
1196     this->input_sections_.push_back(Input_section(object, shndx,
1197                                                   shdr.get_sh_size(),
1198                                                   addralign));
1199
1200   return aligned_offset_in_section;
1201 }
1202
1203 // Add arbitrary data to an output section.
1204
1205 void
1206 Output_section::add_output_section_data(Output_section_data* posd)
1207 {
1208   Input_section inp(posd);
1209   this->add_output_section_data(&inp);
1210 }
1211
1212 // Add arbitrary data to an output section by Input_section.
1213
1214 void
1215 Output_section::add_output_section_data(Input_section* inp)
1216 {
1217   if (this->input_sections_.empty())
1218     this->first_input_offset_ = this->current_data_size_for_child();
1219
1220   this->input_sections_.push_back(*inp);
1221
1222   uint64_t addralign = inp->addralign();
1223   if (addralign > this->addralign_)
1224     this->addralign_ = addralign;
1225
1226   inp->set_output_section(this);
1227 }
1228
1229 // Add a merge section to an output section.
1230
1231 void
1232 Output_section::add_output_merge_section(Output_section_data* posd,
1233                                          bool is_string, uint64_t entsize)
1234 {
1235   Input_section inp(posd, is_string, entsize);
1236   this->add_output_section_data(&inp);
1237 }
1238
1239 // Add an input section to a SHF_MERGE section.
1240
1241 bool
1242 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
1243                                         uint64_t flags, uint64_t entsize,
1244                                         uint64_t addralign)
1245 {
1246   bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
1247
1248   // We only merge strings if the alignment is not more than the
1249   // character size.  This could be handled, but it's unusual.
1250   if (is_string && addralign > entsize)
1251     return false;
1252
1253   Input_section_list::iterator p;
1254   for (p = this->input_sections_.begin();
1255        p != this->input_sections_.end();
1256        ++p)
1257     if (p->is_merge_section(is_string, entsize, addralign))
1258       {
1259         p->add_input_section(object, shndx);
1260         return true;
1261       }
1262
1263   // We handle the actual constant merging in Output_merge_data or
1264   // Output_merge_string_data.
1265   Output_section_data* posd;
1266   if (!is_string)
1267     posd = new Output_merge_data(entsize, addralign);
1268   else
1269     {
1270       switch (entsize)
1271         {
1272         case 1:
1273           posd = new Output_merge_string<char>(addralign);
1274           break;
1275         case 2:
1276           posd = new Output_merge_string<uint16_t>(addralign);
1277           break;
1278         case 4:
1279           posd = new Output_merge_string<uint32_t>(addralign);
1280           break;
1281         default:
1282           return false;
1283         }
1284     }
1285
1286   this->add_output_merge_section(posd, is_string, entsize);
1287   posd->add_input_section(object, shndx);
1288
1289   return true;
1290 }
1291
1292 // Given an address OFFSET relative to the start of input section
1293 // SHNDX in OBJECT, return whether this address is being included in
1294 // the final link.  This should only be called if SHNDX in OBJECT has
1295 // a special mapping.
1296
1297 bool
1298 Output_section::is_input_address_mapped(const Relobj* object,
1299                                         unsigned int shndx,
1300                                         off_t offset) const
1301 {
1302   gold_assert(object->is_section_specially_mapped(shndx));
1303
1304   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1305        p != this->input_sections_.end();
1306        ++p)
1307     {
1308       off_t output_offset;
1309       if (p->output_offset(object, shndx, offset, &output_offset))
1310         return output_offset != -1;
1311     }
1312
1313   // By default we assume that the address is mapped.  This should
1314   // only be called after we have passed all sections to Layout.  At
1315   // that point we should know what we are discarding.
1316   return true;
1317 }
1318
1319 // Given an address OFFSET relative to the start of input section
1320 // SHNDX in object OBJECT, return the output offset relative to the
1321 // start of the section.  This should only be called if SHNDX in
1322 // OBJECT has a special mapping.
1323
1324 off_t
1325 Output_section::output_offset(const Relobj* object, unsigned int shndx,
1326                               off_t offset) const
1327 {
1328   gold_assert(object->is_section_specially_mapped(shndx));
1329   // This can only be called meaningfully when layout is complete.
1330   gold_assert(Output_data::is_layout_complete());
1331
1332   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1333        p != this->input_sections_.end();
1334        ++p)
1335     {
1336       off_t output_offset;
1337       if (p->output_offset(object, shndx, offset, &output_offset))
1338         return output_offset;
1339     }
1340   gold_unreachable();
1341 }
1342
1343 // Return the output virtual address of OFFSET relative to the start
1344 // of input section SHNDX in object OBJECT.
1345
1346 uint64_t
1347 Output_section::output_address(const Relobj* object, unsigned int shndx,
1348                                off_t offset) const
1349 {
1350   gold_assert(object->is_section_specially_mapped(shndx));
1351   // This can only be called meaningfully when layout is complete.
1352   gold_assert(Output_data::is_layout_complete());
1353
1354   uint64_t addr = this->address() + this->first_input_offset_;
1355   for (Input_section_list::const_iterator p = this->input_sections_.begin();
1356        p != this->input_sections_.end();
1357        ++p)
1358     {
1359       addr = align_address(addr, p->addralign());
1360       off_t output_offset;
1361       if (p->output_offset(object, shndx, offset, &output_offset))
1362         {
1363           if (output_offset == -1)
1364             return -1U;
1365           return addr + output_offset;
1366         }
1367       addr += p->data_size();
1368     }
1369
1370   // If we get here, it means that we don't know the mapping for this
1371   // input section.  This might happen in principle if
1372   // add_input_section were called before add_output_section_data.
1373   // But it should never actually happen.
1374
1375   gold_unreachable();
1376 }
1377
1378 // Set the data size of an Output_section.  This is where we handle
1379 // setting the addresses of any Output_section_data objects.
1380
1381 void
1382 Output_section::set_final_data_size()
1383 {
1384   if (this->input_sections_.empty())
1385     {
1386       this->set_data_size(this->current_data_size_for_child());
1387       return;
1388     }
1389
1390   uint64_t address = this->address();
1391   off_t startoff = this->offset();
1392   off_t off = startoff + this->first_input_offset_;
1393   for (Input_section_list::iterator p = this->input_sections_.begin();
1394        p != this->input_sections_.end();
1395        ++p)
1396     {
1397       off = align_address(off, p->addralign());
1398       p->set_address_and_file_offset(address + (off - startoff), off,
1399                                      startoff);
1400       off += p->data_size();
1401     }
1402
1403   this->set_data_size(off - startoff);
1404 }
1405
1406 // Write the section header to *OSHDR.
1407
1408 template<int size, bool big_endian>
1409 void
1410 Output_section::write_header(const Layout* layout,
1411                              const Stringpool* secnamepool,
1412                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
1413 {
1414   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
1415   oshdr->put_sh_type(this->type_);
1416   oshdr->put_sh_flags(this->flags_);
1417   oshdr->put_sh_addr(this->address());
1418   oshdr->put_sh_offset(this->offset());
1419   oshdr->put_sh_size(this->data_size());
1420   if (this->link_section_ != NULL)
1421     oshdr->put_sh_link(this->link_section_->out_shndx());
1422   else if (this->should_link_to_symtab_)
1423     oshdr->put_sh_link(layout->symtab_section()->out_shndx());
1424   else if (this->should_link_to_dynsym_)
1425     oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
1426   else
1427     oshdr->put_sh_link(this->link_);
1428   if (this->info_section_ != NULL)
1429     oshdr->put_sh_info(this->info_section_->out_shndx());
1430   else
1431     oshdr->put_sh_info(this->info_);
1432   oshdr->put_sh_addralign(this->addralign_);
1433   oshdr->put_sh_entsize(this->entsize_);
1434 }
1435
1436 // Write out the data.  For input sections the data is written out by
1437 // Object::relocate, but we have to handle Output_section_data objects
1438 // here.
1439
1440 void
1441 Output_section::do_write(Output_file* of)
1442 {
1443   gold_assert(!this->requires_postprocessing());
1444
1445   off_t output_section_file_offset = this->offset();
1446   for (Fill_list::iterator p = this->fills_.begin();
1447        p != this->fills_.end();
1448        ++p)
1449     {
1450       std::string fill_data(of->target()->code_fill(p->length()));
1451       of->write(output_section_file_offset + p->section_offset(),
1452                 fill_data.data(), fill_data.size());
1453     }
1454
1455   for (Input_section_list::iterator p = this->input_sections_.begin();
1456        p != this->input_sections_.end();
1457        ++p)
1458     p->write(of);
1459 }
1460
1461 // If a section requires postprocessing, create the buffer to use.
1462
1463 void
1464 Output_section::create_postprocessing_buffer()
1465 {
1466   gold_assert(this->requires_postprocessing());
1467   gold_assert(this->postprocessing_buffer_ == NULL);
1468
1469   if (!this->input_sections_.empty())
1470     {
1471       off_t off = this->first_input_offset_;
1472       for (Input_section_list::iterator p = this->input_sections_.begin();
1473            p != this->input_sections_.end();
1474            ++p)
1475         {
1476           off = align_address(off, p->addralign());
1477           p->finalize_data_size();
1478           off += p->data_size();
1479         }
1480       this->set_current_data_size_for_child(off);
1481     }
1482
1483   off_t buffer_size = this->current_data_size_for_child();
1484   this->postprocessing_buffer_ = new unsigned char[buffer_size];
1485 }
1486
1487 // Write all the data of an Output_section into the postprocessing
1488 // buffer.  This is used for sections which require postprocessing,
1489 // such as compression.  Input sections are handled by
1490 // Object::Relocate.
1491
1492 void
1493 Output_section::write_to_postprocessing_buffer()
1494 {
1495   gold_assert(this->requires_postprocessing());
1496
1497   Target* target = parameters->target();
1498   unsigned char* buffer = this->postprocessing_buffer();
1499   for (Fill_list::iterator p = this->fills_.begin();
1500        p != this->fills_.end();
1501        ++p)
1502     {
1503       std::string fill_data(target->code_fill(p->length()));
1504       memcpy(buffer + p->section_offset(), fill_data.data(), fill_data.size());
1505     }
1506
1507   off_t off = this->first_input_offset_;
1508   for (Input_section_list::iterator p = this->input_sections_.begin();
1509        p != this->input_sections_.end();
1510        ++p)
1511     {
1512       off = align_address(off, p->addralign());
1513       p->write_to_buffer(buffer + off);
1514       off += p->data_size();
1515     }
1516 }
1517
1518 // Output segment methods.
1519
1520 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
1521   : output_data_(),
1522     output_bss_(),
1523     vaddr_(0),
1524     paddr_(0),
1525     memsz_(0),
1526     align_(0),
1527     offset_(0),
1528     filesz_(0),
1529     type_(type),
1530     flags_(flags),
1531     is_align_known_(false)
1532 {
1533 }
1534
1535 // Add an Output_section to an Output_segment.
1536
1537 void
1538 Output_segment::add_output_section(Output_section* os,
1539                                    elfcpp::Elf_Word seg_flags,
1540                                    bool front)
1541 {
1542   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
1543   gold_assert(!this->is_align_known_);
1544
1545   // Update the segment flags.
1546   this->flags_ |= seg_flags;
1547
1548   Output_segment::Output_data_list* pdl;
1549   if (os->type() == elfcpp::SHT_NOBITS)
1550     pdl = &this->output_bss_;
1551   else
1552     pdl = &this->output_data_;
1553
1554   // So that PT_NOTE segments will work correctly, we need to ensure
1555   // that all SHT_NOTE sections are adjacent.  This will normally
1556   // happen automatically, because all the SHT_NOTE input sections
1557   // will wind up in the same output section.  However, it is possible
1558   // for multiple SHT_NOTE input sections to have different section
1559   // flags, and thus be in different output sections, but for the
1560   // different section flags to map into the same segment flags and
1561   // thus the same output segment.
1562
1563   // Note that while there may be many input sections in an output
1564   // section, there are normally only a few output sections in an
1565   // output segment.  This loop is expected to be fast.
1566
1567   if (os->type() == elfcpp::SHT_NOTE && !pdl->empty())
1568     {
1569       Output_segment::Output_data_list::iterator p = pdl->end();
1570       do
1571         {
1572           --p;
1573           if ((*p)->is_section_type(elfcpp::SHT_NOTE))
1574             {
1575               // We don't worry about the FRONT parameter.
1576               ++p;
1577               pdl->insert(p, os);
1578               return;
1579             }
1580         }
1581       while (p != pdl->begin());
1582     }
1583
1584   // Similarly, so that PT_TLS segments will work, we need to group
1585   // SHF_TLS sections.  An SHF_TLS/SHT_NOBITS section is a special
1586   // case: we group the SHF_TLS/SHT_NOBITS sections right after the
1587   // SHF_TLS/SHT_PROGBITS sections.  This lets us set up PT_TLS
1588   // correctly.  SHF_TLS sections get added to both a PT_LOAD segment
1589   // and the PT_TLS segment -- we do this grouping only for the
1590   // PT_LOAD segment.
1591   if (this->type_ != elfcpp::PT_TLS
1592       && (os->flags() & elfcpp::SHF_TLS) != 0
1593       && !this->output_data_.empty())
1594     {
1595       pdl = &this->output_data_;
1596       bool nobits = os->type() == elfcpp::SHT_NOBITS;
1597       bool sawtls = false;
1598       Output_segment::Output_data_list::iterator p = pdl->end();
1599       do
1600         {
1601           --p;
1602           bool insert;
1603           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
1604             {
1605               sawtls = true;
1606               // Put a NOBITS section after the first TLS section.
1607               // But a PROGBITS section after the first TLS/PROGBITS
1608               // section.
1609               insert = nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS);
1610             }
1611           else
1612             {
1613               // If we've gone past the TLS sections, but we've seen a
1614               // TLS section, then we need to insert this section now.
1615               insert = sawtls;
1616             }
1617
1618           if (insert)
1619             {
1620               // We don't worry about the FRONT parameter.
1621               ++p;
1622               pdl->insert(p, os);
1623               return;
1624             }
1625         }
1626       while (p != pdl->begin());
1627
1628       // There are no TLS sections yet; put this one at the requested
1629       // location in the section list.
1630     }
1631
1632   if (front)
1633     pdl->push_front(os);
1634   else
1635     pdl->push_back(os);
1636 }
1637
1638 // Add an Output_data (which is not an Output_section) to the start of
1639 // a segment.
1640
1641 void
1642 Output_segment::add_initial_output_data(Output_data* od)
1643 {
1644   gold_assert(!this->is_align_known_);
1645   this->output_data_.push_front(od);
1646 }
1647
1648 // Return the maximum alignment of the Output_data in Output_segment.
1649 // Once we compute this, we prohibit new sections from being added.
1650
1651 uint64_t
1652 Output_segment::addralign()
1653 {
1654   if (!this->is_align_known_)
1655     {
1656       uint64_t addralign;
1657
1658       addralign = Output_segment::maximum_alignment(&this->output_data_);
1659       if (addralign > this->align_)
1660         this->align_ = addralign;
1661
1662       addralign = Output_segment::maximum_alignment(&this->output_bss_);
1663       if (addralign > this->align_)
1664         this->align_ = addralign;
1665
1666       this->is_align_known_ = true;
1667     }
1668
1669   return this->align_;
1670 }
1671
1672 // Return the maximum alignment of a list of Output_data.
1673
1674 uint64_t
1675 Output_segment::maximum_alignment(const Output_data_list* pdl)
1676 {
1677   uint64_t ret = 0;
1678   for (Output_data_list::const_iterator p = pdl->begin();
1679        p != pdl->end();
1680        ++p)
1681     {
1682       uint64_t addralign = (*p)->addralign();
1683       if (addralign > ret)
1684         ret = addralign;
1685     }
1686   return ret;
1687 }
1688
1689 // Return the number of dynamic relocs applied to this segment.
1690
1691 unsigned int
1692 Output_segment::dynamic_reloc_count() const
1693 {
1694   return (this->dynamic_reloc_count_list(&this->output_data_)
1695           + this->dynamic_reloc_count_list(&this->output_bss_));
1696 }
1697
1698 // Return the number of dynamic relocs applied to an Output_data_list.
1699
1700 unsigned int
1701 Output_segment::dynamic_reloc_count_list(const Output_data_list* pdl) const
1702 {
1703   unsigned int count = 0;
1704   for (Output_data_list::const_iterator p = pdl->begin();
1705        p != pdl->end();
1706        ++p)
1707     count += (*p)->dynamic_reloc_count();
1708   return count;
1709 }
1710
1711 // Set the section addresses for an Output_segment.  ADDR is the
1712 // address and *POFF is the file offset.  Set the section indexes
1713 // starting with *PSHNDX.  Return the address of the immediately
1714 // following segment.  Update *POFF and *PSHNDX.
1715
1716 uint64_t
1717 Output_segment::set_section_addresses(uint64_t addr, off_t* poff,
1718                                       unsigned int* pshndx)
1719 {
1720   gold_assert(this->type_ == elfcpp::PT_LOAD);
1721
1722   this->vaddr_ = addr;
1723   this->paddr_ = addr;
1724
1725   off_t orig_off = *poff;
1726   this->offset_ = orig_off;
1727
1728   *poff = align_address(*poff, this->addralign());
1729
1730   addr = this->set_section_list_addresses(&this->output_data_, addr, poff,
1731                                           pshndx);
1732   this->filesz_ = *poff - orig_off;
1733
1734   off_t off = *poff;
1735
1736   uint64_t ret = this->set_section_list_addresses(&this->output_bss_, addr,
1737                                                   poff, pshndx);
1738   this->memsz_ = *poff - orig_off;
1739
1740   // Ignore the file offset adjustments made by the BSS Output_data
1741   // objects.
1742   *poff = off;
1743
1744   return ret;
1745 }
1746
1747 // Set the addresses and file offsets in a list of Output_data
1748 // structures.
1749
1750 uint64_t
1751 Output_segment::set_section_list_addresses(Output_data_list* pdl,
1752                                            uint64_t addr, off_t* poff,
1753                                            unsigned int* pshndx)
1754 {
1755   off_t startoff = *poff;
1756
1757   off_t off = startoff;
1758   for (Output_data_list::iterator p = pdl->begin();
1759        p != pdl->end();
1760        ++p)
1761     {
1762       off = align_address(off, (*p)->addralign());
1763       (*p)->set_address_and_file_offset(addr + (off - startoff), off);
1764
1765       // Unless this is a PT_TLS segment, we want to ignore the size
1766       // of a SHF_TLS/SHT_NOBITS section.  Such a section does not
1767       // affect the size of a PT_LOAD segment.
1768       if (this->type_ == elfcpp::PT_TLS
1769           || !(*p)->is_section_flag_set(elfcpp::SHF_TLS)
1770           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
1771         off += (*p)->data_size();
1772
1773       if ((*p)->is_section())
1774         {
1775           (*p)->set_out_shndx(*pshndx);
1776           ++*pshndx;
1777         }
1778     }
1779
1780   *poff = off;
1781   return addr + (off - startoff);
1782 }
1783
1784 // For a non-PT_LOAD segment, set the offset from the sections, if
1785 // any.
1786
1787 void
1788 Output_segment::set_offset()
1789 {
1790   gold_assert(this->type_ != elfcpp::PT_LOAD);
1791
1792   if (this->output_data_.empty() && this->output_bss_.empty())
1793     {
1794       this->vaddr_ = 0;
1795       this->paddr_ = 0;
1796       this->memsz_ = 0;
1797       this->align_ = 0;
1798       this->offset_ = 0;
1799       this->filesz_ = 0;
1800       return;
1801     }
1802
1803   const Output_data* first;
1804   if (this->output_data_.empty())
1805     first = this->output_bss_.front();
1806   else
1807     first = this->output_data_.front();
1808   this->vaddr_ = first->address();
1809   this->paddr_ = this->vaddr_;
1810   this->offset_ = first->offset();
1811
1812   if (this->output_data_.empty())
1813     this->filesz_ = 0;
1814   else
1815     {
1816       const Output_data* last_data = this->output_data_.back();
1817       this->filesz_ = (last_data->address()
1818                        + last_data->data_size()
1819                        - this->vaddr_);
1820     }
1821
1822   const Output_data* last;
1823   if (this->output_bss_.empty())
1824     last = this->output_data_.back();
1825   else
1826     last = this->output_bss_.back();
1827   this->memsz_ = (last->address()
1828                   + last->data_size()
1829                   - this->vaddr_);
1830 }
1831
1832 // Return the number of Output_sections in an Output_segment.
1833
1834 unsigned int
1835 Output_segment::output_section_count() const
1836 {
1837   return (this->output_section_count_list(&this->output_data_)
1838           + this->output_section_count_list(&this->output_bss_));
1839 }
1840
1841 // Return the number of Output_sections in an Output_data_list.
1842
1843 unsigned int
1844 Output_segment::output_section_count_list(const Output_data_list* pdl) const
1845 {
1846   unsigned int count = 0;
1847   for (Output_data_list::const_iterator p = pdl->begin();
1848        p != pdl->end();
1849        ++p)
1850     {
1851       if ((*p)->is_section())
1852         ++count;
1853     }
1854   return count;
1855 }
1856
1857 // Write the segment data into *OPHDR.
1858
1859 template<int size, bool big_endian>
1860 void
1861 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
1862 {
1863   ophdr->put_p_type(this->type_);
1864   ophdr->put_p_offset(this->offset_);
1865   ophdr->put_p_vaddr(this->vaddr_);
1866   ophdr->put_p_paddr(this->paddr_);
1867   ophdr->put_p_filesz(this->filesz_);
1868   ophdr->put_p_memsz(this->memsz_);
1869   ophdr->put_p_flags(this->flags_);
1870   ophdr->put_p_align(this->addralign());
1871 }
1872
1873 // Write the section headers into V.
1874
1875 template<int size, bool big_endian>
1876 unsigned char*
1877 Output_segment::write_section_headers(const Layout* layout,
1878                                       const Stringpool* secnamepool,
1879                                       unsigned char* v,
1880                                       unsigned int *pshndx
1881                                       ACCEPT_SIZE_ENDIAN) const
1882 {
1883   // Every section that is attached to a segment must be attached to a
1884   // PT_LOAD segment, so we only write out section headers for PT_LOAD
1885   // segments.
1886   if (this->type_ != elfcpp::PT_LOAD)
1887     return v;
1888
1889   v = this->write_section_headers_list
1890       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
1891           layout, secnamepool, &this->output_data_, v, pshndx
1892           SELECT_SIZE_ENDIAN(size, big_endian));
1893   v = this->write_section_headers_list
1894       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
1895           layout, secnamepool, &this->output_bss_, v, pshndx
1896           SELECT_SIZE_ENDIAN(size, big_endian));
1897   return v;
1898 }
1899
1900 template<int size, bool big_endian>
1901 unsigned char*
1902 Output_segment::write_section_headers_list(const Layout* layout,
1903                                            const Stringpool* secnamepool,
1904                                            const Output_data_list* pdl,
1905                                            unsigned char* v,
1906                                            unsigned int* pshndx
1907                                            ACCEPT_SIZE_ENDIAN) const
1908 {
1909   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
1910   for (Output_data_list::const_iterator p = pdl->begin();
1911        p != pdl->end();
1912        ++p)
1913     {
1914       if ((*p)->is_section())
1915         {
1916           const Output_section* ps = static_cast<const Output_section*>(*p);
1917           gold_assert(*pshndx == ps->out_shndx());
1918           elfcpp::Shdr_write<size, big_endian> oshdr(v);
1919           ps->write_header(layout, secnamepool, &oshdr);
1920           v += shdr_size;
1921           ++*pshndx;
1922         }
1923     }
1924   return v;
1925 }
1926
1927 // Output_file methods.
1928
1929 Output_file::Output_file(const General_options& options, Target* target)
1930   : options_(options),
1931     target_(target),
1932     name_(options.output_file_name()),
1933     o_(-1),
1934     file_size_(0),
1935     base_(NULL),
1936     map_is_anonymous_(false)
1937 {
1938 }
1939
1940 // Open the output file.
1941
1942 void
1943 Output_file::open(off_t file_size)
1944 {
1945   this->file_size_ = file_size;
1946
1947   // Unlink the file first; otherwise the open() may fail if the file
1948   // is busy (e.g. it's an executable that's currently being executed).
1949   //
1950   // However, the linker may be part of a system where a zero-length
1951   // file is created for it to write to, with tight permissions (gcc
1952   // 2.95 did something like this).  Unlinking the file would work
1953   // around those permission controls, so we only unlink if the file
1954   // has a non-zero size.  We also unlink only regular files to avoid
1955   // trouble with directories/etc.
1956   //
1957   // If we fail, continue; this command is merely a best-effort attempt
1958   // to improve the odds for open().
1959
1960   // We let the name "-" mean "stdout"
1961   if (strcmp(this->name_, "-") == 0)
1962     this->o_ = STDOUT_FILENO;
1963   else
1964     {
1965       struct stat s;
1966       if (::stat(this->name_, &s) == 0 && s.st_size != 0)
1967         unlink_if_ordinary(this->name_);
1968
1969       int mode = parameters->output_is_object() ? 0666 : 0777;
1970       int o = ::open(this->name_, O_RDWR | O_CREAT | O_TRUNC, mode);
1971       if (o < 0)
1972         gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
1973       this->o_ = o;
1974     }
1975
1976   this->map();
1977 }
1978
1979 // Resize the output file.
1980
1981 void
1982 Output_file::resize(off_t file_size)
1983 {
1984   // If the mmap is mapping an anonymous memory buffer, this is easy:
1985   // just mremap to the new size.  If it's mapping to a file, we want
1986   // to unmap to flush to the file, then remap after growing the file.
1987   if (this->map_is_anonymous_)
1988     {
1989       void* base = ::mremap(this->base_, this->file_size_, file_size,
1990                             MREMAP_MAYMOVE);
1991       if (base == MAP_FAILED)
1992         gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
1993       this->base_ = static_cast<unsigned char*>(base);
1994       this->file_size_ = file_size;
1995     }
1996   else
1997     {
1998       this->unmap();
1999       this->file_size_ = file_size;
2000       this->map();
2001     }
2002 }
2003
2004 // Map the file into memory.
2005
2006 void
2007 Output_file::map()
2008 {
2009   const int o = this->o_;
2010
2011   // If the output file is not a regular file, don't try to mmap it;
2012   // instead, we'll mmap a block of memory (an anonymous buffer), and
2013   // then later write the buffer to the file.
2014   void* base;
2015   struct stat statbuf;
2016   if (o == STDOUT_FILENO || o == STDERR_FILENO
2017       || ::fstat(o, &statbuf) != 0
2018       || !S_ISREG(statbuf.st_mode))
2019     {
2020       this->map_is_anonymous_ = true;
2021       base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
2022                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
2023     }
2024   else
2025     {
2026       // Write out one byte to make the file the right size.
2027       if (::lseek(o, this->file_size_ - 1, SEEK_SET) < 0)
2028         gold_fatal(_("%s: lseek: %s"), this->name_, strerror(errno));
2029       char b = 0;
2030       if (::write(o, &b, 1) != 1)
2031         gold_fatal(_("%s: write: %s"), this->name_, strerror(errno));
2032
2033       // Map the file into memory.
2034       this->map_is_anonymous_ = false;
2035       base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
2036                     MAP_SHARED, o, 0);
2037     }
2038   if (base == MAP_FAILED)
2039     gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
2040   this->base_ = static_cast<unsigned char*>(base);
2041 }
2042
2043 // Unmap the file from memory.
2044
2045 void
2046 Output_file::unmap()
2047 {
2048   if (::munmap(this->base_, this->file_size_) < 0)
2049     gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
2050   this->base_ = NULL;
2051 }
2052
2053 // Close the output file.
2054
2055 void
2056 Output_file::close()
2057 {
2058   // If the map isn't file-backed, we need to write it now.
2059   if (this->map_is_anonymous_)
2060     {
2061       size_t bytes_to_write = this->file_size_;
2062       while (bytes_to_write > 0)
2063         {
2064           ssize_t bytes_written = ::write(this->o_, this->base_, bytes_to_write);
2065           if (bytes_written == 0)
2066             gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
2067           else if (bytes_written < 0)
2068             gold_error(_("%s: write: %s"), this->name_, strerror(errno));
2069           else
2070             bytes_to_write -= bytes_written;
2071         }
2072     }
2073   this->unmap();
2074
2075   // We don't close stdout or stderr
2076   if (this->o_ != STDOUT_FILENO && this->o_ != STDERR_FILENO)
2077     if (::close(this->o_) < 0)
2078       gold_error(_("%s: close: %s"), this->name_, strerror(errno));
2079   this->o_ = -1;
2080 }
2081
2082 // Instantiate the templates we need.  We could use the configure
2083 // script to restrict this to only the ones for implemented targets.
2084
2085 #ifdef HAVE_TARGET_32_LITTLE
2086 template
2087 off_t
2088 Output_section::add_input_section<32, false>(
2089     Sized_relobj<32, false>* object,
2090     unsigned int shndx,
2091     const char* secname,
2092     const elfcpp::Shdr<32, false>& shdr,
2093     unsigned int reloc_shndx);
2094 #endif
2095
2096 #ifdef HAVE_TARGET_32_BIG
2097 template
2098 off_t
2099 Output_section::add_input_section<32, true>(
2100     Sized_relobj<32, true>* object,
2101     unsigned int shndx,
2102     const char* secname,
2103     const elfcpp::Shdr<32, true>& shdr,
2104     unsigned int reloc_shndx);
2105 #endif
2106
2107 #ifdef HAVE_TARGET_64_LITTLE
2108 template
2109 off_t
2110 Output_section::add_input_section<64, false>(
2111     Sized_relobj<64, false>* object,
2112     unsigned int shndx,
2113     const char* secname,
2114     const elfcpp::Shdr<64, false>& shdr,
2115     unsigned int reloc_shndx);
2116 #endif
2117
2118 #ifdef HAVE_TARGET_64_BIG
2119 template
2120 off_t
2121 Output_section::add_input_section<64, true>(
2122     Sized_relobj<64, true>* object,
2123     unsigned int shndx,
2124     const char* secname,
2125     const elfcpp::Shdr<64, true>& shdr,
2126     unsigned int reloc_shndx);
2127 #endif
2128
2129 #ifdef HAVE_TARGET_32_LITTLE
2130 template
2131 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
2132 #endif
2133
2134 #ifdef HAVE_TARGET_32_BIG
2135 template
2136 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
2137 #endif
2138
2139 #ifdef HAVE_TARGET_64_LITTLE
2140 template
2141 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
2142 #endif
2143
2144 #ifdef HAVE_TARGET_64_BIG
2145 template
2146 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
2147 #endif
2148
2149 #ifdef HAVE_TARGET_32_LITTLE
2150 template
2151 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
2152 #endif
2153
2154 #ifdef HAVE_TARGET_32_BIG
2155 template
2156 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
2157 #endif
2158
2159 #ifdef HAVE_TARGET_64_LITTLE
2160 template
2161 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
2162 #endif
2163
2164 #ifdef HAVE_TARGET_64_BIG
2165 template
2166 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
2167 #endif
2168
2169 #ifdef HAVE_TARGET_32_LITTLE
2170 template
2171 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
2172 #endif
2173
2174 #ifdef HAVE_TARGET_32_BIG
2175 template
2176 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
2177 #endif
2178
2179 #ifdef HAVE_TARGET_64_LITTLE
2180 template
2181 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
2182 #endif
2183
2184 #ifdef HAVE_TARGET_64_BIG
2185 template
2186 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
2187 #endif
2188
2189 #ifdef HAVE_TARGET_32_LITTLE
2190 template
2191 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
2192 #endif
2193
2194 #ifdef HAVE_TARGET_32_BIG
2195 template
2196 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
2197 #endif
2198
2199 #ifdef HAVE_TARGET_64_LITTLE
2200 template
2201 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
2202 #endif
2203
2204 #ifdef HAVE_TARGET_64_BIG
2205 template
2206 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
2207 #endif
2208
2209 #ifdef HAVE_TARGET_32_LITTLE
2210 template
2211 class Output_data_got<32, false>;
2212 #endif
2213
2214 #ifdef HAVE_TARGET_32_BIG
2215 template
2216 class Output_data_got<32, true>;
2217 #endif
2218
2219 #ifdef HAVE_TARGET_64_LITTLE
2220 template
2221 class Output_data_got<64, false>;
2222 #endif
2223
2224 #ifdef HAVE_TARGET_64_BIG
2225 template
2226 class Output_data_got<64, true>;
2227 #endif
2228
2229 } // End namespace gold.