X-Git-Url: https://repo.jachan.dev/binutils.git/blobdiff_plain/16164a6b00372ebc0360f6aa71337e5613278817..4b95cf5c0c75d6efc1b2f96af72317aecca079f1:/gold/output.cc diff --git a/gold/output.cc b/gold/output.cc index 2539aac8a6..29cca5dc35 100644 --- a/gold/output.cc +++ b/gold/output.cc @@ -1,6 +1,6 @@ // output.cc -- manage the output file for gold -// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +// Copyright (C) 2006-2014 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -434,7 +434,7 @@ Output_segment_headers::do_size() const // Output_file_header methods. -Output_file_header::Output_file_header(const Target* target, +Output_file_header::Output_file_header(Target* target, const Symbol_table* symtab, const Output_segment_headers* osh) : target_(target), @@ -576,7 +576,7 @@ Output_file_header::do_sized_write(Output_file* of) // Let the target adjust the ELF header, e.g., to set EI_OSABI in // the e_ident field. - parameters->target().adjust_elf_header(view, ehdr_size); + this->target_->adjust_elf_header(view, ehdr_size); of->write_output_view(0, ehdr_size, view); } @@ -589,7 +589,7 @@ Output_file_header::entry() { const bool should_issue_warning = (parameters->options().entry() != NULL && !parameters->options().relocatable() - && !parameters->options().shared()); + && !parameters->options().shared()); const char* entry = parameters->entry(); Symbol* sym = this->symtab_->lookup(entry); @@ -768,7 +768,7 @@ Output_reloc::Output_reloc( shndx_(INVALID_CODE) { gold_assert(local_sym_index != GSYM_CODE - && local_sym_index != INVALID_CODE); + && local_sym_index != INVALID_CODE); // this->type_ is a bitfield; make sure TYPE fits. gold_assert(this->type_ == type); this->u1_.relobj = relobj; @@ -794,7 +794,7 @@ Output_reloc::Output_reloc( shndx_(shndx) { gold_assert(local_sym_index != GSYM_CODE - && local_sym_index != INVALID_CODE); + && local_sym_index != INVALID_CODE); gold_assert(shndx != INVALID_CODE); // this->type_ is a bitfield; make sure TYPE fits. gold_assert(this->type_ == type); @@ -811,9 +811,10 @@ Output_reloc::Output_reloc( Output_section* os, unsigned int type, Output_data* od, - Address address) + Address address, + bool is_relative) : address_(address), local_sym_index_(SECTION_CODE), type_(type), - is_relative_(false), is_symbolless_(false), + is_relative_(is_relative), is_symbolless_(is_relative), is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE) { // this->type_ is a bitfield; make sure TYPE fits. @@ -832,9 +833,10 @@ Output_reloc::Output_reloc( unsigned int type, Sized_relobj* relobj, unsigned int shndx, - Address address) + Address address, + bool is_relative) : address_(address), local_sym_index_(SECTION_CODE), type_(type), - is_relative_(false), is_symbolless_(false), + is_relative_(is_relative), is_symbolless_(is_relative), is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx) { gold_assert(shndx != INVALID_CODE); @@ -848,15 +850,16 @@ Output_reloc::Output_reloc( os->set_needs_symtab_index(); } -// An absolute relocation. +// An absolute or relative relocation. template Output_reloc::Output_reloc( unsigned int type, Output_data* od, - Address address) + Address address, + bool is_relative) : address_(address), local_sym_index_(0), type_(type), - is_relative_(false), is_symbolless_(false), + is_relative_(is_relative), is_symbolless_(false), is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE) { // this->type_ is a bitfield; make sure TYPE fits. @@ -870,9 +873,10 @@ Output_reloc::Output_reloc( unsigned int type, Sized_relobj* relobj, unsigned int shndx, - Address address) + Address address, + bool is_relative) : address_(address), local_sym_index_(0), type_(type), - is_relative_(false), is_symbolless_(false), + is_relative_(is_relative), is_symbolless_(false), is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx) { gold_assert(shndx != INVALID_CODE); @@ -949,14 +953,14 @@ set_needs_dynsym_index() default: { - const unsigned int lsi = this->local_sym_index_; + const unsigned int lsi = this->local_sym_index_; Sized_relobj_file* relobj = this->u1_.relobj->sized_relobj(); gold_assert(relobj != NULL); - if (!this->is_section_symbol_) - relobj->set_needs_output_dynsym_entry(lsi); - else - relobj->output_section(lsi)->set_needs_dynsym_index(); + if (!this->is_section_symbol_) + relobj->set_needs_output_dynsym_entry(lsi); + else + relobj->output_section(lsi)->set_needs_dynsym_index(); } break; } @@ -1005,26 +1009,26 @@ Output_reloc::get_symbol_index() default: { - const unsigned int lsi = this->local_sym_index_; + const unsigned int lsi = this->local_sym_index_; Sized_relobj_file* relobj = this->u1_.relobj->sized_relobj(); gold_assert(relobj != NULL); - if (!this->is_section_symbol_) - { - if (dynamic) - index = relobj->dynsym_index(lsi); - else - index = relobj->symtab_index(lsi); - } - else - { - Output_section* os = relobj->output_section(lsi); - gold_assert(os != NULL); - if (dynamic) - index = os->dynsym_index(); - else - index = os->symtab_index(); - } + if (!this->is_section_symbol_) + { + if (dynamic) + index = relobj->dynsym_index(lsi); + else + index = relobj->symtab_index(lsi); + } + else + { + Output_section* os = relobj->output_section(lsi); + gold_assert(os != NULL); + if (dynamic) + index = os->dynsym_index(); + else + index = os->symtab_index(); + } } break; } @@ -1041,11 +1045,11 @@ Output_reloc:: local_section_offset(Addend addend) const { gold_assert(this->local_sym_index_ != GSYM_CODE - && this->local_sym_index_ != SECTION_CODE + && this->local_sym_index_ != SECTION_CODE && this->local_sym_index_ != TARGET_CODE - && this->local_sym_index_ != INVALID_CODE + && this->local_sym_index_ != INVALID_CODE && this->local_sym_index_ != 0 - && this->is_section_symbol_); + && this->is_section_symbol_); const unsigned int lsi = this->local_sym_index_; Output_section* os = this->u1_.relobj->output_section(lsi); gold_assert(os != NULL); @@ -1126,29 +1130,25 @@ Output_reloc::symbol_value( const Sized_symbol* sym; sym = static_cast*>(this->u1_.gsym); if (this->use_plt_offset_ && sym->has_plt_offset()) - { - uint64_t plt_address = - parameters->target().plt_address_for_global(sym); - return plt_address + sym->plt_offset(); - } + return parameters->target().plt_address_for_global(sym); else return sym->value() + addend; } - gold_assert(this->local_sym_index_ != SECTION_CODE - && this->local_sym_index_ != TARGET_CODE - && this->local_sym_index_ != INVALID_CODE + if (this->local_sym_index_ == SECTION_CODE) + { + gold_assert(!this->use_plt_offset_); + return this->u1_.os->address() + addend; + } + gold_assert(this->local_sym_index_ != TARGET_CODE + && this->local_sym_index_ != INVALID_CODE && this->local_sym_index_ != 0 - && !this->is_section_symbol_); + && !this->is_section_symbol_); const unsigned int lsi = this->local_sym_index_; Sized_relobj_file* relobj = this->u1_.relobj->sized_relobj(); gold_assert(relobj != NULL); if (this->use_plt_offset_) - { - uint64_t plt_address = - parameters->target().plt_address_for_local(relobj, lsi); - return plt_address + relobj->local_plt_offset(lsi); - } + return parameters->target().plt_address_for_local(relobj, lsi); const Symbol_value* symval = relobj->local_symbol(lsi); return symval->value(relobj, addend); } @@ -1361,9 +1361,11 @@ Output_data_group::do_write(Output_file* of) // Write out the entry. -template +template void -Output_data_got::Got_entry::write(unsigned char* pov) const +Output_data_got::Got_entry::write( + unsigned int got_indx, + unsigned char* pov) const { Valtype val = 0; @@ -1375,17 +1377,42 @@ Output_data_got::Got_entry::write(unsigned char* pov) const // link-time value, which will be relocated dynamically by a // RELATIVE relocation. Symbol* gsym = this->u_.gsym; - if (this->use_plt_offset_ && gsym->has_plt_offset()) - val = (parameters->target().plt_address_for_global(gsym) - + gsym->plt_offset()); + if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset()) + val = parameters->target().plt_address_for_global(gsym); else { - Sized_symbol* sgsym; - // This cast is a bit ugly. We don't want to put a - // virtual method in Symbol, because we want Symbol to be - // as small as possible. - sgsym = static_cast*>(gsym); - val = sgsym->value(); + switch (parameters->size_and_endianness()) + { +#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) + case Parameters::TARGET_32_LITTLE: + case Parameters::TARGET_32_BIG: + { + // This cast is ugly. We don't want to put a + // virtual method in Symbol, because we want Symbol + // to be as small as possible. + Sized_symbol<32>::Value_type v; + v = static_cast*>(gsym)->value(); + val = convert_types::Value_type>(v); + } + break; +#endif +#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) + case Parameters::TARGET_64_LITTLE: + case Parameters::TARGET_64_BIG: + { + Sized_symbol<64>::Value_type v; + v = static_cast*>(gsym)->value(); + val = convert_types::Value_type>(v); + } + break; +#endif + default: + gold_unreachable(); + } + if (this->use_plt_or_tls_offset_ + && gsym->type() == elfcpp::STT_TLS) + val += parameters->target().tls_offset_for_global(gsym, + got_indx); } } break; @@ -1397,30 +1424,30 @@ Output_data_got::Got_entry::write(unsigned char* pov) const case RESERVED_CODE: // If we're doing an incremental update, don't touch this GOT entry. if (parameters->incremental_update()) - return; + return; val = this->u_.constant; break; default: { const Relobj* object = this->u_.object; - const unsigned int lsi = this->local_sym_index_; - if (!this->use_plt_offset_) + const unsigned int lsi = this->local_sym_index_; + bool is_tls = object->local_is_tls(lsi); + if (this->use_plt_or_tls_offset_ && !is_tls) + val = parameters->target().plt_address_for_local(object, lsi); + else { uint64_t lval = object->local_symbol_value(lsi, 0); val = convert_types(lval); - } - else - { - uint64_t plt_address = - parameters->target().plt_address_for_local(object, lsi); - val = plt_address + object->local_plt_offset(lsi); + if (this->use_plt_or_tls_offset_ && is_tls) + val += parameters->target().tls_offset_for_local(object, lsi, + got_indx); } } break; } - elfcpp::Swap::writeval(pov, val); + elfcpp::Swap::writeval(pov, val); } // Output_data_got methods. @@ -1429,9 +1456,9 @@ Output_data_got::Got_entry::write(unsigned char* pov) const // this is a new GOT entry, false if the symbol already had a GOT // entry. -template +template bool -Output_data_got::add_global( +Output_data_got::add_global( Symbol* gsym, unsigned int got_type) { @@ -1445,10 +1472,10 @@ Output_data_got::add_global( // Like add_global, but use the PLT offset. -template +template bool -Output_data_got::add_global_plt(Symbol* gsym, - unsigned int got_type) +Output_data_got::add_global_plt(Symbol* gsym, + unsigned int got_type) { if (gsym->has_got_offset(got_type)) return false; @@ -1461,9 +1488,9 @@ Output_data_got::add_global_plt(Symbol* gsym, // Add an entry for a global symbol to the GOT, and add a dynamic // relocation of type R_TYPE for the GOT entry. -template +template void -Output_data_got::add_global_with_rel( +Output_data_got::add_global_with_rel( Symbol* gsym, unsigned int got_type, Output_data_reloc_generic* rel_dyn, @@ -1480,9 +1507,9 @@ Output_data_got::add_global_with_rel( // Add a pair of entries for a global symbol to the GOT, and add // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively. // If R_TYPE_2 == 0, add the second entry with no relocation. -template +template void -Output_data_got::add_global_pair_with_rel( +Output_data_got::add_global_pair_with_rel( Symbol* gsym, unsigned int got_type, Output_data_reloc_generic* rel_dyn, @@ -1498,16 +1525,16 @@ Output_data_got::add_global_pair_with_rel( if (r_type_2 != 0) rel_dyn->add_global_generic(gsym, r_type_2, this, - got_offset + size / 8, 0); + got_offset + got_size / 8, 0); } // Add an entry for a local symbol to the GOT. This returns true if // this is a new GOT entry, false if the symbol already has a GOT // entry. -template +template bool -Output_data_got::add_local( +Output_data_got::add_local( Relobj* object, unsigned int symndx, unsigned int got_type) @@ -1523,9 +1550,9 @@ Output_data_got::add_local( // Like add_local, but use the PLT offset. -template +template bool -Output_data_got::add_local_plt( +Output_data_got::add_local_plt( Relobj* object, unsigned int symndx, unsigned int got_type) @@ -1542,9 +1569,9 @@ Output_data_got::add_local_plt( // Add an entry for a local symbol to the GOT, and add a dynamic // relocation of type R_TYPE for the GOT entry. -template +template void -Output_data_got::add_local_with_rel( +Output_data_got::add_local_with_rel( Relobj* object, unsigned int symndx, unsigned int got_type, @@ -1560,18 +1587,19 @@ Output_data_got::add_local_with_rel( } // Add a pair of entries for a local symbol to the GOT, and add -// dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively. -// If R_TYPE_2 == 0, add the second entry with no relocation. -template +// a dynamic relocation of type R_TYPE using the section symbol of +// the output section to which input section SHNDX maps, on the first. +// The first got entry will have a value of zero, the second the +// value of the local symbol. +template void -Output_data_got::add_local_pair_with_rel( +Output_data_got::add_local_pair_with_rel( Relobj* object, unsigned int symndx, unsigned int shndx, unsigned int got_type, Output_data_reloc_generic* rel_dyn, - unsigned int r_type_1, - unsigned int r_type_2) + unsigned int r_type) { if (object->local_has_got_offset(symndx, got_type)) return; @@ -1581,18 +1609,37 @@ Output_data_got::add_local_pair_with_rel( Got_entry(object, symndx, false)); object->set_local_got_offset(symndx, got_type, got_offset); Output_section* os = object->output_section(shndx); - rel_dyn->add_output_section_generic(os, r_type_1, this, got_offset, 0); + rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0); +} - if (r_type_2 != 0) - rel_dyn->add_output_section_generic(os, r_type_2, this, - got_offset + size / 8, 0); +// Add a pair of entries for a local symbol to the GOT, and add +// a dynamic relocation of type R_TYPE using STN_UNDEF on the first. +// The first got entry will have a value of zero, the second the +// value of the local symbol offset by Target::tls_offset_for_local. +template +void +Output_data_got::add_local_tls_pair( + Relobj* object, + unsigned int symndx, + unsigned int got_type, + Output_data_reloc_generic* rel_dyn, + unsigned int r_type) +{ + if (object->local_has_got_offset(symndx, got_type)) + return; + + unsigned int got_offset + = this->add_got_entry_pair(Got_entry(), + Got_entry(object, symndx, true)); + object->set_local_got_offset(symndx, got_type, got_offset); + rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0); } // Reserve a slot in the GOT for a local symbol or the second slot of a pair. -template +template void -Output_data_got::reserve_local( +Output_data_got::reserve_local( unsigned int i, Relobj* object, unsigned int sym_index, @@ -1604,9 +1651,9 @@ Output_data_got::reserve_local( // Reserve a slot in the GOT for a global symbol. -template +template void -Output_data_got::reserve_global( +Output_data_got::reserve_global( unsigned int i, Symbol* gsym, unsigned int got_type) @@ -1617,22 +1664,20 @@ Output_data_got::reserve_global( // Write out the GOT. -template +template void -Output_data_got::do_write(Output_file* of) +Output_data_got::do_write(Output_file* of) { - const int add = size / 8; + const int add = got_size / 8; const off_t off = this->offset(); const off_t oview_size = this->data_size(); unsigned char* const oview = of->get_output_view(off, oview_size); unsigned char* pov = oview; - for (typename Got_entries::const_iterator p = this->entries_.begin(); - p != this->entries_.end(); - ++p) + for (unsigned int i = 0; i < this->entries_.size(); ++i) { - p->write(pov); + this->entries_[i].write(i, pov); pov += add; } @@ -1646,9 +1691,9 @@ Output_data_got::do_write(Output_file* of) // Create a new GOT entry and return its offset. -template +template unsigned int -Output_data_got::add_got_entry(Got_entry got_entry) +Output_data_got::add_got_entry(Got_entry got_entry) { if (!this->is_data_size_valid()) { @@ -1659,11 +1704,12 @@ Output_data_got::add_got_entry(Got_entry got_entry) else { // For an incremental update, find an available slot. - off_t got_offset = this->free_list_.allocate(size / 8, size / 8, 0); + off_t got_offset = this->free_list_.allocate(got_size / 8, + got_size / 8, 0); if (got_offset == -1) gold_fallback(_("out of patch space (GOT);" " relink with --incremental-full")); - unsigned int got_index = got_offset / (size / 8); + unsigned int got_index = got_offset / (got_size / 8); gold_assert(got_index < this->entries_.size()); this->entries_[got_index] = got_entry; return static_cast(got_offset); @@ -1672,10 +1718,11 @@ Output_data_got::add_got_entry(Got_entry got_entry) // Create a pair of new GOT entries and return the offset of the first. -template +template unsigned int -Output_data_got::add_got_entry_pair(Got_entry got_entry_1, - Got_entry got_entry_2) +Output_data_got::add_got_entry_pair( + Got_entry got_entry_1, + Got_entry got_entry_2) { if (!this->is_data_size_valid()) { @@ -1689,11 +1736,12 @@ Output_data_got::add_got_entry_pair(Got_entry got_entry_1, else { // For an incremental update, find an available pair of slots. - off_t got_offset = this->free_list_.allocate(2 * size / 8, size / 8, 0); + off_t got_offset = this->free_list_.allocate(2 * got_size / 8, + got_size / 8, 0); if (got_offset == -1) gold_fallback(_("out of patch space (GOT);" " relink with --incremental-full")); - unsigned int got_index = got_offset / (size / 8); + unsigned int got_index = got_offset / (got_size / 8); gold_assert(got_index < this->entries_.size()); this->entries_[got_index] = got_entry_1; this->entries_[got_index + 1] = got_entry_2; @@ -1703,9 +1751,9 @@ Output_data_got::add_got_entry_pair(Got_entry got_entry_1, // Replace GOT entry I with a new value. -template +template void -Output_data_got::replace_got_entry( +Output_data_got::replace_got_entry( unsigned int i, Got_entry got_entry) { @@ -1888,7 +1936,7 @@ Output_symtab_xindex::endian_do_write(unsigned char* const oview) ++p) { unsigned int symndx = p->first; - gold_assert(symndx * 4 < this->data_size()); + gold_assert(static_cast(symndx) * 4 < this->data_size()); elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second); } } @@ -2197,9 +2245,9 @@ Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const case RELAXED_INPUT_SECTION_CODE: { - Output_relaxed_input_section* relaxed_section = + Output_relaxed_input_section* relaxed_section = this->relaxed_input_section(); - mapfile->print_input_section(relaxed_section->relobj(), + mapfile->print_input_section(relaxed_section->relobj(), relaxed_section->shndx()); } break; @@ -2373,27 +2421,25 @@ Output_section::add_input_section(Layout* layout, input_section_size = uncompressed_size; off_t offset_in_section; - off_t aligned_offset_in_section; + if (this->has_fixed_layout()) { // For incremental updates, find a chunk of unused space in the section. offset_in_section = this->free_list_.allocate(input_section_size, addralign, 0); if (offset_in_section == -1) - gold_fallback(_("out of patch space in section %s; " + gold_fallback(_("out of patch space in section %s; " "relink with --incremental-full"), this->name()); - aligned_offset_in_section = offset_in_section; - } - else - { - offset_in_section = this->current_data_size_for_child(); - aligned_offset_in_section = align_address(offset_in_section, - addralign); - this->set_current_data_size_for_child(aligned_offset_in_section - + input_section_size); + return offset_in_section; } + offset_in_section = this->current_data_size_for_child(); + off_t aligned_offset_in_section = align_address(offset_in_section, + addralign); + this->set_current_data_size_for_child(aligned_offset_in_section + + input_section_size); + // Determine if we want to delay code-fill generation until the output // section is written. When the target is relaxing, we want to delay fill // generating to avoid adjusting them during relaxation. Also, if we are @@ -2403,7 +2449,7 @@ Output_section::add_input_section(Layout* layout, && (sh_flags & elfcpp::SHF_EXECINSTR) != 0 && parameters->target().has_code_fill() && (parameters->target().may_relax() - || layout->is_section_ordering_specified())) + || layout->is_section_ordering_specified())) { gold_assert(this->fills_.empty()); this->generate_code_fills_at_write_ = true; @@ -2420,13 +2466,13 @@ Output_section::add_input_section(Layout* layout, // sections without input sections. off_t fill_len = aligned_offset_in_section - offset_in_section; if (this->input_sections_.empty()) - this->fills_.push_back(Fill(offset_in_section, fill_len)); + this->fills_.push_back(Fill(offset_in_section, fill_len)); else - { - std::string fill_data(parameters->target().code_fill(fill_len)); - Output_data_const* odc = new Output_data_const(fill_data, 1); - this->input_sections_.push_back(Input_section(odc)); - } + { + std::string fill_data(parameters->target().code_fill(fill_len)); + Output_data_const* odc = new Output_data_const(fill_data, 1); + this->input_sections_.push_back(Input_section(odc)); + } } // We need to keep track of this section if we are already keeping @@ -2449,22 +2495,14 @@ Output_section::add_input_section(Layout* layout, using --section-ordering-file, match the section name with a pattern. */ if (parameters->options().section_ordering_file()) - { - unsigned int section_order_index = - layout->find_section_order_index(std::string(secname)); - if (section_order_index != 0) - { - isecn.set_section_order_index(section_order_index); - this->set_input_section_order_specified(); - } - } - if (this->has_fixed_layout()) { - // For incremental updates, finalize the address and offset now. - uint64_t addr = this->address(); - isecn.set_address_and_file_offset(addr + aligned_offset_in_section, - aligned_offset_in_section, - this->offset()); + unsigned int section_order_index = + layout->find_section_order_index(std::string(secname)); + if (section_order_index != 0) + { + isecn.set_section_order_index(section_order_index); + this->set_input_section_order_specified(); + } } this->input_sections_.push_back(isecn); } @@ -2534,12 +2572,12 @@ Output_section::add_relaxed_input_section(Layout* layout, if (layout->is_section_ordering_specified()) { unsigned int section_order_index = - layout->find_section_order_index(name); + layout->find_section_order_index(name); if (section_order_index != 0) - { - inp.set_section_order_index(section_order_index); - this->set_input_section_order_specified(); - } + { + inp.set_section_order_index(section_order_index); + this->set_input_section_order_specified(); + } } this->add_output_section_data(&inp); @@ -2549,9 +2587,9 @@ Output_section::add_relaxed_input_section(Layout* layout, // For a relaxed section, we use the current data size. Linker scripts // get all the input sections, including relaxed one from an output - // section and add them back to them same output section to compute the + // section and add them back to the same output section to compute the // output section size. If we do not account for sizes of relaxed input - // sections, an output section would be incorrectly sized. + // sections, an output section would be incorrectly sized. off_t offset_in_section = this->current_data_size_for_child(); off_t aligned_offset_in_section = align_address(offset_in_section, poris->addralign()); @@ -2596,11 +2634,6 @@ Output_section::add_merge_input_section(Relobj* object, unsigned int shndx, { bool is_string = (flags & elfcpp::SHF_STRINGS) != 0; - // We only merge strings if the alignment is not more than the - // character size. This could be handled, but it's unusual. - if (is_string && addralign > entsize) - return false; - // We cannot restore merged input section states. gold_assert(this->checkpoint_ == NULL); @@ -2718,7 +2751,7 @@ Output_section::convert_input_sections_in_list_to_relaxed_sections( (*input_sections)[p->second].set_section_order_index(soi); } } - + // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS // is a vector of pointers to Output_relaxed_input_section or its derived // classes. The relaxed sections must correspond to existing input sections. @@ -2733,7 +2766,7 @@ Output_section::convert_input_sections_to_relaxed_sections( // this. If there is no checkpoint active, just search the current // input section list and replace the sections there. If there is // a checkpoint, also replace the sections there. - + // By default, we look at the whole list. size_t limit = this->input_sections_.size(); @@ -2846,13 +2879,13 @@ Output_section::build_lookup_maps() const for (Output_merge_base::Input_sections::const_iterator is = pomb->input_sections_begin(); is != pomb->input_sections_end(); - ++is) + ++is) { const Const_section_id& csid = *is; this->lookup_maps_->add_merge_input_section(csid.first, csid.second, pomb); } - + } else if (p->is_relaxed_input_section()) { @@ -2894,7 +2927,7 @@ Output_section::is_input_address_mapped(const Relobj* object, { section_offset_type output_offset; bool found = posd->output_offset(object, shndx, offset, &output_offset); - gold_assert(found); + gold_assert(found); return output_offset != -1; } @@ -2929,13 +2962,13 @@ Output_section::output_offset(const Relobj* object, unsigned int shndx, // Look at the Output_section_data_maps first. const Output_section_data* posd = this->find_merge_section(object, shndx); - if (posd == NULL) + if (posd == NULL) posd = this->find_relaxed_input_section(object, shndx); if (posd != NULL) { section_offset_type output_offset; bool found = posd->output_offset(object, shndx, offset, &output_offset); - gold_assert(found); + gold_assert(found); return output_offset; } @@ -2962,7 +2995,7 @@ Output_section::output_address(const Relobj* object, unsigned int shndx, // Look at the Output_section_data_maps first. const Output_section_data* posd = this->find_merge_section(object, shndx); - if (posd == NULL) + if (posd == NULL) posd = this->find_relaxed_input_section(object, shndx); if (posd != NULL && posd->is_address_valid()) { @@ -3093,7 +3126,7 @@ Output_section::set_final_data_size() double pct = parameters->options().incremental_patch(); size_t extra = static_cast(data_size * pct); if (this->free_space_fill_ != NULL - && this->free_space_fill_->minimum_hole_size() > extra) + && this->free_space_fill_->minimum_hole_size() > extra) extra = this->free_space_fill_->minimum_hole_size(); off_t new_size = align_address(data_size + extra, this->addralign()); this->patch_space_ = new_size - data_size; @@ -3181,7 +3214,7 @@ class Output_section::Input_section_sort_entry || input_section.is_relaxed_input_section()) { if (this->section_has_name_ - && must_sort_attached_input_sections) + && must_sort_attached_input_sections) { // This is only called single-threaded from Layout::finalize, // so it is OK to lock. Unfortunately we have no way to pass @@ -3274,7 +3307,11 @@ class Output_section::Input_section_sort_entry // in order to better support gcc, and we need to be compatible. bool match_file_name(const char* file_name) const - { return Layout::match_file_name(this->input_section_.relobj(), file_name); } + { + if (this->input_section_.is_output_section_data()) + return false; + return Layout::match_file_name(this->input_section_.relobj(), file_name); + } // Returns 1 if THIS should appear before S in section order, -1 if S // appears before THIS and 0 if they are not comparable. @@ -3285,10 +3322,10 @@ class Output_section::Input_section_sort_entry unsigned int s_secn_index = s.input_section().section_order_index(); if (this_secn_index > 0 && s_secn_index > 0) { - if (this_secn_index < s_secn_index) - return 1; - else if (this_secn_index > s_secn_index) - return -1; + if (this_secn_index < s_secn_index) + return 1; + else if (this_secn_index > s_secn_index) + return -1; } return 0; } @@ -3448,10 +3485,75 @@ Output_section::Input_section_sort_section_order_index_compare::operator()( // Keep input order if section ordering cannot determine order. if (s1_secn_index == s2_secn_index) return s1.index() < s2.index(); - + return s1_secn_index < s2_secn_index; } +// Return true if S1 should come before S2. This is the sort comparison +// function for .text to sort sections with prefixes +// .text.{unlikely,exit,startup,hot} before other sections. + +bool +Output_section::Input_section_sort_section_prefix_special_ordering_compare + ::operator()( + const Output_section::Input_section_sort_entry& s1, + const Output_section::Input_section_sort_entry& s2) const +{ + // We sort all the sections with no names to the end. + if (!s1.section_has_name() || !s2.section_has_name()) + { + if (s1.section_has_name()) + return true; + if (s2.section_has_name()) + return false; + return s1.index() < s2.index(); + } + + // Some input section names have special ordering requirements. + int o1 = Layout::special_ordering_of_input_section(s1.section_name().c_str()); + int o2 = Layout::special_ordering_of_input_section(s2.section_name().c_str()); + if (o1 != o2) + { + if (o1 < 0) + return false; + else if (o2 < 0) + return true; + else + return o1 < o2; + } + + // Keep input order otherwise. + return s1.index() < s2.index(); +} + +// Return true if S1 should come before S2. This is the sort comparison +// function for sections to sort them by name. + +bool +Output_section::Input_section_sort_section_name_compare + ::operator()( + const Output_section::Input_section_sort_entry& s1, + const Output_section::Input_section_sort_entry& s2) const +{ + // We sort all the sections with no names to the end. + if (!s1.section_has_name() || !s2.section_has_name()) + { + if (s1.section_has_name()) + return true; + if (s2.section_has_name()) + return false; + return s1.index() < s2.index(); + } + + // We sort by name. + int compare = s1.section_name().compare(s2.section_name()); + if (compare != 0) + return compare < 0; + + // Keep input order otherwise. + return s1.index() < s2.index(); +} + // This updates the section order index of input sections according to the // the order specified in the mapping from Section id to order index. @@ -3465,10 +3567,10 @@ Output_section::update_section_layout( { if (p->is_input_section() || p->is_relaxed_input_section()) - { + { Object* obj = (p->is_input_section() ? p->relobj() - : p->relaxed_input_section()->relobj()); + : p->relaxed_input_section()->relobj()); unsigned int shndx = p->shndx(); Section_layout_order::const_iterator it = order_map->find(Section_id(obj, shndx)); @@ -3476,11 +3578,11 @@ Output_section::update_section_layout( continue; unsigned int section_order_index = it->second; if (section_order_index != 0) - { - p->set_section_order_index(section_order_index); - this->set_input_section_order_specified(); + { + p->set_section_order_index(section_order_index); + this->set_input_section_order_specified(); } - } + } } } @@ -3510,25 +3612,31 @@ Output_section::sort_attached_input_sections() p != this->input_sections_.end(); ++p, ++i) sort_list.push_back(Input_section_sort_entry(*p, i, - this->must_sort_attached_input_sections())); + this->must_sort_attached_input_sections())); // Sort the input sections. if (this->must_sort_attached_input_sections()) { if (this->type() == elfcpp::SHT_PREINIT_ARRAY - || this->type() == elfcpp::SHT_INIT_ARRAY - || this->type() == elfcpp::SHT_FINI_ARRAY) - std::sort(sort_list.begin(), sort_list.end(), - Input_section_sort_init_fini_compare()); + || this->type() == elfcpp::SHT_INIT_ARRAY + || this->type() == elfcpp::SHT_FINI_ARRAY) + std::sort(sort_list.begin(), sort_list.end(), + Input_section_sort_init_fini_compare()); + else if (strcmp(parameters->options().sort_section(), "name") == 0) + std::sort(sort_list.begin(), sort_list.end(), + Input_section_sort_section_name_compare()); + else if (strcmp(this->name(), ".text") == 0) + std::sort(sort_list.begin(), sort_list.end(), + Input_section_sort_section_prefix_special_ordering_compare()); else - std::sort(sort_list.begin(), sort_list.end(), - Input_section_sort_compare()); + std::sort(sort_list.begin(), sort_list.end(), + Input_section_sort_compare()); } else { gold_assert(this->input_section_order_specified()); std::sort(sort_list.begin(), sort_list.end(), - Input_section_sort_section_order_index_compare()); + Input_section_sort_section_order_index_compare()); } // Copy the sorted input sections back to our list. @@ -3811,7 +3919,7 @@ Output_section::add_script_input_section(const Input_section& sis) this->input_sections_.push_back(sis); - // Update fast lookup maps if necessary. + // Update fast lookup maps if necessary. if (this->lookup_maps_->is_valid()) { if (sis.is_merge_section()) @@ -4126,7 +4234,7 @@ Output_segment::maximum_alignment() if (!this->is_max_align_known_) { for (int i = 0; i < static_cast(ORDER_MAX); ++i) - { + { const Output_data_list* pdl = &this->output_lists_[i]; uint64_t addralign = Output_segment::maximum_alignment_list(pdl); if (addralign > this->max_align_) @@ -4190,8 +4298,9 @@ Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const // and *PSHNDX. uint64_t -Output_segment::set_section_addresses(Layout* layout, bool reset, - uint64_t addr, +Output_segment::set_section_addresses(const Target* target, + Layout* layout, bool reset, + uint64_t addr, unsigned int* increase_relro, bool* has_relro, off_t* poff, @@ -4205,7 +4314,7 @@ Output_segment::set_section_addresses(Layout* layout, bool reset, bool in_tls = false; // If we have relro sections, we need to pad forward now so that the - // relro sections plus INCREASE_RELRO end on a common page boundary. + // relro sections plus INCREASE_RELRO end on an abi page boundary. if (parameters->options().relro() && this->is_first_section_relro() && (!this->are_addresses_set_ || reset)) @@ -4260,7 +4369,7 @@ Output_segment::set_section_addresses(Layout* layout, bool reset, last_relro_pad = aligned_size - relro_size; *has_relro = true; - uint64_t page_align = parameters->target().common_pagesize(); + uint64_t page_align = parameters->target().abi_pagesize(); // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0. uint64_t desired_align = page_align - (aligned_size % page_align); @@ -4330,6 +4439,41 @@ Output_segment::set_section_addresses(Layout* layout, bool reset, // objects. *poff = off; + // If code segments must contain only code, and this code segment is + // page-aligned in the file, then fill it out to a whole page with + // code fill (the tail of the segment will not be within any section). + // Thus the entire code segment can be mapped from the file as whole + // pages and that mapping will contain only valid instructions. + if (target->isolate_execinstr() && (this->flags() & elfcpp::PF_X) != 0) + { + uint64_t abi_pagesize = target->abi_pagesize(); + if (orig_off % abi_pagesize == 0 && off % abi_pagesize != 0) + { + size_t fill_size = abi_pagesize - (off % abi_pagesize); + + std::string fill_data; + if (target->has_code_fill()) + fill_data = target->code_fill(fill_size); + else + fill_data.resize(fill_size); // Zero fill. + + Output_data_const* fill = new Output_data_const(fill_data, 0); + fill->set_address(this->vaddr_ + this->memsz_); + fill->set_file_offset(off); + layout->add_relax_output(fill); + + off += fill_size; + gold_assert(off % abi_pagesize == 0); + ret += fill_size; + gold_assert(ret % abi_pagesize == 0); + + gold_assert((uint64_t) this->filesz_ == this->memsz_); + this->memsz_ = this->filesz_ += fill_size; + + *poff = off; + } + } + return ret; } @@ -4338,10 +4482,10 @@ Output_segment::set_section_addresses(Layout* layout, bool reset, uint64_t Output_segment::set_section_list_addresses(Layout* layout, bool reset, - Output_data_list* pdl, + Output_data_list* pdl, uint64_t addr, off_t* poff, unsigned int* pshndx, - bool* in_tls) + bool* in_tls) { off_t startoff = *poff; // For incremental updates, we may allocate non-fixed sections from @@ -4360,40 +4504,40 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset, // the section will most likely already have an address. if (!(*p)->is_address_valid()) { - uint64_t align = (*p)->addralign(); - - if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)) - { - // Give the first TLS section the alignment of the - // entire TLS segment. Otherwise the TLS segment as a - // whole may be misaligned. - if (!*in_tls) - { - Output_segment* tls_segment = layout->tls_segment(); - gold_assert(tls_segment != NULL); - uint64_t segment_align = tls_segment->maximum_alignment(); - gold_assert(segment_align >= align); - align = segment_align; - - *in_tls = true; - } - } - else - { - // If this is the first section after the TLS segment, - // align it to at least the alignment of the TLS - // segment, so that the size of the overall TLS segment - // is aligned. - if (*in_tls) - { - uint64_t segment_align = - layout->tls_segment()->maximum_alignment(); - if (segment_align > align) - align = segment_align; - - *in_tls = false; - } - } + uint64_t align = (*p)->addralign(); + + if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)) + { + // Give the first TLS section the alignment of the + // entire TLS segment. Otherwise the TLS segment as a + // whole may be misaligned. + if (!*in_tls) + { + Output_segment* tls_segment = layout->tls_segment(); + gold_assert(tls_segment != NULL); + uint64_t segment_align = tls_segment->maximum_alignment(); + gold_assert(segment_align >= align); + align = segment_align; + + *in_tls = true; + } + } + else + { + // If this is the first section after the TLS segment, + // align it to at least the alignment of the TLS + // segment, so that the size of the overall TLS segment + // is aligned. + if (*in_tls) + { + uint64_t segment_align = + layout->tls_segment()->maximum_alignment(); + if (segment_align > align) + align = segment_align; + + *in_tls = false; + } + } if (!parameters->incremental_update()) { @@ -4407,12 +4551,12 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset, off_t current_size = (*p)->current_data_size(); off = layout->allocate(current_size, align, startoff); if (off == -1) - { + { gold_assert((*p)->output_section() != NULL); gold_fallback(_("out of patch space for section %s; " "relink with --incremental-full"), (*p)->output_section()->name()); - } + } (*p)->set_address_and_file_offset(addr + (off - startoff), off); if ((*p)->data_size() > current_size) { @@ -4424,11 +4568,11 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset, } } else if (parameters->incremental_update()) - { - // For incremental updates, use the fixed offset for the - // high-water mark computation. - off = (*p)->offset(); - } + { + // For incremental updates, use the fixed offset for the + // high-water mark computation. + off = (*p)->offset(); + } else { // The script may have inserted a skip forward, but it @@ -4478,7 +4622,7 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset, off += (*p)->data_size(); if (off > maxoff) - maxoff = off; + maxoff = off; if ((*p)->is_section()) { @@ -4570,7 +4714,7 @@ Output_segment::set_offset(unsigned int increase) // page boundary. if (this->type_ == elfcpp::PT_GNU_RELRO) { - uint64_t page_align = parameters->target().common_pagesize(); + uint64_t page_align = parameters->target().abi_pagesize(); uint64_t segment_end = this->vaddr_ + this->memsz_; if (parameters->incremental_update()) { @@ -4607,10 +4751,10 @@ Output_segment::set_tls_offsets() (*p)->set_tls_offset(this->vaddr_); } -// Return the load address of the first section. +// Return the first section. -uint64_t -Output_segment::first_section_load_address() const +Output_section* +Output_segment::first_section() const { for (int i = 0; i < static_cast(ORDER_MAX); ++i) { @@ -4620,9 +4764,7 @@ Output_segment::first_section_load_address() const ++p) { if ((*p)->is_section()) - return ((*p)->has_load_address() - ? (*p)->load_address() - : (*p)->address()); + return (*p)->output_section(); } } gold_unreachable(); @@ -5077,8 +5219,8 @@ Output_file::map() return; gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"), - this->name_, static_cast(this->file_size_), - strerror(errno)); + this->name_, static_cast(this->file_size_), + strerror(errno)); } // Unmap the file from memory. @@ -5110,19 +5252,19 @@ Output_file::close() size_t bytes_to_write = this->file_size_; size_t offset = 0; while (bytes_to_write > 0) - { - ssize_t bytes_written = ::write(this->o_, this->base_ + offset, - bytes_to_write); - if (bytes_written == 0) - gold_error(_("%s: write: unexpected 0 return-value"), this->name_); - else if (bytes_written < 0) - gold_error(_("%s: write: %s"), this->name_, strerror(errno)); - else - { - bytes_to_write -= bytes_written; - offset += bytes_written; - } - } + { + ssize_t bytes_written = ::write(this->o_, this->base_ + offset, + bytes_to_write); + if (bytes_written == 0) + gold_error(_("%s: write: unexpected 0 return-value"), this->name_); + else if (bytes_written < 0) + gold_error(_("%s: write: %s"), this->name_, strerror(errno)); + else + { + bytes_to_write -= bytes_written; + offset += bytes_written; + } + } } this->unmap(); @@ -5410,24 +5552,16 @@ template class Output_data_group<64, true>; #endif -#ifdef HAVE_TARGET_32_LITTLE template class Output_data_got<32, false>; -#endif -#ifdef HAVE_TARGET_32_BIG template class Output_data_got<32, true>; -#endif -#ifdef HAVE_TARGET_64_LITTLE template class Output_data_got<64, false>; -#endif -#ifdef HAVE_TARGET_64_BIG template class Output_data_got<64, true>; -#endif } // End namespace gold.