X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gold%2Fscript-sections.cc;h=37f729f7588718fc33944c6870da3a243ba93014;hb=f65fe5704af56aca58fd5547d0841a9512e540af;hp=eebbb5eb7ee022f05b665ed436ab048002f7d90f;hpb=4ef28648fb46ee431ce3d8d5cdceb8c171b81cb9;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/script-sections.cc b/gold/script-sections.cc index eebbb5eb7e..37f729f758 100644 --- a/gold/script-sections.cc +++ b/gold/script-sections.cc @@ -1,6 +1,6 @@ // script-sections.cc -- linker script SECTIONS for gold -// Copyright 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008-2019 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -53,10 +53,10 @@ class Memory_region attributes_(attributes), start_(start), length_(length), - current_vma_offset_(0), - current_lma_offset_(0), + current_offset_(0), vma_sections_(), - lma_sections_() + lma_sections_(), + last_section_(NULL) { } // Return the name of this region. @@ -87,45 +87,56 @@ class Memory_region } Expression* - get_current_vma_address(void) const + get_current_address() const { return script_exp_binary_add(this->start_, - script_exp_integer(this->current_vma_offset_)); + script_exp_integer(this->current_offset_)); } - - Expression* - get_current_lma_address(void) const + + void + set_address(uint64_t addr, const Symbol_table* symtab, const Layout* layout) { - return - script_exp_binary_add(this->start_, - script_exp_integer(this->current_lma_offset_)); + uint64_t start = this->start_->eval(symtab, layout, false); + uint64_t len = this->length_->eval(symtab, layout, false); + if (addr < start || addr >= start + len) + gold_error(_("address 0x%llx is not within region %s"), + static_cast(addr), + this->name_.c_str()); + else if (addr < start + this->current_offset_) + gold_error(_("address 0x%llx moves dot backwards in region %s"), + static_cast(addr), + this->name_.c_str()); + this->current_offset_ = addr - start; } - + void - increment_vma_offset(std::string section_name, uint64_t amount, - const Symbol_table* symtab, const Layout* layout) + increment_offset(std::string section_name, uint64_t amount, + const Symbol_table* symtab, const Layout* layout) { - this->current_vma_offset_ += amount; + this->current_offset_ += amount; - if (this->current_vma_offset_ + if (this->current_offset_ > this->length_->eval(symtab, layout, false)) - gold_error (_("section %s overflows end of region %s"), - section_name.c_str(), this->name_.c_str()); + gold_error(_("section %s overflows end of region %s"), + section_name.c_str(), this->name_.c_str()); } - - void - increment_lma_offset(std::string section_name, uint64_t amount, - const Symbol_table* symtab, const Layout* layout) - { - this->current_lma_offset_ += amount; - if (this->current_lma_offset_ - > this->length_->eval(symtab, layout, false)) - gold_error (_("section %s overflows end of region %s (based on load address)"), - section_name.c_str(), this->name_.c_str()); + // Returns true iff there is room left in this region + // for AMOUNT more bytes of data. + bool + has_room_for(const Symbol_table* symtab, const Layout* layout, + uint64_t amount) const + { + return (this->current_offset_ + amount + < this->length_->eval(symtab, layout, false)); } + // Return true if the provided section flags + // are compatible with this region's attributes. + bool + attributes_compatible(elfcpp::Elf_Xword flags, elfcpp::Elf_Xword type) const; + void add_section(Output_section_definition* sec, bool vma) { @@ -140,41 +151,103 @@ class Memory_region // Return the start of the list of sections // whose VMAs are taken from this region. Section_list::const_iterator - get_vma_section_list_start(void) const + get_vma_section_list_start() const { return this->vma_sections_.begin(); } // Return the start of the list of sections // whose LMAs are taken from this region. Section_list::const_iterator - get_lma_section_list_start(void) const + get_lma_section_list_start() const { return this->lma_sections_.begin(); } // Return the end of the list of sections // whose VMAs are taken from this region. Section_list::const_iterator - get_vma_section_list_end(void) const + get_vma_section_list_end() const { return this->vma_sections_.end(); } // Return the end of the list of sections // whose LMAs are taken from this region. Section_list::const_iterator - get_lma_section_list_end(void) const + get_lma_section_list_end() const { return this->lma_sections_.end(); } + Output_section_definition* + get_last_section() const + { return this->last_section_; } + + void + set_last_section(Output_section_definition* sec) + { this->last_section_ = sec; } + private: std::string name_; unsigned int attributes_; Expression* start_; Expression* length_; - uint64_t current_vma_offset_; - uint64_t current_lma_offset_; + // The offset to the next free byte in the region. + // Note - for compatibility with GNU LD we only maintain one offset + // regardless of whether the region is being used for VMA values, + // LMA values, or both. + uint64_t current_offset_; // A list of sections whose VMAs are set inside this region. Section_list vma_sections_; // A list of sections whose LMAs are set inside this region. Section_list lma_sections_; + // The latest section to make use of this region. + Output_section_definition* last_section_; }; +// Return true if the provided section flags +// are compatible with this region's attributes. + +bool +Memory_region::attributes_compatible(elfcpp::Elf_Xword flags, + elfcpp::Elf_Xword type) const +{ + unsigned int attrs = this->attributes_; + + // No attributes means that this region is not compatible with anything. + if (attrs == 0) + return false; + + bool match = true; + do + { + switch (attrs & - attrs) + { + case MEM_EXECUTABLE: + if ((flags & elfcpp::SHF_EXECINSTR) == 0) + match = false; + break; + + case MEM_WRITEABLE: + if ((flags & elfcpp::SHF_WRITE) == 0) + match = false; + break; + + case MEM_READABLE: + // All sections are presumed readable. + break; + + case MEM_ALLOCATABLE: + if ((flags & elfcpp::SHF_ALLOC) == 0) + match = false; + break; + + case MEM_INITIALIZED: + if ((type & elfcpp::SHT_NOBITS) != 0) + match = false; + break; + } + attrs &= ~ (attrs & - attrs); + } + while (attrs != 0); + + return match; +} + // Print a memory region. void @@ -240,6 +313,10 @@ class Orphan_section_placement bool find_place(Output_section*, Elements_iterator** pwhere); + // Update PLACE_LAST_ALLOC. + void + update_last_alloc(Elements_iterator where); + // Return the iterator being used for sections at the very end of // the linker script. Elements_iterator @@ -256,6 +333,7 @@ class Orphan_section_placement PLACE_TLS, PLACE_TLS_BSS, PLACE_BSS, + PLACE_LAST_ALLOC, PLACE_REL, PLACE_INTERP, PLACE_NONALLOC, @@ -295,6 +373,7 @@ Orphan_section_placement::Orphan_section_placement() this->initialize_place(PLACE_TLS, NULL); this->initialize_place(PLACE_TLS_BSS, NULL); this->initialize_place(PLACE_BSS, ".bss"); + this->initialize_place(PLACE_LAST_ALLOC, NULL); this->initialize_place(PLACE_REL, NULL); this->initialize_place(PLACE_INTERP, ".interp"); this->initialize_place(PLACE_NONALLOC, NULL); @@ -323,6 +402,15 @@ Orphan_section_placement::output_section_init(const std::string& name, bool first_init = this->first_init_; this->first_init_ = false; + // Remember the last allocated section. Any orphan bss sections + // will be placed after it. + if (os != NULL + && (os->flags() & elfcpp::SHF_ALLOC) != 0) + { + this->places_[PLACE_LAST_ALLOC].location = location; + this->places_[PLACE_LAST_ALLOC].have_location = true; + } + for (int i = 0; i < PLACE_MAX; ++i) { if (this->places_[i].name != NULL && this->places_[i].name == name) @@ -435,8 +523,13 @@ Orphan_section_placement::find_place(Output_section* os, case PLACE_RODATA: follow = PLACE_TEXT; break; + case PLACE_DATA: + follow = PLACE_RODATA; + if (!this->places_[PLACE_RODATA].have_location) + follow = PLACE_TEXT; + break; case PLACE_BSS: - follow = PLACE_DATA; + follow = PLACE_LAST_ALLOC; break; case PLACE_REL: follow = PLACE_TEXT; @@ -473,6 +566,20 @@ Orphan_section_placement::find_place(Output_section* os, return ret; } +// Update PLACE_LAST_ALLOC. +void +Orphan_section_placement::update_last_alloc(Elements_iterator elem) +{ + Elements_iterator prev = elem; + --prev; + if (this->places_[PLACE_LAST_ALLOC].have_location + && this->places_[PLACE_LAST_ALLOC].location == prev) + { + this->places_[PLACE_LAST_ALLOC].have_location = true; + this->places_[PLACE_LAST_ALLOC].location = elem; + } +} + // Return the iterator being used for sections at the very end of the // linker script. @@ -525,7 +632,7 @@ class Sections_element // Output_section_definition. virtual const char* output_section_name(const char*, const char*, Output_section***, - Script_sections::Section_type*) + Script_sections::Section_type*, bool*, bool) { return NULL; } // Initialize OSP with an output section. @@ -535,7 +642,7 @@ class Sections_element { } // Set section addresses. This includes applying assignments if the - // the expression is an absolute value. + // expression is an absolute value. virtual void set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*, uint64_t*) @@ -623,7 +730,7 @@ class Sections_element_assignment : public Sections_element set_section_addresses(Symbol_table* symtab, Layout* layout, uint64_t* dot_value, uint64_t*, uint64_t*) { - this->assignment_.set_if_absolute(symtab, layout, true, *dot_value); + this->assignment_.set_if_absolute(symtab, layout, true, *dot_value, NULL); } // Print for debugging. @@ -656,9 +763,8 @@ class Sections_element_dot_assignment : public Sections_element // We ignore the section of the result because outside of an // output section definition the dot symbol is always considered // to be absolute. - Output_section* dummy; *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value, - NULL, &dummy, NULL); + NULL, NULL, NULL, false); } // Update the dot symbol while setting section addresses. @@ -667,9 +773,8 @@ class Sections_element_dot_assignment : public Sections_element uint64_t* dot_value, uint64_t* dot_alignment, uint64_t* load_address) { - Output_section* dummy; *dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value, - NULL, &dummy, dot_alignment); + NULL, NULL, dot_alignment, false); *load_address = *dot_value; } @@ -745,11 +850,11 @@ class Output_section_element // Return whether this element matches FILE_NAME and SECTION_NAME. // The only real implementation is in Output_section_element_input. virtual bool - match_name(const char*, const char*) const + match_name(const char*, const char*, bool *) const { return false; } // Set section addresses. This includes applying assignments if the - // the expression is an absolute value. + // expression is an absolute value. virtual void set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t, uint64_t*, uint64_t*, Output_section**, std::string*, @@ -811,9 +916,11 @@ class Output_section_element_assignment : public Output_section_element void set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*, uint64_t, uint64_t* dot_value, uint64_t*, - Output_section**, std::string*, Input_section_list*) + Output_section** dot_section, std::string*, + Input_section_list*) { - this->assignment_.set_if_absolute(symtab, layout, true, *dot_value); + this->assignment_.set_if_absolute(symtab, layout, true, *dot_value, + *dot_section); } // Print for debugging. @@ -837,20 +944,28 @@ class Output_section_element_dot_assignment : public Output_section_element : val_(val) { } + // An assignment to dot within an output section is enough to force + // the output section to exist. + bool + needs_output_section() const + { return true; } + // Finalize the symbol. void finalize_symbols(Symbol_table* symtab, const Layout* layout, uint64_t* dot_value, Output_section** dot_section) { *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value, - *dot_section, dot_section, NULL); + *dot_section, dot_section, NULL, + true); } // Update the dot symbol while setting section addresses. void set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*, uint64_t, uint64_t* dot_value, uint64_t*, - Output_section**, std::string*, Input_section_list*); + Output_section** dot_section, std::string*, + Input_section_list*); // Print for debugging. void @@ -881,7 +996,8 @@ Output_section_element_dot_assignment::set_section_addresses( { uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, false, *dot_value, *dot_section, - dot_section, dot_alignment); + dot_section, dot_alignment, + true); if (next_dot < *dot_value) gold_error(_("dot may not move backward")); if (next_dot > *dot_value && output_section != NULL) @@ -980,10 +1096,10 @@ Output_data_expression::do_write(Output_file* of) void Output_data_expression::do_write_to_buffer(unsigned char* buf) { - Output_section* dummy; uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_, true, this->dot_value_, - this->dot_section_, &dummy, NULL); + this->dot_section_, NULL, NULL, + false); if (parameters->target().is_big_endian()) this->endian_write_to_buffer(val, buf); @@ -1133,7 +1249,7 @@ class Output_section_element_fill : public Output_section_element Output_section* fill_section; uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, false, *dot_value, *dot_section, - &fill_section, NULL); + &fill_section, NULL, false); if (fill_section != NULL) gold_warning(_("fill value is not absolute")); // FIXME: The GNU linker supports fill values of arbitrary length. @@ -1172,10 +1288,10 @@ class Output_section_element_input : public Output_section_element *dot_section = this->final_dot_section_; } - // See whether we match FILE_NAME and SECTION_NAME as an input - // section. + // See whether we match FILE_NAME and SECTION_NAME as an input section. + // If we do then also indicate whether the section should be KEPT. bool - match_name(const char* file_name, const char* section_name) const; + match_name(const char* file_name, const char* section_name, bool* keep) const; // Set the section address. void @@ -1327,15 +1443,19 @@ Output_section_element_input::match_file_name(const char* file_name) const return true; } -// See whether we match FILE_NAME and SECTION_NAME. +// See whether we match FILE_NAME and SECTION_NAME. If we do then +// KEEP indicates whether the section should survive garbage collection. bool Output_section_element_input::match_name(const char* file_name, - const char* section_name) const + const char* section_name, + bool *keep) const { if (!this->match_file_name(file_name)) return false; + *keep = this->keep_; + // If there are no section name patterns, then we match. if (this->input_section_patterns_.empty()) return true; @@ -1387,7 +1507,12 @@ class Input_section_info // Set the section name. void set_section_name(const std::string name) - { this->section_name_ = name; } + { + if (is_compressed_debug_section(name.c_str())) + this->section_name_ = corresponding_uncompressed_section_name(name); + else + this->section_name_ = name; + } // Return the section size. uint64_t @@ -1412,7 +1537,7 @@ class Input_section_info private: // Input section, can be a relaxed section. Output_section::Input_section input_section_; - // Name of the section. + // Name of the section. std::string section_name_; // Section size. uint64_t size_; @@ -1433,18 +1558,69 @@ class Input_section_sorter operator()(const Input_section_info&, const Input_section_info&) const; private: + static unsigned long + get_init_priority(const char*); + Sort_wildcard filename_sort_; Sort_wildcard section_sort_; }; +// Return a relative priority of the section with the specified NAME +// (a lower value meand a higher priority), or 0 if it should be compared +// with others as strings. +// The implementation of this function is copied from ld/ldlang.c. + +unsigned long +Input_section_sorter::get_init_priority(const char* name) +{ + char* end; + unsigned long init_priority; + + // GCC uses the following section names for the init_priority + // attribute with numerical values 101 and 65535 inclusive. A + // lower value means a higher priority. + // + // 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the + // decimal numerical value of the init_priority attribute. + // The order of execution in .init_array is forward and + // .fini_array is backward. + // 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the + // decimal numerical value of the init_priority attribute. + // The order of execution in .ctors is backward and .dtors + // is forward. + + if (strncmp(name, ".init_array.", 12) == 0 + || strncmp(name, ".fini_array.", 12) == 0) + { + init_priority = strtoul(name + 12, &end, 10); + return *end ? 0 : init_priority; + } + else if (strncmp(name, ".ctors.", 7) == 0 + || strncmp(name, ".dtors.", 7) == 0) + { + init_priority = strtoul(name + 7, &end, 10); + return *end ? 0 : 65535 - init_priority; + } + + return 0; +} + bool Input_section_sorter::operator()(const Input_section_info& isi1, const Input_section_info& isi2) const { + if (this->section_sort_ == SORT_WILDCARD_BY_INIT_PRIORITY) + { + unsigned long ip1 = get_init_priority(isi1.section_name().c_str()); + unsigned long ip2 = get_init_priority(isi2.section_name().c_str()); + if (ip1 != 0 && ip2 != 0 && ip1 != ip2) + return ip1 < ip2; + } if (this->section_sort_ == SORT_WILDCARD_BY_NAME || this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT || (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME - && isi1.addralign() == isi2.addralign())) + && isi1.addralign() == isi2.addralign()) + || this->section_sort_ == SORT_WILDCARD_BY_INIT_PRIORITY) { if (isi1.section_name() != isi2.section_name()) return isi1.section_name() < isi2.section_name(); @@ -1485,11 +1661,36 @@ Output_section_element_input::set_section_addresses( // We build a list of sections which match each // Input_section_pattern. + // If none of the patterns specify a sort option, we throw all + // matching input sections into a single bin, in the order we + // find them. Otherwise, we put matching input sections into + // a separate bin for each pattern, and sort each one as + // specified. Thus, an input section spec like this: + // *(.foo .bar) + // will group all .foo and .bar sections in the order seen, + // whereas this: + // *(.foo) *(.bar) + // will group all .foo sections followed by all .bar sections. + // This matches Gnu ld behavior. + + // Things get really weird, though, when you add a sort spec + // on some, but not all, of the patterns, like this: + // *(SORT_BY_NAME(.foo) .bar) + // We do not attempt to match Gnu ld behavior in this case. + typedef std::vector > Matching_sections; size_t input_pattern_count = this->input_section_patterns_.size(); - if (input_pattern_count == 0) - input_pattern_count = 1; - Matching_sections matching_sections(input_pattern_count); + size_t bin_count = 1; + bool any_patterns_with_sort = false; + for (size_t i = 0; i < input_pattern_count; ++i) + { + const Input_section_pattern& isp(this->input_section_patterns_[i]); + if (isp.sort != SORT_WILDCARD_NONE) + any_patterns_with_sort = true; + } + if (any_patterns_with_sort) + bin_count = input_pattern_count; + Matching_sections matching_sections(bin_count); // Look through the list of sections for this output section. Add // each one which matches to one of the elements of @@ -1499,7 +1700,7 @@ Output_section_element_input::set_section_addresses( while (p != input_sections->end()) { Relobj* relobj = p->relobj(); - unsigned int shndx = p->shndx(); + unsigned int shndx = p->shndx(); Input_section_info isi(*p); // Calling section_name and section_addralign is not very @@ -1515,7 +1716,7 @@ Output_section_element_input::set_section_addresses( isi.set_section_name(relobj->section_name(shndx)); if (p->is_relaxed_input_section()) { - // We use current data size because relxed section sizes may not + // We use current data size because relaxed section sizes may not // have finalized yet. isi.set_size(p->relaxed_input_section()->current_data_size()); isi.set_addralign(p->relaxed_input_section()->addralign()); @@ -1546,10 +1747,12 @@ Output_section_element_input::set_section_addresses( break; } - if (i >= this->input_section_patterns_.size()) + if (i >= input_pattern_count) ++p; else { + if (i >= bin_count) + i = 0; matching_sections[i].push_back(isi); p = input_sections->erase(p); } @@ -1562,7 +1765,7 @@ Output_section_element_input::set_section_addresses( // output section. uint64_t dot = *dot_value; - for (size_t i = 0; i < input_pattern_count; ++i) + for (size_t i = 0; i < bin_count; ++i) { if (matching_sections[i].empty()) continue; @@ -1582,16 +1785,16 @@ Output_section_element_input::set_section_addresses( p != matching_sections[i].end(); ++p) { - // Override the original address alignment if SUBALIGN is specified - // and is greater than the original alignment. We need to make a - // copy of the input section to modify the alignment. + // Override the original address alignment if SUBALIGN is specified. + // We need to make a copy of the input section to modify the + // alignment. Output_section::Input_section sis(p->input_section()); uint64_t this_subalign = sis.addralign(); if (!sis.is_input_section()) - sis.output_section_data()->finalize_data_size(); + sis.output_section_data()->finalize_data_size(); uint64_t data_size = sis.data_size(); - if (this_subalign < subalign) + if (subalign > 0) { this_subalign = subalign; sis.set_addralign(subalign); @@ -1709,6 +1912,10 @@ Output_section_element_input::print(FILE* f) const fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME("); close_parens = 2; break; + case SORT_WILDCARD_BY_INIT_PRIORITY: + fprintf(f, "SORT_BY_INIT_PRIORITY("); + close_parens = 1; + break; default: gold_unreachable(); } @@ -1795,7 +2002,8 @@ class Output_section_definition : public Sections_element // section name. const char* output_section_name(const char* file_name, const char* section_name, - Output_section***, Script_sections::Section_type*); + Output_section***, Script_sections::Section_type*, + bool*, bool); // Initialize OSP with an output section. void @@ -1855,15 +2063,15 @@ class Output_section_definition : public Sections_element void set_section_vma(Expression* address) { this->address_ = address; } - + void set_section_lma(Expression* address) { this->load_address_ = address; } - std::string - get_section_name(void) const + const std::string& + get_section_name() const { return this->name_; } - + private: static const char* script_section_type_name(Script_section_type); @@ -2052,18 +2260,15 @@ Output_section_definition::finalize_symbols(Symbol_table* symtab, uint64_t address = *dot_value; if (this->address_ != NULL) { - Output_section* dummy; address = this->address_->eval_with_dot(symtab, layout, true, *dot_value, NULL, - &dummy, NULL); + NULL, NULL, false); } if (this->align_ != NULL) { - Output_section* dummy; uint64_t align = this->align_->eval_with_dot(symtab, layout, true, - *dot_value, - NULL, - &dummy, NULL); + *dot_value, NULL, + NULL, NULL, false); address = align_address(address, align); } *dot_value = address; @@ -2083,14 +2288,27 @@ Output_section_definition::output_section_name( const char* file_name, const char* section_name, Output_section*** slot, - Script_sections::Section_type* psection_type) + Script_sections::Section_type* psection_type, + bool* keep, + bool match_input_spec) { + // If the section is a linker-created output section, just look for a match + // on the output section name. + if (!match_input_spec && this->name_ != "/DISCARD/") + { + if (this->name_ != section_name) + return NULL; + *slot = &this->output_section_; + *psection_type = this->section_type(); + return this->name_.c_str(); + } + // Ask each element whether it matches NAME. for (Output_section_elements::const_iterator p = this->elements_.begin(); p != this->elements_.end(); ++p) { - if ((*p)->match_name(file_name, section_name)) + if ((*p)->match_name(file_name, section_name, keep)) { // We found a match for NAME, which means that it should go // into this output section. @@ -2104,6 +2322,112 @@ Output_section_definition::output_section_name( return NULL; } +// Return true if memory from START to START + LENGTH is contained +// within a memory region. + +bool +Script_sections::block_in_region(Symbol_table* symtab, Layout* layout, + uint64_t start, uint64_t length) const +{ + if (this->memory_regions_ == NULL) + return false; + + for (Memory_regions::const_iterator mr = this->memory_regions_->begin(); + mr != this->memory_regions_->end(); + ++mr) + { + uint64_t s = (*mr)->start_address()->eval(symtab, layout, false); + uint64_t l = (*mr)->length()->eval(symtab, layout, false); + + if (s <= start + && (s + l) >= (start + length)) + return true; + } + + return false; +} + +// Find a memory region that should be used by a given output SECTION. +// If provided set PREVIOUS_SECTION_RETURN to point to the last section +// that used the return memory region. + +Memory_region* +Script_sections::find_memory_region( + Output_section_definition* section, + bool find_vma_region, + bool explicit_only, + Output_section_definition** previous_section_return) +{ + if (previous_section_return != NULL) + * previous_section_return = NULL; + + // Walk the memory regions specified in this script, if any. + if (this->memory_regions_ == NULL) + return NULL; + + // The /DISCARD/ section never gets assigned to any region. + if (section->get_section_name() == "/DISCARD/") + return NULL; + + Memory_region* first_match = NULL; + + // First check to see if a region has been assigned to this section. + for (Memory_regions::const_iterator mr = this->memory_regions_->begin(); + mr != this->memory_regions_->end(); + ++mr) + { + if (find_vma_region) + { + for (Memory_region::Section_list::const_iterator s = + (*mr)->get_vma_section_list_start(); + s != (*mr)->get_vma_section_list_end(); + ++s) + if ((*s) == section) + { + (*mr)->set_last_section(section); + return *mr; + } + } + else + { + for (Memory_region::Section_list::const_iterator s = + (*mr)->get_lma_section_list_start(); + s != (*mr)->get_lma_section_list_end(); + ++s) + if ((*s) == section) + { + (*mr)->set_last_section(section); + return *mr; + } + } + + if (!explicit_only) + { + // Make a note of the first memory region whose attributes + // are compatible with the section. If we do not find an + // explicit region assignment, then we will return this region. + Output_section* out_sec = section->get_output_section(); + if (first_match == NULL + && out_sec != NULL + && (*mr)->attributes_compatible(out_sec->flags(), + out_sec->type())) + first_match = *mr; + } + } + + // With LMA computations, if an explicit region has not been specified then + // we will want to set the difference between the VMA and the LMA of the + // section were searching for to be the same as the difference between the + // VMA and LMA of the last section to be added to first matched region. + // Hence, if it was asked for, we return a pointer to the last section + // known to be used by the first matched region. + if (first_match != NULL + && previous_section_return != NULL) + *previous_section_return = first_match->get_last_section(); + + return first_match; +} + // Set the section address. Note that the OUTPUT_SECTION_ field will // be NULL if no input sections were mapped to this output section. // We still have to adjust dot and process symbol assignments. @@ -2115,27 +2439,54 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, uint64_t* dot_alignment, uint64_t* load_address) { + Memory_region* vma_region = NULL; + Memory_region* lma_region = NULL; + Script_sections* script_sections = + layout->script_options()->script_sections(); uint64_t address; uint64_t old_dot_value = *dot_value; uint64_t old_load_address = *load_address; - // Check for --section-start. - bool is_address_set = false; - if (this->output_section_ != NULL) - is_address_set = - parameters->options().section_start(this->output_section_->name(), - &address); - if (!is_address_set) + // If input section sorting is requested via --section-ordering-file or + // linker plugins, then do it here. This is important because we want + // any sorting specified in the linker scripts, which will be done after + // this, to take precedence. The final order of input sections is then + // guaranteed to be according to the linker script specification. + if (this->output_section_ != NULL + && this->output_section_->input_section_order_specified()) + this->output_section_->sort_attached_input_sections(); + + // Decide the start address for the section. The algorithm is: + // 1) If an address has been specified in a linker script, use that. + // 2) Otherwise if a memory region has been specified for the section, + // use the next free address in the region. + // 3) Otherwise if memory regions have been specified find the first + // region whose attributes are compatible with this section and + // install it into that region. + // 4) Otherwise use the current location counter. + + if (this->output_section_ != NULL + // Check for --section-start. + && parameters->options().section_start(this->output_section_->name(), + &address)) + ; + else if (this->address_ == NULL) { - if (this->address_ == NULL) - address = *dot_value; + vma_region = script_sections->find_memory_region(this, true, false, NULL); + if (vma_region != NULL) + address = vma_region->get_current_address()->eval(symtab, layout, + false); else - { - Output_section* dummy; - address = this->address_->eval_with_dot(symtab, layout, true, - *dot_value, NULL, &dummy, - dot_alignment); - } + address = *dot_value; + } + else + { + vma_region = script_sections->find_memory_region(this, true, true, NULL); + address = this->address_->eval_with_dot(symtab, layout, true, + *dot_value, NULL, NULL, + dot_alignment, false); + if (vma_region != NULL) + vma_region->set_address(address, symtab, layout); } uint64_t align; @@ -2150,7 +2501,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, { Output_section* align_section; align = this->align_->eval_with_dot(symtab, layout, true, *dot_value, - NULL, &align_section, NULL); + NULL, &align_section, NULL, false); if (align_section != NULL) gold_warning(_("alignment of section %s is not absolute"), this->name_.c_str()); @@ -2158,6 +2509,35 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, this->output_section_->set_addralign(align); } + uint64_t subalign; + if (this->subalign_ == NULL) + subalign = 0; + else + { + Output_section* subalign_section; + subalign = this->subalign_->eval_with_dot(symtab, layout, true, + *dot_value, NULL, + &subalign_section, NULL, + false); + if (subalign_section != NULL) + gold_warning(_("subalign of section %s is not absolute"), + this->name_.c_str()); + + // Reserve a value of 0 to mean there is no SUBALIGN property. + if (subalign == 0) + subalign = 1; + + // The external alignment of the output section must be at least + // as large as that of the input sections. If there is no + // explicit ALIGN property, we set the output section alignment + // to match the input section alignment. + if (align < subalign || this->align_ == NULL) + { + align = subalign; + this->output_section_->set_addralign(align); + } + } + address = align_address(address, align); uint64_t start_address = address; @@ -2174,33 +2554,73 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, this->evaluated_address_ = address; this->evaluated_addralign_ = align; + uint64_t laddr; + if (this->load_address_ == NULL) - this->evaluated_load_address_ = address; + { + Output_section_definition* previous_section; + + // Determine if an LMA region has been set for this section. + lma_region = script_sections->find_memory_region(this, false, false, + &previous_section); + + if (lma_region != NULL) + { + if (previous_section == NULL) + // The LMA address was explicitly set to the given region. + laddr = lma_region->get_current_address()->eval(symtab, layout, + false); + else + { + // We are not going to use the discovered lma_region, so + // make sure that we do not update it in the code below. + lma_region = NULL; + + if (this->address_ != NULL || previous_section == this) + { + // Either an explicit VMA address has been set, or an + // explicit VMA region has been set, so set the LMA equal to + // the VMA. + laddr = address; + } + else + { + // The LMA address was not explicitly or implicitly set. + // + // We have been given the first memory region that is + // compatible with the current section and a pointer to the + // last section to use this region. Set the LMA of this + // section so that the difference between its' VMA and LMA + // is the same as the difference between the VMA and LMA of + // the last section in the given region. + laddr = address + (previous_section->evaluated_load_address_ + - previous_section->evaluated_address_); + } + } + + if (this->output_section_ != NULL) + this->output_section_->set_load_address(laddr); + } + else + { + // Do not set the load address of the output section, if one exists. + // This allows future sections to determine what the load address + // should be. If none is ever set, it will default to being the + // same as the vma address. + laddr = address; + } + } else { - Output_section* dummy; - uint64_t laddr = - this->load_address_->eval_with_dot(symtab, layout, true, *dot_value, - this->output_section_, &dummy, - NULL); + laddr = this->load_address_->eval_with_dot(symtab, layout, true, + *dot_value, + this->output_section_, + NULL, NULL, false); if (this->output_section_ != NULL) this->output_section_->set_load_address(laddr); - this->evaluated_load_address_ = laddr; } - uint64_t subalign; - if (this->subalign_ == NULL) - subalign = 0; - else - { - Output_section* subalign_section; - subalign = this->subalign_->eval_with_dot(symtab, layout, true, - *dot_value, NULL, - &subalign_section, NULL); - if (subalign_section != NULL) - gold_warning(_("subalign of section %s is not absolute"), - this->name_.c_str()); - } + this->evaluated_load_address_ = laddr; std::string fill; if (this->fill_ != NULL) @@ -2211,7 +2631,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true, *dot_value, NULL, &fill_section, - NULL); + NULL, false); if (fill_section != NULL) gold_warning(_("fill of section %s is not absolute"), this->name_.c_str()); @@ -2242,8 +2662,38 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, gold_assert(input_sections.empty()); - if (this->load_address_ == NULL || this->output_section_ == NULL) + if (vma_region != NULL) + { + // Update the VMA region being used by the section now that we know how + // big it is. Use the current address in the region, rather than + // start_address because that might have been aligned upwards and we + // need to allow for the padding. + Expression* addr = vma_region->get_current_address(); + uint64_t size = *dot_value - addr->eval(symtab, layout, false); + + vma_region->increment_offset(this->get_section_name(), size, + symtab, layout); + } + + // If the LMA region is different from the VMA region, then increment the + // offset there as well. Note that we use the same "dot_value - + // start_address" formula that is used in the load_address assignment below. + if (lma_region != NULL && lma_region != vma_region) + lma_region->increment_offset(this->get_section_name(), + *dot_value - start_address, + symtab, layout); + + // Compute the load address for the following section. + if (this->output_section_ == NULL) *load_address = *dot_value; + else if (this->load_address_ == NULL) + { + if (lma_region == NULL) + *load_address = *dot_value; + else + *load_address = + lma_region->get_current_address()->eval(symtab, layout, false); + } else *load_address = (this->output_section_->load_address() + (*dot_value - start_address)); @@ -2596,6 +3046,26 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, uint64_t address = *dot_value; address = align_address(address, this->os_->addralign()); + // If input section sorting is requested via --section-ordering-file or + // linker plugins, then do it here. This is important because we want + // any sorting specified in the linker scripts, which will be done after + // this, to take precedence. The final order of input sections is then + // guaranteed to be according to the linker script specification. + if (this->os_ != NULL + && this->os_->input_section_order_specified()) + this->os_->sort_attached_input_sections(); + + // For a relocatable link, all orphan sections are put at + // address 0. In general we expect all sections to be at + // address 0 for a relocatable link, but we permit the linker + // script to override that for specific output sections. + if (parameters->options().relocatable()) + { + address = 0; + *load_address = 0; + have_load_address = false; + } + if ((this->os_->flags() & elfcpp::SHF_ALLOC) != 0) { this->os_->set_address(address); @@ -2613,18 +3083,24 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, { uint64_t addralign = p->addralign(); if (!p->is_input_section()) - p->output_section_data()->finalize_data_size(); + p->output_section_data()->finalize_data_size(); uint64_t size = p->data_size(); address = align_address(address, addralign); this->os_->add_script_input_section(*p); address += size; } - // An SHF_TLS/SHT_NOBITS section does not take up any address space. - if (this->os_ == NULL - || (this->os_->flags() & elfcpp::SHF_TLS) == 0 - || this->os_->type() != elfcpp::SHT_NOBITS) + if (parameters->options().relocatable()) { + // For a relocatable link, reset DOT_VALUE to 0. + *dot_value = 0; + *load_address = 0; + } + else if (this->os_ == NULL + || (this->os_->flags() & elfcpp::SHF_TLS) == 0 + || this->os_->type() != elfcpp::SHT_NOBITS) + { + // An SHF_TLS/SHT_NOBITS section does not take up any address space. if (!have_load_address) *load_address = address; else @@ -2788,7 +3264,7 @@ Script_sections::add_memory_region(const char* name, size_t namelen, this->memory_regions_ = new Memory_regions(); else if (this->find_memory_region(name, namelen)) { - gold_error (_("region '%.*s' already defined"), static_cast(namelen), + gold_error(_("region '%.*s' already defined"), static_cast(namelen), name); // FIXME: Add a GOLD extension to allow multiple regions with the same // name. This would amount to a single region covering disjoint blocks @@ -2870,7 +3346,8 @@ Script_sections::Script_sections() data_segment_align_start_(), saw_data_segment_align_(false), saw_relro_end_(false), - saw_segment_start_expression_(false) + saw_segment_start_expression_(false), + segments_created_(false) { } @@ -3091,7 +3568,9 @@ Script_sections::output_section_name( const char* file_name, const char* section_name, Output_section*** output_section_slot, - Script_sections::Section_type* psection_type) + Script_sections::Section_type* psection_type, + bool* keep, + bool is_input_section) { for (Sections_elements::const_iterator p = this->sections_elements_->begin(); p != this->sections_elements_->end(); @@ -3099,7 +3578,8 @@ Script_sections::output_section_name( { const char* ret = (*p)->output_section_name(file_name, section_name, output_section_slot, - psection_type); + psection_type, keep, + is_input_section); if (ret != NULL) { @@ -3115,12 +3595,37 @@ Script_sections::output_section_name( } } - // If we couldn't find a mapping for the name, the output section - // gets the name of the input section. - + // We have an orphan section. *output_section_slot = NULL; *psection_type = Script_sections::ST_NONE; + *keep = false; + + General_options::Orphan_handling orphan_handling = + parameters->options().orphan_handling_enum(); + if (orphan_handling == General_options::ORPHAN_DISCARD) + return NULL; + if (orphan_handling == General_options::ORPHAN_ERROR) + { + if (file_name == NULL) + gold_error(_("unplaced orphan section '%s'"), section_name); + else + gold_error(_("unplaced orphan section '%s' from '%s'"), + section_name, file_name); + return NULL; + } + if (orphan_handling == General_options::ORPHAN_WARN) + { + if (file_name == NULL) + gold_warning(_("orphan section '%s' is being placed in section '%s'"), + section_name, section_name); + else + gold_warning(_("orphan section '%s' from '%s' is being placed " + "in section '%s'"), + section_name, file_name, section_name); + } + // If we couldn't find a mapping for the name, the output section + // gets the name of the input section. return section_name; } @@ -3173,6 +3678,9 @@ Script_sections::place_orphan(Output_section* os) Sections_elements::iterator last = osp->last_place(); *where = this->sections_elements_->insert(last, orphan); } + + if ((os->flags() & elfcpp::SHF_ALLOC) != 0) + osp->update_last_alloc(*where); } // Set the addresses of all the output sections. Walk through all the @@ -3188,41 +3696,6 @@ Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout) { gold_assert(this->saw_sections_clause_); - // Walk the memory regions specified in this script, if any. - if (this->memory_regions_ != NULL) - { - for (Memory_regions::const_iterator mr = this->memory_regions_->begin(); - mr != this->memory_regions_->end(); - ++mr) - { - // FIXME: What should we do with the attributes of the regions ? - - // For each region, set the VMA of the sections associated with it. - for (Memory_region::Section_list::const_iterator s = - (*mr)->get_vma_section_list_start(); - s != (*mr)->get_vma_section_list_end(); - ++s) - { - (*s)->set_section_vma((*mr)->get_current_vma_address()); - (*mr)->increment_vma_offset((*s)->get_section_name(), - (*s)->get_output_section()->current_data_size(), - symtab, layout); - } - - // Similarly, set the LMA values. - for (Memory_region::Section_list::const_iterator s = - (*mr)->get_lma_section_list_start(); - s != (*mr)->get_lma_section_list_end(); - ++s) - { - (*s)->set_section_lma((*mr)->get_current_lma_address()); - (*mr)->increment_lma_offset((*s)->get_section_name(), - (*s)->get_output_section()->current_data_size(), - symtab, layout); - } - } - } - // Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain // for our representation. for (Sections_elements::iterator p = this->sections_elements_->begin(); @@ -3291,7 +3764,7 @@ Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout) Output_section* os = (*p)->get_output_section(); // Handle -Ttext, -Tdata and -Tbss options. We do this by looking for - // the special sections by names and doing dot assignments. + // the special sections by names and doing dot assignments. if (use_tsection_options && os != NULL && (os->flags() & elfcpp::SHF_ALLOC) != 0) @@ -3320,7 +3793,7 @@ Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout) (*p)->set_section_addresses(symtab, layout, &dot_value, &dot_alignment, &load_address); - } + } if (this->phdrs_elements_ != NULL) { @@ -3338,8 +3811,19 @@ Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout) class Sort_output_sections { public: + Sort_output_sections(const Script_sections::Sections_elements* elements) + : elements_(elements) + { } + bool operator()(const Output_section* os1, const Output_section* os2) const; + + private: + int + script_compare(const Output_section* os1, const Output_section* os2) const; + + private: + const Script_sections::Sections_elements* elements_; }; bool @@ -3360,26 +3844,70 @@ Sort_output_sections::operator()(const Output_section* os1, if (os1->address() != os2->address()) return os1->address() < os2->address(); - // Sort TLS sections to the end. + // If the linker script says which of these sections is first, go + // with what it says. + int i = this->script_compare(os1, os2); + if (i != 0) + return i < 0; + + // Sort PROGBITS before NOBITS. + bool nobits1 = os1->type() == elfcpp::SHT_NOBITS; + bool nobits2 = os2->type() == elfcpp::SHT_NOBITS; + if (nobits1 != nobits2) + return nobits2; + + // Sort PROGBITS TLS sections to the end, NOBITS TLS sections to the + // beginning. bool tls1 = (os1->flags() & elfcpp::SHF_TLS) != 0; bool tls2 = (os2->flags() & elfcpp::SHF_TLS) != 0; if (tls1 != tls2) - return tls2; - - // Sort PROGBITS before NOBITS. - if (os1->type() == elfcpp::SHT_PROGBITS && os2->type() == elfcpp::SHT_NOBITS) - return true; - if (os1->type() == elfcpp::SHT_NOBITS && os2->type() == elfcpp::SHT_PROGBITS) - return false; + return nobits1 ? tls1 : tls2; // Sort non-NOLOAD before NOLOAD. if (os1->is_noload() && !os2->is_noload()) return true; if (!os1->is_noload() && os2->is_noload()) return true; - - // Otherwise we don't care. - return false; + + // The sections seem practically identical. Sort by name to get a + // stable sort. + return os1->name() < os2->name(); +} + +// Return -1 if OS1 comes before OS2 in ELEMENTS_, 1 if comes after, 0 +// if either OS1 or OS2 is not mentioned. This ensures that we keep +// empty sections in the order in which they appear in a linker +// script. + +int +Sort_output_sections::script_compare(const Output_section* os1, + const Output_section* os2) const +{ + if (this->elements_ == NULL) + return 0; + + bool found_os1 = false; + bool found_os2 = false; + for (Script_sections::Sections_elements::const_iterator + p = this->elements_->begin(); + p != this->elements_->end(); + ++p) + { + if (os2 == (*p)->get_output_section()) + { + if (found_os1) + return -1; + found_os2 = true; + } + else if (os1 == (*p)->get_output_section()) + { + if (found_os2) + return 1; + found_os1 = true; + } + } + + return 0; } // Return whether OS is a BSS section. This is a SHT_NOBITS section. @@ -3418,7 +3946,7 @@ Script_sections::total_header_size(Layout* layout) const return file_header_size + segment_headers_size; } -// Return the amount we have to subtract from the LMA to accomodate +// Return the amount we have to subtract from the LMA to accommodate // headers of the given size. The complication is that the file // header have to be at the start of a page, as otherwise it will not // be at the start of the file. @@ -3452,7 +3980,8 @@ Script_sections::create_segments(Layout* layout, uint64_t dot_alignment) layout->get_allocated_sections(§ions); // Sort the sections by address. - std::stable_sort(sections.begin(), sections.end(), Sort_output_sections()); + std::stable_sort(sections.begin(), sections.end(), + Sort_output_sections(this->sections_elements_)); this->create_note_and_tls_segments(layout, §ions); @@ -3461,10 +3990,10 @@ Script_sections::create_segments(Layout* layout, uint64_t dot_alignment) Output_segment* first_seg = NULL; Output_segment* current_seg = NULL; bool is_current_seg_readonly = true; - Layout::Section_list::iterator plast = sections.end(); uint64_t last_vma = 0; uint64_t last_lma = 0; uint64_t last_size = 0; + bool in_bss = false; for (Layout::Section_list::iterator p = sections.begin(); p != sections.end(); ++p) @@ -3491,7 +4020,7 @@ Script_sections::create_segments(Layout* layout, uint64_t dot_alignment) // skipping a page. need_new_segment = true; } - else if (is_bss_section(*plast) && !is_bss_section(*p)) + else if (in_bss && !is_bss_section(*p)) { // A non-BSS section can not follow a BSS section in the // same segment. @@ -3523,6 +4052,7 @@ Script_sections::create_segments(Layout* layout, uint64_t dot_alignment) if (first_seg == NULL) first_seg = current_seg; is_current_seg_readonly = true; + in_bss = false; } current_seg->add_output_section_to_load(layout, *p, seg_flags); @@ -3530,7 +4060,9 @@ Script_sections::create_segments(Layout* layout, uint64_t dot_alignment) if (((*p)->flags() & elfcpp::SHF_WRITE) != 0) is_current_seg_readonly = false; - plast = p; + if (is_bss_section(*p) && size > 0) + in_bss = true; + last_vma = vma; last_lma = lma; last_size = size; @@ -3576,6 +4108,18 @@ Script_sections::create_segments(Layout* layout, uint64_t dot_alignment) if (lma < subtract || vma < subtract) return NULL; + // If memory regions have been specified and the address range + // we are about to use is not contained within any region then + // issue a warning message about the segment we are going to + // create. It will be outside of any region and so possibly + // using non-existent or protected memory. We test LMA rather + // than VMA since we assume that the headers will never be + // relocated. + if (this->memory_regions_ != NULL + && !this->block_in_region (NULL, layout, lma - subtract, subtract)) + gold_warning(_("creating a segment to contain the file and program" + " headers outside of any MEMORY region")); + Output_segment* load_seg = layout->make_output_segment(elfcpp::PT_LOAD, elfcpp::PF_R); load_seg->set_addresses(vma - subtract, lma - subtract); @@ -3642,7 +4186,21 @@ Script_sections::create_note_and_tls_segments( saw_tls = true; } + + // If we see a section named .interp then put the .interp section + // in a PT_INTERP segment. + // This is for GNU ld compatibility. + if (strcmp((*p)->name(), ".interp") == 0) + { + elfcpp::Elf_Word seg_flags = + Layout::section_flags_to_segment((*p)->flags()); + Output_segment* oseg = layout->make_output_segment(elfcpp::PT_INTERP, + seg_flags); + oseg->add_output_section_to_nonload(*p, seg_flags); + } } + + this->segments_created_ = true; } // Add a program header. The PHDRS clause is syntactically distinct @@ -3670,6 +4228,10 @@ Script_sections::add_phdr(const char* name, size_t namelen, unsigned int type, size_t Script_sections::expected_segment_count(const Layout* layout) const { + // If we've already created the segments, we won't be adding any more. + if (this->segments_created_) + return 0; + if (this->saw_phdrs_clause()) return this->phdrs_elements_->size(); @@ -3681,6 +4243,7 @@ Script_sections::expected_segment_count(const Layout* layout) const bool saw_note = false; bool saw_tls = false; + bool saw_interp = false; for (Layout::Section_list::const_iterator p = sections.begin(); p != sections.end(); ++p) @@ -3704,6 +4267,15 @@ Script_sections::expected_segment_count(const Layout* layout) const saw_tls = true; } } + else if (strcmp((*p)->name(), ".interp") == 0) + { + // There can only be one PT_INTERP segment. + if (!saw_interp) + { + ++ret; + saw_interp = true; + } + } } return ret; @@ -3732,27 +4304,50 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) p != this->phdrs_elements_->end(); ++p) name_to_segment[(*p)->name()] = (*p)->create_segment(layout); + this->segments_created_ = true; // Walk through the output sections and attach them to segments. // Output sections in the script which do not list segments are // attached to the same set of segments as the immediately preceding // output section. - + String_list* phdr_names = NULL; bool load_segments_only = false; for (Sections_elements::const_iterator p = this->sections_elements_->begin(); p != this->sections_elements_->end(); ++p) { - bool orphan; + bool is_orphan; String_list* old_phdr_names = phdr_names; - Output_section* os = (*p)->allocate_to_segment(&phdr_names, &orphan); + Output_section* os = (*p)->allocate_to_segment(&phdr_names, &is_orphan); if (os == NULL) continue; + elfcpp::Elf_Word seg_flags = + Layout::section_flags_to_segment(os->flags()); + if (phdr_names == NULL) { - gold_error(_("allocated section not in any segment")); + // Don't worry about empty orphan sections. + if (is_orphan && os->current_data_size() > 0) + gold_error(_("allocated section %s not in any segment"), + os->name()); + + // To avoid later crashes drop this section into the first + // PT_LOAD segment. + for (Phdrs_elements::const_iterator ppe = + this->phdrs_elements_->begin(); + ppe != this->phdrs_elements_->end(); + ++ppe) + { + Output_segment* oseg = (*ppe)->segment(); + if (oseg->type() == elfcpp::PT_LOAD) + { + oseg->add_output_section_to_load(layout, os, seg_flags); + break; + } + } + continue; } @@ -3760,14 +4355,14 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) // filtering. if (old_phdr_names != phdr_names) load_segments_only = false; - + // If this is an orphan section--one that was not explicitly // mentioned in the linker script--then it should not inherit // any segment type other than PT_LOAD. Otherwise, e.g., the // PT_INTERP segment will pick up following orphan sections, // which does not make sense. If this is not an orphan section, // we trust the linker script. - if (orphan) + if (is_orphan) { // Enable PT_LOAD segments only filtering until we see another // list of segment names. @@ -3788,9 +4383,6 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) && r->second->type() != elfcpp::PT_LOAD) continue; - elfcpp::Elf_Word seg_flags = - Layout::section_flags_to_segment(os->flags()); - if (r->second->type() != elfcpp::PT_LOAD) r->second->add_output_section_to_nonload(os, seg_flags); else @@ -3960,6 +4552,7 @@ Script_sections::release_segments() ++p) (*p)->release_segment(); } + this->segments_created_ = false; } // Print the SECTIONS clause to F for debugging.