gold/output.cc

   1 // output.cc -- manage the output file for gold
   2
   3 #include "gold.h"
   4
   5 #include <cstdlib>
   6 #include <cerrno>
   7 #include <fcntl.h>
   8 #include <unistd.h>
   9 #include <sys/mman.h>
  10 #include <algorithm>
  11
  12 #include "object.h"
  13 #include "symtab.h"
  14 #include "reloc.h"
  15 #include "output.h"
  16
  17 namespace gold
  18 {
  19
  20 // Output_data variables.
  21
  22 bool Output_data::sizes_are_fixed;
  23
  24 // Output_data methods.
  25
  26 Output_data::~Output_data()
  27 {
  28 }
  29
  30 // Set the address and offset.
  31
  32 void
  33 Output_data::set_address(uint64_t addr, off_t off)
  34 {
  35   this->address_ = addr;
  36   this->offset_ = off;
  37
  38   // Let the child class know.
  39   this->do_set_address(addr, off);
  40 }
  41
  42 // Return the default alignment for a size--32 or 64.
  43
  44 uint64_t
  45 Output_data::default_alignment(int size)
  46 {
  47   if (size == 32)
  48     return 4;
  49   else if (size == 64)
  50     return 8;
  51   else
  52     gold_unreachable();
  53 }
  54
  55 // Output_section_header methods.  This currently assumes that the
  56 // segment and section lists are complete at construction time.
  57
  58 Output_section_headers::Output_section_headers(
  59     int size,
  60     bool big_endian,
  61     const Layout::Segment_list& segment_list,
  62     const Layout::Section_list& unattached_section_list,
  63     const Stringpool* secnamepool)
  64   : size_(size),
  65     big_endian_(big_endian),
  66     segment_list_(segment_list),
  67     unattached_section_list_(unattached_section_list),
  68     secnamepool_(secnamepool)
  69 {
  70   // Count all the sections.  Start with 1 for the null section.
  71   off_t count = 1;
  72   for (Layout::Segment_list::const_iterator p = segment_list.begin();
  73        p != segment_list.end();
  74        ++p)
  75     if ((*p)->type() == elfcpp::PT_LOAD)
  76       count += (*p)->output_section_count();
  77   count += unattached_section_list.size();
  78
  79   int shdr_size;
  80   if (size == 32)
  81     shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
  82   else if (size == 64)
  83     shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
  84   else
  85     gold_unreachable();
  86
  87   this->set_data_size(count * shdr_size);
  88 }
  89
  90 // Write out the section headers.
  91
  92 void
  93 Output_section_headers::do_write(Output_file* of)
  94 {
  95   if (this->size_ == 32)
  96     {
  97       if (this->big_endian_)
  98         this->do_sized_write<32, true>(of);
  99       else
 100         this->do_sized_write<32, false>(of);
 101     }
 102   else if (this->size_ == 64)
 103     {
 104       if (this->big_endian_)
 105         this->do_sized_write<64, true>(of);
 106       else
 107         this->do_sized_write<64, false>(of);
 108     }
 109   else
 110     gold_unreachable();
 111 }
 112
 113 template<int size, bool big_endian>
 114 void
 115 Output_section_headers::do_sized_write(Output_file* of)
 116 {
 117   off_t all_shdrs_size = this->data_size();
 118   unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
 119
 120   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
 121   unsigned char* v = view;
 122
 123   {
 124     typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
 125     oshdr.put_sh_name(0);
 126     oshdr.put_sh_type(elfcpp::SHT_NULL);
 127     oshdr.put_sh_flags(0);
 128     oshdr.put_sh_addr(0);
 129     oshdr.put_sh_offset(0);
 130     oshdr.put_sh_size(0);
 131     oshdr.put_sh_link(0);
 132     oshdr.put_sh_info(0);
 133     oshdr.put_sh_addralign(0);
 134     oshdr.put_sh_entsize(0);
 135   }
 136
 137   v += shdr_size;
 138
 139   unsigned shndx = 1;
 140   for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
 141        p != this->segment_list_.end();
 142        ++p)
 143     v = (*p)->write_section_headers SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
 144             this->secnamepool_, v, &shndx
 145             SELECT_SIZE_ENDIAN(size, big_endian));
 146   for (Layout::Section_list::const_iterator p =
 147          this->unattached_section_list_.begin();
 148        p != this->unattached_section_list_.end();
 149        ++p)
 150     {
 151       gold_assert(shndx == (*p)->out_shndx());
 152       elfcpp::Shdr_write<size, big_endian> oshdr(v);
 153       (*p)->write_header(this->secnamepool_, &oshdr);
 154       v += shdr_size;
 155       ++shndx;
 156     }
 157
 158   of->write_output_view(this->offset(), all_shdrs_size, view);
 159 }
 160
 161 // Output_segment_header methods.
 162
 163 Output_segment_headers::Output_segment_headers(
 164     int size,
 165     bool big_endian,
 166     const Layout::Segment_list& segment_list)
 167   : size_(size), big_endian_(big_endian), segment_list_(segment_list)
 168 {
 169   int phdr_size;
 170   if (size == 32)
 171     phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
 172   else if (size == 64)
 173     phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
 174   else
 175     gold_unreachable();
 176
 177   this->set_data_size(segment_list.size() * phdr_size);
 178 }
 179
 180 void
 181 Output_segment_headers::do_write(Output_file* of)
 182 {
 183   if (this->size_ == 32)
 184     {
 185       if (this->big_endian_)
 186         this->do_sized_write<32, true>(of);
 187       else
 188         this->do_sized_write<32, false>(of);
 189     }
 190   else if (this->size_ == 64)
 191     {
 192       if (this->big_endian_)
 193         this->do_sized_write<64, true>(of);
 194       else
 195         this->do_sized_write<64, false>(of);
 196     }
 197   else
 198     gold_unreachable();
 199 }
 200
 201 template<int size, bool big_endian>
 202 void
 203 Output_segment_headers::do_sized_write(Output_file* of)
 204 {
 205   const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
 206   off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
 207   unsigned char* view = of->get_output_view(this->offset(),
 208                                             all_phdrs_size);
 209   unsigned char* v = view;
 210   for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
 211        p != this->segment_list_.end();
 212        ++p)
 213     {
 214       elfcpp::Phdr_write<size, big_endian> ophdr(v);
 215       (*p)->write_header(&ophdr);
 216       v += phdr_size;
 217     }
 218
 219   of->write_output_view(this->offset(), all_phdrs_size, view);
 220 }
 221
 222 // Output_file_header methods.
 223
 224 Output_file_header::Output_file_header(int size,
 225                                        bool big_endian,
 226                                        const General_options& options,
 227                                        const Target* target,
 228                                        const Symbol_table* symtab,
 229                                        const Output_segment_headers* osh)
 230   : size_(size),
 231     big_endian_(big_endian),
 232     options_(options),
 233     target_(target),
 234     symtab_(symtab),
 235     segment_header_(osh),
 236     section_header_(NULL),
 237     shstrtab_(NULL)
 238 {
 239   int ehdr_size;
 240   if (size == 32)
 241     ehdr_size = elfcpp::Elf_sizes<32>::ehdr_size;
 242   else if (size == 64)
 243     ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size;
 244   else
 245     gold_unreachable();
 246
 247   this->set_data_size(ehdr_size);
 248 }
 249
 250 // Set the section table information for a file header.
 251
 252 void
 253 Output_file_header::set_section_info(const Output_section_headers* shdrs,
 254                                      const Output_section* shstrtab)
 255 {
 256   this->section_header_ = shdrs;
 257   this->shstrtab_ = shstrtab;
 258 }
 259
 260 // Write out the file header.
 261
 262 void
 263 Output_file_header::do_write(Output_file* of)
 264 {
 265   if (this->size_ == 32)
 266     {
 267       if (this->big_endian_)
 268         this->do_sized_write<32, true>(of);
 269       else
 270         this->do_sized_write<32, false>(of);
 271     }
 272   else if (this->size_ == 64)
 273     {
 274       if (this->big_endian_)
 275         this->do_sized_write<64, true>(of);
 276       else
 277         this->do_sized_write<64, false>(of);
 278     }
 279   else
 280     gold_unreachable();
 281 }
 282
 283 // Write out the file header with appropriate size and endianess.
 284
 285 template<int size, bool big_endian>
 286 void
 287 Output_file_header::do_sized_write(Output_file* of)
 288 {
 289   gold_assert(this->offset() == 0);
 290
 291   int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
 292   unsigned char* view = of->get_output_view(0, ehdr_size);
 293   elfcpp::Ehdr_write<size, big_endian> oehdr(view);
 294
 295   unsigned char e_ident[elfcpp::EI_NIDENT];
 296   memset(e_ident, 0, elfcpp::EI_NIDENT);
 297   e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
 298   e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
 299   e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
 300   e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
 301   if (size == 32)
 302     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
 303   else if (size == 64)
 304     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
 305   else
 306     gold_unreachable();
 307   e_ident[elfcpp::EI_DATA] = (big_endian
 308                               ? elfcpp::ELFDATA2MSB
 309                               : elfcpp::ELFDATA2LSB);
 310   e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
 311   // FIXME: Some targets may need to set EI_OSABI and EI_ABIVERSION.
 312   oehdr.put_e_ident(e_ident);
 313
 314   elfcpp::ET e_type;
 315   // FIXME: ET_DYN.
 316   if (this->options_.is_relocatable())
 317     e_type = elfcpp::ET_REL;
 318   else
 319     e_type = elfcpp::ET_EXEC;
 320   oehdr.put_e_type(e_type);
 321
 322   oehdr.put_e_machine(this->target_->machine_code());
 323   oehdr.put_e_version(elfcpp::EV_CURRENT);
 324
 325   // FIXME: Need to support -e, and target specific entry symbol.
 326   Symbol* sym = this->symtab_->lookup("_start");
 327   typename Sized_symbol<size>::Value_type v;
 328   if (sym == NULL)
 329     v = 0;
 330   else
 331     {
 332       Sized_symbol<size>* ssym;
 333       ssym = this->symtab_->get_sized_symbol SELECT_SIZE_NAME(size) (
 334         sym SELECT_SIZE(size));
 335       v = ssym->value();
 336     }
 337   oehdr.put_e_entry(v);
 338
 339   oehdr.put_e_phoff(this->segment_header_->offset());
 340   oehdr.put_e_shoff(this->section_header_->offset());
 341
 342   // FIXME: The target needs to set the flags.
 343   oehdr.put_e_flags(0);
 344
 345   oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
 346   oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
 347   oehdr.put_e_phnum(this->segment_header_->data_size()
 348                      / elfcpp::Elf_sizes<size>::phdr_size);
 349   oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
 350   oehdr.put_e_shnum(this->section_header_->data_size()
 351                      / elfcpp::Elf_sizes<size>::shdr_size);
 352   oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
 353
 354   of->write_output_view(0, ehdr_size, view);
 355 }
 356
 357 // Output_data_const methods.
 358
 359 void
 360 Output_data_const::do_write(Output_file* of)
 361 {
 362   of->write(this->offset(), this->data_.data(), this->data_.size());
 363 }
 364
 365 // Output_data_const_buffer methods.
 366
 367 void
 368 Output_data_const_buffer::do_write(Output_file* of)
 369 {
 370   of->write(this->offset(), this->p_, this->data_size());
 371 }
 372
 373 // Output_section_data methods.
 374
 375 unsigned int
 376 Output_section_data::do_out_shndx() const
 377 {
 378   gold_assert(this->output_section_ != NULL);
 379   return this->output_section_->out_shndx();
 380 }
 381
 382 // Output_data_strtab methods.
 383
 384 // Set the address.  We don't actually care about the address, but we
 385 // do set our final size.
 386
 387 void
 388 Output_data_strtab::do_set_address(uint64_t, off_t)
 389 {
 390   this->strtab_->set_string_offsets();
 391   this->set_data_size(this->strtab_->get_strtab_size());
 392 }
 393
 394 // Write out a string table.
 395
 396 void
 397 Output_data_strtab::do_write(Output_file* of)
 398 {
 399   this->strtab_->write(of, this->offset());
 400 }
 401
 402 // Output_reloc methods.
 403
 404 // Get the symbol index of a relocation.
 405
 406 template<bool dynamic, int size, bool big_endian>
 407 unsigned int
 408 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 409   const
 410 {
 411   unsigned int index;
 412   switch (this->local_sym_index_)
 413     {
 414     case INVALID_CODE:
 415       gold_unreachable();
 416
 417     case GSYM_CODE:
 418       if (this->u1_.gsym == NULL)
 419         index = 0;
 420       else if (dynamic)
 421         index = this->u1_.gsym->dynsym_index();
 422       else
 423         index = this->u1_.gsym->symtab_index();
 424       break;
 425
 426     case SECTION_CODE:
 427       if (dynamic)
 428         index = this->u1_.os->dynsym_index();
 429       else
 430         index = this->u1_.os->symtab_index();
 431       break;
 432
 433     default:
 434       if (dynamic)
 435         {
 436           // FIXME: It seems that some targets may need to generate
 437           // dynamic relocations against local symbols for some
 438           // reasons.  This will have to be addressed at some point.
 439           gold_unreachable();
 440         }
 441       else
 442         index = this->u1_.relobj->symtab_index(this->local_sym_index_);
 443       break;
 444     }
 445   gold_assert(index != -1U);
 446   return index;
 447 }
 448
 449 // Write out the offset and info fields of a Rel or Rela relocation
 450 // entry.
 451
 452 template<bool dynamic, int size, bool big_endian>
 453 template<typename Write_rel>
 454 void
 455 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
 456     Write_rel* wr) const
 457 {
 458   Address address = this->address_;
 459   if (this->shndx_ != INVALID_CODE)
 460     {
 461       off_t off;
 462       Output_section* os = this->u2_.relobj->output_section(this->shndx_,
 463                                                             &off);
 464       gold_assert(os != NULL);
 465       address += os->address() + off;
 466     }
 467   else if (this->u2_.od != NULL)
 468     address += this->u2_.od->address();
 469   wr->put_r_offset(address);
 470   wr->put_r_info(elfcpp::elf_r_info<size>(this->get_symbol_index(),
 471                                           this->type_));
 472 }
 473
 474 // Write out a Rel relocation.
 475
 476 template<bool dynamic, int size, bool big_endian>
 477 void
 478 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
 479     unsigned char* pov) const
 480 {
 481   elfcpp::Rel_write<size, big_endian> orel(pov);
 482   this->write_rel(&orel);
 483 }
 484
 485 // Write out a Rela relocation.
 486
 487 template<bool dynamic, int size, bool big_endian>
 488 void
 489 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
 490     unsigned char* pov) const
 491 {
 492   elfcpp::Rela_write<size, big_endian> orel(pov);
 493   this->rel_.write_rel(&orel);
 494   orel.put_r_addend(this->addend_);
 495 }
 496
 497 // Output_data_reloc_base methods.
 498
 499 // Write out relocation data.
 500
 501 template<int sh_type, bool dynamic, int size, bool big_endian>
 502 void
 503 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
 504     Output_file* of)
 505 {
 506   const off_t off = this->offset();
 507   const off_t oview_size = this->data_size();
 508   unsigned char* const oview = of->get_output_view(off, oview_size);
 509
 510   unsigned char* pov = oview;
 511   for (typename Relocs::const_iterator p = this->relocs_.begin();
 512        p != this->relocs_.end();
 513        ++p)
 514     {
 515       p->write(pov);
 516       pov += reloc_size;
 517     }
 518
 519   gold_assert(pov - oview == oview_size);
 520
 521   of->write_output_view(off, oview_size, oview);
 522
 523   // We no longer need the relocation entries.
 524   this->relocs_.clear();
 525 }
 526
 527 // Output_data_got::Got_entry methods.
 528
 529 // Write out the entry.
 530
 531 template<int size, bool big_endian>
 532 void
 533 Output_data_got<size, big_endian>::Got_entry::write(
 534     const General_options* options,
 535     unsigned char* pov) const
 536 {
 537   Valtype val = 0;
 538
 539   switch (this->local_sym_index_)
 540     {
 541     case GSYM_CODE:
 542       {
 543         Symbol* gsym = this->u_.gsym;
 544
 545         // If the symbol is resolved locally, we need to write out its
 546         // value.  Otherwise we just write zero.  The target code is
 547         // responsible for creating a relocation entry to fill in the
 548         // value at runtime.
 549         if (gsym->final_value_is_known(options))
 550           {
 551             Sized_symbol<size>* sgsym;
 552             // This cast is a bit ugly.  We don't want to put a
 553             // virtual method in Symbol, because we want Symbol to be
 554             // as small as possible.
 555             sgsym = static_cast<Sized_symbol<size>*>(gsym);
 556             val = sgsym->value();
 557           }
 558       }
 559       break;
 560
 561     case CONSTANT_CODE:
 562       val = this->u_.constant;
 563       break;
 564
 565     default:
 566       gold_unreachable();
 567     }
 568
 569   elfcpp::Swap<size, big_endian>::writeval(pov, val);
 570 }
 571
 572 // Output_data_got methods.
 573
 574 // Add an entry for a global symbol to the GOT.  This returns true if
 575 // this is a new GOT entry, false if the symbol already had a GOT
 576 // entry.
 577
 578 template<int size, bool big_endian>
 579 bool
 580 Output_data_got<size, big_endian>::add_global(Symbol* gsym)
 581 {
 582   if (gsym->has_got_offset())
 583     return false;
 584
 585   this->entries_.push_back(Got_entry(gsym));
 586   this->set_got_size();
 587   gsym->set_got_offset(this->last_got_offset());
 588   return true;
 589 }
 590
 591 // Write out the GOT.
 592
 593 template<int size, bool big_endian>
 594 void
 595 Output_data_got<size, big_endian>::do_write(Output_file* of)
 596 {
 597   const int add = size / 8;
 598
 599   const off_t off = this->offset();
 600   const off_t oview_size = this->data_size();
 601   unsigned char* const oview = of->get_output_view(off, oview_size);
 602
 603   unsigned char* pov = oview;
 604   for (typename Got_entries::const_iterator p = this->entries_.begin();
 605        p != this->entries_.end();
 606        ++p)
 607     {
 608       p->write(this->options_, pov);
 609       pov += add;
 610     }
 611
 612   gold_assert(pov - oview == oview_size);
 613
 614   of->write_output_view(off, oview_size, oview);
 615
 616   // We no longer need the GOT entries.
 617   this->entries_.clear();
 618 }
 619
 620 // Output_data_dynamic::Dynamic_entry methods.
 621
 622 // Write out the entry.
 623
 624 template<int size, bool big_endian>
 625 void
 626 Output_data_dynamic::Dynamic_entry::write(
 627     unsigned char* pov,
 628     const Stringpool* pool) const
 629 {
 630   typename elfcpp::Elf_types<size>::Elf_WXword val;
 631   switch (this->classification_)
 632     {
 633     case DYNAMIC_NUMBER:
 634       val = this->u_.val;
 635       break;
 636
 637     case DYNAMIC_SECTION_ADDRESS:
 638       val = this->u_.os->address();
 639       break;
 640
 641     case DYNAMIC_SECTION_SIZE:
 642       val = this->u_.os->data_size();
 643       break;
 644
 645     case DYNAMIC_SYMBOL:
 646       {
 647         Sized_symbol<size>* s = static_cast<Sized_symbol<size>*>(this->u_.sym);
 648         val = s->value();
 649       }
 650       break;
 651
 652     case DYNAMIC_STRING:
 653       val = pool->get_offset(this->u_.str);
 654       break;
 655
 656     default:
 657       gold_unreachable();
 658     }
 659
 660   elfcpp::Dyn_write<size, big_endian> dw(pov);
 661   dw.put_d_tag(this->tag_);
 662   dw.put_d_val(val);
 663 }
 664
 665 // Output_data_dynamic methods.
 666
 667 // Set the final data size.
 668
 669 void
 670 Output_data_dynamic::do_set_address(uint64_t, off_t)
 671 {
 672   // Add the terminating entry.
 673   this->add_constant(elfcpp::DT_NULL, 0);
 674
 675   int dyn_size;
 676   if (this->target_->get_size() == 32)
 677     dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
 678   else if (this->target_->get_size() == 64)
 679     dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
 680   else
 681     gold_unreachable();
 682   this->set_data_size(this->entries_.size() * dyn_size);
 683 }
 684
 685 // Write out the dynamic entries.
 686
 687 void
 688 Output_data_dynamic::do_write(Output_file* of)
 689 {
 690   if (this->target_->get_size() == 32)
 691     {
 692       if (this->target_->is_big_endian())
 693         this->sized_write<32, true>(of);
 694       else
 695         this->sized_write<32, false>(of);
 696     }
 697   else if (this->target_->get_size() == 64)
 698     {
 699       if (this->target_->is_big_endian())
 700         this->sized_write<64, true>(of);
 701       else
 702         this->sized_write<64, false>(of);
 703     }
 704   else
 705     gold_unreachable();
 706 }
 707
 708 template<int size, bool big_endian>
 709 void
 710 Output_data_dynamic::sized_write(Output_file* of)
 711 {
 712   const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
 713
 714   const off_t offset = this->offset();
 715   const off_t oview_size = this->data_size();
 716   unsigned char* const oview = of->get_output_view(offset, oview_size);
 717
 718   unsigned char* pov = oview;
 719   for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
 720        p != this->entries_.end();
 721        ++p)
 722     {
 723       p->write<size, big_endian>(pov, this->pool_);
 724       pov += dyn_size;
 725     }
 726
 727   gold_assert(pov - oview == oview_size);
 728
 729   of->write_output_view(offset, oview_size, oview);
 730
 731   // We no longer need the dynamic entries.
 732   this->entries_.clear();
 733 }
 734
 735 // Output_section::Input_section methods.
 736
 737 // Return the data size.  For an input section we store the size here.
 738 // For an Output_section_data, we have to ask it for the size.
 739
 740 off_t
 741 Output_section::Input_section::data_size() const
 742 {
 743   if (this->is_input_section())
 744     return this->data_size_;
 745   else
 746     return this->u_.posd->data_size();
 747 }
 748
 749 // Set the address and file offset.
 750
 751 void
 752 Output_section::Input_section::set_address(uint64_t addr, off_t off,
 753                                            off_t secoff)
 754 {
 755   if (this->is_input_section())
 756     this->u_.object->set_section_offset(this->shndx_, off - secoff);
 757   else
 758     this->u_.posd->set_address(addr, off);
 759 }
 760
 761 // Write out the data.  We don't have to do anything for an input
 762 // section--they are handled via Object::relocate--but this is where
 763 // we write out the data for an Output_section_data.
 764
 765 void
 766 Output_section::Input_section::write(Output_file* of)
 767 {
 768   if (!this->is_input_section())
 769     this->u_.posd->write(of);
 770 }
 771
 772 // Output_section methods.
 773
 774 // Construct an Output_section.  NAME will point into a Stringpool.
 775
 776 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
 777                                elfcpp::Elf_Xword flags, bool may_add_data)
 778   : name_(name),
 779     addralign_(0),
 780     entsize_(0),
 781     link_(0),
 782     info_(0),
 783     type_(type),
 784     flags_(flags),
 785     out_shndx_(0),
 786     symtab_index_(0),
 787     dynsym_index_(0),
 788     input_sections_(),
 789     first_input_offset_(0),
 790     may_add_data_(may_add_data),
 791     needs_symtab_index_(false),
 792     needs_dynsym_index_(false)
 793 {
 794 }
 795
 796 Output_section::~Output_section()
 797 {
 798 }
 799
 800 // Add the input section SHNDX, with header SHDR, named SECNAME, in
 801 // OBJECT, to the Output_section.  Return the offset of the input
 802 // section within the output section.  We don't always keep track of
 803 // input sections for an Output_section.  Instead, each Object keeps
 804 // track of the Output_section for each of its input sections.
 805
 806 template<int size, bool big_endian>
 807 off_t
 808 Output_section::add_input_section(Relobj* object, unsigned int shndx,
 809                                   const char* secname,
 810                                   const elfcpp::Shdr<size, big_endian>& shdr)
 811 {
 812   gold_assert(this->may_add_data_);
 813
 814   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
 815   if ((addralign & (addralign - 1)) != 0)
 816     {
 817       fprintf(stderr, _("%s: %s: invalid alignment %lu for section \"%s\"\n"),
 818               program_name, object->name().c_str(),
 819               static_cast<unsigned long>(addralign), secname);
 820       gold_exit(false);
 821     }
 822
 823   if (addralign > this->addralign_)
 824     this->addralign_ = addralign;
 825
 826   off_t ssize = this->data_size();
 827   ssize = align_address(ssize, addralign);
 828   this->set_data_size(ssize + shdr.get_sh_size());
 829
 830   // We need to keep track of this section if we are already keeping
 831   // track of sections, or if we are relaxing.  FIXME: Add test for
 832   // relaxing.
 833   if (! this->input_sections_.empty())
 834     this->input_sections_.push_back(Input_section(object, shndx,
 835                                                   shdr.get_sh_size(),
 836                                                   addralign));
 837
 838   return ssize;
 839 }
 840
 841 // Add arbitrary data to an output section.
 842
 843 void
 844 Output_section::add_output_section_data(Output_section_data* posd)
 845 {
 846   gold_assert(this->may_add_data_);
 847
 848   if (this->input_sections_.empty())
 849     this->first_input_offset_ = this->data_size();
 850
 851   this->input_sections_.push_back(Input_section(posd));
 852
 853   uint64_t addralign = posd->addralign();
 854   if (addralign > this->addralign_)
 855     this->addralign_ = addralign;
 856
 857   posd->set_output_section(this);
 858 }
 859
 860 // Set the address of an Output_section.  This is where we handle
 861 // setting the addresses of any Output_section_data objects.
 862
 863 void
 864 Output_section::do_set_address(uint64_t address, off_t startoff)
 865 {
 866   if (this->input_sections_.empty())
 867     return;
 868
 869   off_t off = startoff + this->first_input_offset_;
 870   for (Input_section_list::iterator p = this->input_sections_.begin();
 871        p != this->input_sections_.end();
 872        ++p)
 873     {
 874       off = align_address(off, p->addralign());
 875       p->set_address(address + (off - startoff), off, startoff);
 876       off += p->data_size();
 877     }
 878
 879   this->set_data_size(off - startoff);
 880 }
 881
 882 // Write the section header to *OSHDR.
 883
 884 template<int size, bool big_endian>
 885 void
 886 Output_section::write_header(const Stringpool* secnamepool,
 887                              elfcpp::Shdr_write<size, big_endian>* oshdr) const
 888 {
 889   oshdr->put_sh_name(secnamepool->get_offset(this->name_));
 890   oshdr->put_sh_type(this->type_);
 891   oshdr->put_sh_flags(this->flags_);
 892   oshdr->put_sh_addr(this->address());
 893   oshdr->put_sh_offset(this->offset());
 894   oshdr->put_sh_size(this->data_size());
 895   oshdr->put_sh_link(this->link_);
 896   oshdr->put_sh_info(this->info_);
 897   oshdr->put_sh_addralign(this->addralign_);
 898   oshdr->put_sh_entsize(this->entsize_);
 899 }
 900
 901 // Write out the data.  For input sections the data is written out by
 902 // Object::relocate, but we have to handle Output_section_data objects
 903 // here.
 904
 905 void
 906 Output_section::do_write(Output_file* of)
 907 {
 908   for (Input_section_list::iterator p = this->input_sections_.begin();
 909        p != this->input_sections_.end();
 910        ++p)
 911     p->write(of);
 912 }
 913
 914 // Output segment methods.
 915
 916 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
 917   : output_data_(),
 918     output_bss_(),
 919     vaddr_(0),
 920     paddr_(0),
 921     memsz_(0),
 922     align_(0),
 923     offset_(0),
 924     filesz_(0),
 925     type_(type),
 926     flags_(flags),
 927     is_align_known_(false)
 928 {
 929 }
 930
 931 // Add an Output_section to an Output_segment.
 932
 933 void
 934 Output_segment::add_output_section(Output_section* os,
 935                                    elfcpp::Elf_Word seg_flags,
 936                                    bool front)
 937 {
 938   gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
 939   gold_assert(!this->is_align_known_);
 940
 941   // Update the segment flags.
 942   this->flags_ |= seg_flags;
 943
 944   Output_segment::Output_data_list* pdl;
 945   if (os->type() == elfcpp::SHT_NOBITS)
 946     pdl = &this->output_bss_;
 947   else
 948     pdl = &this->output_data_;
 949
 950   // So that PT_NOTE segments will work correctly, we need to ensure
 951   // that all SHT_NOTE sections are adjacent.  This will normally
 952   // happen automatically, because all the SHT_NOTE input sections
 953   // will wind up in the same output section.  However, it is possible
 954   // for multiple SHT_NOTE input sections to have different section
 955   // flags, and thus be in different output sections, but for the
 956   // different section flags to map into the same segment flags and
 957   // thus the same output segment.
 958
 959   // Note that while there may be many input sections in an output
 960   // section, there are normally only a few output sections in an
 961   // output segment.  This loop is expected to be fast.
 962
 963   if (os->type() == elfcpp::SHT_NOTE && !pdl->empty())
 964     {
 965       Output_segment::Output_data_list::iterator p = pdl->end();
 966       do
 967         {
 968           --p;
 969           if ((*p)->is_section_type(elfcpp::SHT_NOTE))
 970             {
 971               // We don't worry about the FRONT parameter.
 972               ++p;
 973               pdl->insert(p, os);
 974               return;
 975             }
 976         }
 977       while (p != pdl->begin());
 978     }
 979
 980   // Similarly, so that PT_TLS segments will work, we need to group
 981   // SHF_TLS sections.  An SHF_TLS/SHT_NOBITS section is a special
 982   // case: we group the SHF_TLS/SHT_NOBITS sections right after the
 983   // SHF_TLS/SHT_PROGBITS sections.  This lets us set up PT_TLS
 984   // correctly.
 985   if ((os->flags() & elfcpp::SHF_TLS) != 0 && !this->output_data_.empty())
 986     {
 987       pdl = &this->output_data_;
 988       bool nobits = os->type() == elfcpp::SHT_NOBITS;
 989       bool sawtls = false;
 990       Output_segment::Output_data_list::iterator p = pdl->end();
 991       do
 992         {
 993           --p;
 994           bool insert;
 995           if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
 996             {
 997               sawtls = true;
 998               // Put a NOBITS section after the first TLS section.
 999               // But a PROGBITS section after the first TLS/PROGBITS
1000               // section.
1001               insert = nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS);
1002             }
1003           else
1004             {
1005               // If we've gone past the TLS sections, but we've seen a
1006               // TLS section, then we need to insert this section now.
1007               insert = sawtls;
1008             }
1009
1010           if (insert)
1011             {
1012               // We don't worry about the FRONT parameter.
1013               ++p;
1014               pdl->insert(p, os);
1015               return;
1016             }
1017         }
1018       while (p != pdl->begin());
1019
1020       // There are no TLS sections yet; put this one at the requested
1021       // location in the section list.
1022     }
1023
1024   if (front)
1025     pdl->push_front(os);
1026   else
1027     pdl->push_back(os);
1028 }
1029
1030 // Add an Output_data (which is not an Output_section) to the start of
1031 // a segment.
1032
1033 void
1034 Output_segment::add_initial_output_data(Output_data* od)
1035 {
1036   gold_assert(!this->is_align_known_);
1037   this->output_data_.push_front(od);
1038 }
1039
1040 // Return the maximum alignment of the Output_data in Output_segment.
1041 // Once we compute this, we prohibit new sections from being added.
1042
1043 uint64_t
1044 Output_segment::addralign()
1045 {
1046   if (!this->is_align_known_)
1047     {
1048       uint64_t addralign;
1049
1050       addralign = Output_segment::maximum_alignment(&this->output_data_);
1051       if (addralign > this->align_)
1052         this->align_ = addralign;
1053
1054       addralign = Output_segment::maximum_alignment(&this->output_bss_);
1055       if (addralign > this->align_)
1056         this->align_ = addralign;
1057
1058       this->is_align_known_ = true;
1059     }
1060
1061   return this->align_;
1062 }
1063
1064 // Return the maximum alignment of a list of Output_data.
1065
1066 uint64_t
1067 Output_segment::maximum_alignment(const Output_data_list* pdl)
1068 {
1069   uint64_t ret = 0;
1070   for (Output_data_list::const_iterator p = pdl->begin();
1071        p != pdl->end();
1072        ++p)
1073     {
1074       uint64_t addralign = (*p)->addralign();
1075       if (addralign > ret)
1076         ret = addralign;
1077     }
1078   return ret;
1079 }
1080
1081 // Set the section addresses for an Output_segment.  ADDR is the
1082 // address and *POFF is the file offset.  Set the section indexes
1083 // starting with *PSHNDX.  Return the address of the immediately
1084 // following segment.  Update *POFF and *PSHNDX.
1085
1086 uint64_t
1087 Output_segment::set_section_addresses(uint64_t addr, off_t* poff,
1088                                       unsigned int* pshndx)
1089 {
1090   gold_assert(this->type_ == elfcpp::PT_LOAD);
1091
1092   this->vaddr_ = addr;
1093   this->paddr_ = addr;
1094
1095   off_t orig_off = *poff;
1096   this->offset_ = orig_off;
1097
1098   *poff = align_address(*poff, this->addralign());
1099
1100   addr = this->set_section_list_addresses(&this->output_data_, addr, poff,
1101                                           pshndx);
1102   this->filesz_ = *poff - orig_off;
1103
1104   off_t off = *poff;
1105
1106   uint64_t ret = this->set_section_list_addresses(&this->output_bss_, addr,
1107                                                   poff, pshndx);
1108   this->memsz_ = *poff - orig_off;
1109
1110   // Ignore the file offset adjustments made by the BSS Output_data
1111   // objects.
1112   *poff = off;
1113
1114   return ret;
1115 }
1116
1117 // Set the addresses in a list of Output_data structures.
1118
1119 uint64_t
1120 Output_segment::set_section_list_addresses(Output_data_list* pdl,
1121                                            uint64_t addr, off_t* poff,
1122                                            unsigned int* pshndx)
1123 {
1124   off_t startoff = *poff;
1125
1126   off_t off = startoff;
1127   for (Output_data_list::iterator p = pdl->begin();
1128        p != pdl->end();
1129        ++p)
1130     {
1131       off = align_address(off, (*p)->addralign());
1132       (*p)->set_address(addr + (off - startoff), off);
1133
1134       // Unless this is a PT_TLS segment, we want to ignore the size
1135       // of a SHF_TLS/SHT_NOBITS section.  Such a section does not
1136       // affect the size of a PT_LOAD segment.
1137       if (this->type_ == elfcpp::PT_TLS
1138           || !(*p)->is_section_flag_set(elfcpp::SHF_TLS)
1139           || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
1140         off += (*p)->data_size();
1141
1142       if ((*p)->is_section())
1143         {
1144           (*p)->set_out_shndx(*pshndx);
1145           ++*pshndx;
1146         }
1147     }
1148
1149   *poff = off;
1150   return addr + (off - startoff);
1151 }
1152
1153 // For a non-PT_LOAD segment, set the offset from the sections, if
1154 // any.
1155
1156 void
1157 Output_segment::set_offset()
1158 {
1159   gold_assert(this->type_ != elfcpp::PT_LOAD);
1160
1161   if (this->output_data_.empty() && this->output_bss_.empty())
1162     {
1163       this->vaddr_ = 0;
1164       this->paddr_ = 0;
1165       this->memsz_ = 0;
1166       this->align_ = 0;
1167       this->offset_ = 0;
1168       this->filesz_ = 0;
1169       return;
1170     }
1171
1172   const Output_data* first;
1173   if (this->output_data_.empty())
1174     first = this->output_bss_.front();
1175   else
1176     first = this->output_data_.front();
1177   this->vaddr_ = first->address();
1178   this->paddr_ = this->vaddr_;
1179   this->offset_ = first->offset();
1180
1181   if (this->output_data_.empty())
1182     this->filesz_ = 0;
1183   else
1184     {
1185       const Output_data* last_data = this->output_data_.back();
1186       this->filesz_ = (last_data->address()
1187                        + last_data->data_size()
1188                        - this->vaddr_);
1189     }
1190
1191   const Output_data* last;
1192   if (this->output_bss_.empty())
1193     last = this->output_data_.back();
1194   else
1195     last = this->output_bss_.back();
1196   this->memsz_ = (last->address()
1197                   + last->data_size()
1198                   - this->vaddr_);
1199 }
1200
1201 // Return the number of Output_sections in an Output_segment.
1202
1203 unsigned int
1204 Output_segment::output_section_count() const
1205 {
1206   return (this->output_section_count_list(&this->output_data_)
1207           + this->output_section_count_list(&this->output_bss_));
1208 }
1209
1210 // Return the number of Output_sections in an Output_data_list.
1211
1212 unsigned int
1213 Output_segment::output_section_count_list(const Output_data_list* pdl) const
1214 {
1215   unsigned int count = 0;
1216   for (Output_data_list::const_iterator p = pdl->begin();
1217        p != pdl->end();
1218        ++p)
1219     {
1220       if ((*p)->is_section())
1221         ++count;
1222     }
1223   return count;
1224 }
1225
1226 // Write the segment data into *OPHDR.
1227
1228 template<int size, bool big_endian>
1229 void
1230 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
1231 {
1232   ophdr->put_p_type(this->type_);
1233   ophdr->put_p_offset(this->offset_);
1234   ophdr->put_p_vaddr(this->vaddr_);
1235   ophdr->put_p_paddr(this->paddr_);
1236   ophdr->put_p_filesz(this->filesz_);
1237   ophdr->put_p_memsz(this->memsz_);
1238   ophdr->put_p_flags(this->flags_);
1239   ophdr->put_p_align(this->addralign());
1240 }
1241
1242 // Write the section headers into V.
1243
1244 template<int size, bool big_endian>
1245 unsigned char*
1246 Output_segment::write_section_headers(const Stringpool* secnamepool,
1247                                       unsigned char* v,
1248                                       unsigned int *pshndx
1249                                       ACCEPT_SIZE_ENDIAN) const
1250 {
1251   // Every section that is attached to a segment must be attached to a
1252   // PT_LOAD segment, so we only write out section headers for PT_LOAD
1253   // segments.
1254   if (this->type_ != elfcpp::PT_LOAD)
1255     return v;
1256
1257   v = this->write_section_headers_list
1258       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
1259           secnamepool, &this->output_data_, v, pshndx
1260           SELECT_SIZE_ENDIAN(size, big_endian));
1261   v = this->write_section_headers_list
1262       SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
1263           secnamepool, &this->output_bss_, v, pshndx
1264           SELECT_SIZE_ENDIAN(size, big_endian));
1265   return v;
1266 }
1267
1268 template<int size, bool big_endian>
1269 unsigned char*
1270 Output_segment::write_section_headers_list(const Stringpool* secnamepool,
1271                                            const Output_data_list* pdl,
1272                                            unsigned char* v,
1273                                            unsigned int* pshndx
1274                                            ACCEPT_SIZE_ENDIAN) const
1275 {
1276   const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
1277   for (Output_data_list::const_iterator p = pdl->begin();
1278        p != pdl->end();
1279        ++p)
1280     {
1281       if ((*p)->is_section())
1282         {
1283           const Output_section* ps = static_cast<const Output_section*>(*p);
1284           gold_assert(*pshndx == ps->out_shndx());
1285           elfcpp::Shdr_write<size, big_endian> oshdr(v);
1286           ps->write_header(secnamepool, &oshdr);
1287           v += shdr_size;
1288           ++*pshndx;
1289         }
1290     }
1291   return v;
1292 }
1293
1294 // Output_file methods.
1295
1296 Output_file::Output_file(const General_options& options)
1297   : options_(options),
1298     name_(options.output_file_name()),
1299     o_(-1),
1300     file_size_(0),
1301     base_(NULL)
1302 {
1303 }
1304
1305 // Open the output file.
1306
1307 void
1308 Output_file::open(off_t file_size)
1309 {
1310   this->file_size_ = file_size;
1311
1312   int mode = this->options_.is_relocatable() ? 0666 : 0777;
1313   int o = ::open(this->name_, O_RDWR | O_CREAT | O_TRUNC, mode);
1314   if (o < 0)
1315     {
1316       fprintf(stderr, _("%s: %s: open: %s\n"),
1317               program_name, this->name_, strerror(errno));
1318       gold_exit(false);
1319     }
1320   this->o_ = o;
1321
1322   // Write out one byte to make the file the right size.
1323   if (::lseek(o, file_size - 1, SEEK_SET) < 0)
1324     {
1325       fprintf(stderr, _("%s: %s: lseek: %s\n"),
1326               program_name, this->name_, strerror(errno));
1327       gold_exit(false);
1328     }
1329   char b = 0;
1330   if (::write(o, &b, 1) != 1)
1331     {
1332       fprintf(stderr, _("%s: %s: write: %s\n"),
1333               program_name, this->name_, strerror(errno));
1334       gold_exit(false);
1335     }
1336
1337   // Map the file into memory.
1338   void* base = ::mmap(NULL, file_size, PROT_READ | PROT_WRITE,
1339                       MAP_SHARED, o, 0);
1340   if (base == MAP_FAILED)
1341     {
1342       fprintf(stderr, _("%s: %s: mmap: %s\n"),
1343               program_name, this->name_, strerror(errno));
1344       gold_exit(false);
1345     }
1346   this->base_ = static_cast<unsigned char*>(base);
1347 }
1348
1349 // Close the output file.
1350
1351 void
1352 Output_file::close()
1353 {
1354   if (::munmap(this->base_, this->file_size_) < 0)
1355     {
1356       fprintf(stderr, _("%s: %s: munmap: %s\n"),
1357               program_name, this->name_, strerror(errno));
1358       gold_exit(false);
1359     }
1360   this->base_ = NULL;
1361
1362   if (::close(this->o_) < 0)
1363     {
1364       fprintf(stderr, _("%s: %s: close: %s\n"),
1365               program_name, this->name_, strerror(errno));
1366       gold_exit(false);
1367     }
1368   this->o_ = -1;
1369 }
1370
1371 // Instantiate the templates we need.  We could use the configure
1372 // script to restrict this to only the ones for implemented targets.
1373
1374 template
1375 off_t
1376 Output_section::add_input_section<32, false>(
1377     Relobj* object,
1378     unsigned int shndx,
1379     const char* secname,
1380     const elfcpp::Shdr<32, false>& shdr);
1381
1382 template
1383 off_t
1384 Output_section::add_input_section<32, true>(
1385     Relobj* object,
1386     unsigned int shndx,
1387     const char* secname,
1388     const elfcpp::Shdr<32, true>& shdr);
1389
1390 template
1391 off_t
1392 Output_section::add_input_section<64, false>(
1393     Relobj* object,
1394     unsigned int shndx,
1395     const char* secname,
1396     const elfcpp::Shdr<64, false>& shdr);
1397
1398 template
1399 off_t
1400 Output_section::add_input_section<64, true>(
1401     Relobj* object,
1402     unsigned int shndx,
1403     const char* secname,
1404     const elfcpp::Shdr<64, true>& shdr);
1405
1406 template
1407 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
1408
1409 template
1410 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
1411
1412 template
1413 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
1414
1415 template
1416 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
1417
1418 template
1419 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
1420
1421 template
1422 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
1423
1424 template
1425 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
1426
1427 template
1428 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
1429
1430 template
1431 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
1432
1433 template
1434 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
1435
1436 template
1437 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
1438
1439 template
1440 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
1441
1442 template
1443 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
1444
1445 template
1446 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
1447
1448 template
1449 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
1450
1451 template
1452 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
1453
1454 template
1455 class Output_data_got<32, false>;
1456
1457 template
1458 class Output_data_got<32, true>;
1459
1460 template
1461 class Output_data_got<64, false>;
1462
1463 template
1464 class Output_data_got<64, true>;
1465
1466 } // End namespace gold.