X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gold%2Fscript-sections.cc;h=24b9103f9217d8c543c606704091902540836c53;hb=1e5d2fb127950dc92a01fe2bbbd12a219bf2286c;hp=68cba6bdd90b65e803ab6a74b97c8b2b391d32c1;hpb=fd247bfe68f03688b12c8583933f5471f1ed0a86;p=external%2Fbinutils.git diff --git a/gold/script-sections.cc b/gold/script-sections.cc index 68cba6b..24b9103 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 Free Software Foundation, Inc. +// Copyright 2008, 2009 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -43,6 +43,278 @@ namespace gold { +// Manage orphan sections. This is intended to be largely compatible +// with the GNU linker. The Linux kernel implicitly relies on +// something similar to the GNU linker's orphan placement. We +// originally used a simpler scheme here, but it caused the kernel +// build to fail, and was also rather inefficient. + +class Orphan_section_placement +{ + private: + typedef Script_sections::Elements_iterator Elements_iterator; + + public: + Orphan_section_placement(); + + // Handle an output section during initialization of this mapping. + void + output_section_init(const std::string& name, Output_section*, + Elements_iterator location); + + // Initialize the last location. + void + last_init(Elements_iterator location); + + // Set *PWHERE to the address of an iterator pointing to the + // location to use for an orphan section. Return true if the + // iterator has a value, false otherwise. + bool + find_place(Output_section*, Elements_iterator** pwhere); + + // Return the iterator being used for sections at the very end of + // the linker script. + Elements_iterator + last_place() const; + + private: + // The places that we specifically recognize. This list is copied + // from the GNU linker. + enum Place_index + { + PLACE_TEXT, + PLACE_RODATA, + PLACE_DATA, + PLACE_TLS, + PLACE_TLS_BSS, + PLACE_BSS, + PLACE_REL, + PLACE_INTERP, + PLACE_NONALLOC, + PLACE_LAST, + PLACE_MAX + }; + + // The information we keep for a specific place. + struct Place + { + // The name of sections for this place. + const char* name; + // Whether we have a location for this place. + bool have_location; + // The iterator for this place. + Elements_iterator location; + }; + + // Initialize one place element. + void + initialize_place(Place_index, const char*); + + // The places. + Place places_[PLACE_MAX]; + // True if this is the first call to output_section_init. + bool first_init_; +}; + +// Initialize Orphan_section_placement. + +Orphan_section_placement::Orphan_section_placement() + : first_init_(true) +{ + this->initialize_place(PLACE_TEXT, ".text"); + this->initialize_place(PLACE_RODATA, ".rodata"); + this->initialize_place(PLACE_DATA, ".data"); + this->initialize_place(PLACE_TLS, NULL); + this->initialize_place(PLACE_TLS_BSS, NULL); + this->initialize_place(PLACE_BSS, ".bss"); + this->initialize_place(PLACE_REL, NULL); + this->initialize_place(PLACE_INTERP, ".interp"); + this->initialize_place(PLACE_NONALLOC, NULL); + this->initialize_place(PLACE_LAST, NULL); +} + +// Initialize one place element. + +void +Orphan_section_placement::initialize_place(Place_index index, const char* name) +{ + this->places_[index].name = name; + this->places_[index].have_location = false; +} + +// While initializing the Orphan_section_placement information, this +// is called once for each output section named in the linker script. +// If we found an output section during the link, it will be passed in +// OS. + +void +Orphan_section_placement::output_section_init(const std::string& name, + Output_section* os, + Elements_iterator location) +{ + bool first_init = this->first_init_; + this->first_init_ = false; + + for (int i = 0; i < PLACE_MAX; ++i) + { + if (this->places_[i].name != NULL && this->places_[i].name == name) + { + if (this->places_[i].have_location) + { + // We have already seen a section with this name. + return; + } + + this->places_[i].location = location; + this->places_[i].have_location = true; + + // If we just found the .bss section, restart the search for + // an unallocated section. This follows the GNU linker's + // behaviour. + if (i == PLACE_BSS) + this->places_[PLACE_NONALLOC].have_location = false; + + return; + } + } + + // Relocation sections. + if (!this->places_[PLACE_REL].have_location + && os != NULL + && (os->type() == elfcpp::SHT_REL || os->type() == elfcpp::SHT_RELA) + && (os->flags() & elfcpp::SHF_ALLOC) != 0) + { + this->places_[PLACE_REL].location = location; + this->places_[PLACE_REL].have_location = true; + } + + // We find the location for unallocated sections by finding the + // first debugging or comment section after the BSS section (if + // there is one). + if (!this->places_[PLACE_NONALLOC].have_location + && (name == ".comment" || Layout::is_debug_info_section(name.c_str()))) + { + // We add orphan sections after the location in PLACES_. We + // want to store unallocated sections before LOCATION. If this + // is the very first section, we can't use it. + if (!first_init) + { + --location; + this->places_[PLACE_NONALLOC].location = location; + this->places_[PLACE_NONALLOC].have_location = true; + } + } +} + +// Initialize the last location. + +void +Orphan_section_placement::last_init(Elements_iterator location) +{ + this->places_[PLACE_LAST].location = location; + this->places_[PLACE_LAST].have_location = true; +} + +// Set *PWHERE to the address of an iterator pointing to the location +// to use for an orphan section. Return true if the iterator has a +// value, false otherwise. + +bool +Orphan_section_placement::find_place(Output_section* os, + Elements_iterator** pwhere) +{ + // Figure out where OS should go. This is based on the GNU linker + // code. FIXME: The GNU linker handles small data sections + // specially, but we don't. + elfcpp::Elf_Word type = os->type(); + elfcpp::Elf_Xword flags = os->flags(); + Place_index index; + if ((flags & elfcpp::SHF_ALLOC) == 0 + && !Layout::is_debug_info_section(os->name())) + index = PLACE_NONALLOC; + else if ((flags & elfcpp::SHF_ALLOC) == 0) + index = PLACE_LAST; + else if (type == elfcpp::SHT_NOTE) + index = PLACE_INTERP; + else if ((flags & elfcpp::SHF_TLS) != 0) + { + if (type == elfcpp::SHT_NOBITS) + index = PLACE_TLS_BSS; + else + index = PLACE_TLS; + } + else if (type == elfcpp::SHT_NOBITS) + index = PLACE_BSS; + else if ((flags & elfcpp::SHF_WRITE) != 0) + index = PLACE_DATA; + else if (type == elfcpp::SHT_REL || type == elfcpp::SHT_RELA) + index = PLACE_REL; + else if ((flags & elfcpp::SHF_EXECINSTR) == 0) + index = PLACE_RODATA; + else + index = PLACE_TEXT; + + // If we don't have a location yet, try to find one based on a + // plausible ordering of sections. + if (!this->places_[index].have_location) + { + Place_index follow; + switch (index) + { + default: + follow = PLACE_MAX; + break; + case PLACE_RODATA: + follow = PLACE_TEXT; + break; + case PLACE_BSS: + follow = PLACE_DATA; + break; + case PLACE_REL: + follow = PLACE_TEXT; + break; + case PLACE_INTERP: + follow = PLACE_TEXT; + break; + case PLACE_TLS: + follow = PLACE_DATA; + break; + case PLACE_TLS_BSS: + follow = PLACE_TLS; + if (!this->places_[PLACE_TLS].have_location) + follow = PLACE_DATA; + break; + } + if (follow != PLACE_MAX && this->places_[follow].have_location) + { + // Set the location of INDEX to the location of FOLLOW. The + // location of INDEX will then be incremented by the caller, + // so anything in INDEX will continue to be after anything + // in FOLLOW. + this->places_[index].location = this->places_[follow].location; + this->places_[index].have_location = true; + } + } + + *pwhere = &this->places_[index].location; + bool ret = this->places_[index].have_location; + + // The caller will set the location. + this->places_[index].have_location = true; + + return ret; +} + +// Return the iterator being used for sections at the very end of the +// linker script. + +Orphan_section_placement::Elements_iterator +Orphan_section_placement::last_place() const +{ + gold_assert(this->places_[PLACE_LAST].have_location); + return this->places_[PLACE_LAST].location; +} + // An element in a SECTIONS clause. class Sections_element @@ -54,6 +326,22 @@ class Sections_element virtual ~Sections_element() { } + // Return whether an output section is relro. + virtual bool + is_relro() const + { return false; } + + // Record that an output section is relro. + virtual void + set_is_relro() + { } + + // Create any required output sections. The only real + // implementation is in Output_section_definition. + virtual void + create_sections(Layout*) + { } + // Add any symbol being defined to the symbol table. virtual void add_symbols_to_table(Symbol_table*) @@ -68,14 +356,15 @@ class Sections_element // section name. This only real implementation is in // Output_section_definition. virtual const char* - output_section_name(const char*, const char*, Output_section***) + output_section_name(const char*, const char*, Output_section***, + Script_sections::Section_type*) { return NULL; } - // Return whether to place an orphan output section after this - // element. - virtual bool - place_orphan_here(const Output_section *, bool*) const - { return false; } + // Initialize OSP with an output section. + virtual void + orphan_section_init(Orphan_section_placement*, + Script_sections::Elements_iterator) + { } // Set section addresses. This includes applying assignments if the // the expression is an absolute value. @@ -99,11 +388,30 @@ class Sections_element // Get the list of segments to use for an allocated section when // using a PHDRS clause. If this is an allocated section, return - // the Output_section, and set *PHDRS_LIST to the list of PHDRS to - // which it should be attached. If the PHDRS were not specified, - // don't change *PHDRS_LIST. + // the Output_section, and set *PHDRS_LIST (the first parameter) to + // the list of PHDRS to which it should be attached. If the PHDRS + // were not specified, don't change *PHDRS_LIST. When not returning + // NULL, set *ORPHAN (the second parameter) according to whether + // this is an orphan section--one that is not mentioned in the + // linker script. virtual Output_section* - allocate_to_segment(String_list**) + allocate_to_segment(String_list**, bool*) + { return NULL; } + + // Look for an output section by name and return the address, the + // load address, the alignment, and the size. This is used when an + // expression refers to an output section which was not actually + // created. This returns true if the section was found, false + // otherwise. The only real definition is for + // Output_section_definition. + virtual bool + get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*, + uint64_t*) const + { return false; } + + // Return the associated Output_section if there is one. + virtual Output_section* + get_output_section() const { return NULL; } // Print the element for debugging purposes. @@ -118,7 +426,7 @@ class Sections_element_assignment : public Sections_element public: Sections_element_assignment(const char* name, size_t namelen, Expression* val, bool provide, bool hidden) - : assignment_(name, namelen, val, provide, hidden) + : assignment_(name, namelen, false, val, provide, hidden) { } // Add the symbol to the symbol table. @@ -175,7 +483,7 @@ class Sections_element_dot_assignment : public Sections_element // output section definition the dot symbol is always considered // to be absolute. Output_section* dummy; - *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_value, + *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value, NULL, &dummy); } @@ -185,7 +493,7 @@ class Sections_element_dot_assignment : public Sections_element uint64_t* dot_value, uint64_t* load_address) { Output_section* dummy; - *dot_value = this->val_->eval_with_dot(symtab, layout, *dot_value, + *dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value, NULL, &dummy); *load_address = *dot_value; } @@ -236,7 +544,7 @@ class Output_section_element { public: // A list of input sections. - typedef std::list > Input_section_list; + typedef std::list Input_section_list; Output_section_element() { } @@ -244,6 +552,11 @@ class Output_section_element virtual ~Output_section_element() { } + // Return whether this element requires an output section to exist. + virtual bool + needs_output_section() const + { return false; } + // Add any symbol being defined to the symbol table. virtual void add_symbols_to_table(Symbol_table*) @@ -300,7 +613,7 @@ class Output_section_element_assignment : public Output_section_element Output_section_element_assignment(const char* name, size_t namelen, Expression* val, bool provide, bool hidden) - : assignment_(name, namelen, val, provide, hidden) + : assignment_(name, namelen, false, val, provide, hidden) { } // Add the symbol to the symbol table. @@ -354,7 +667,7 @@ class Output_section_element_dot_assignment : public Output_section_element 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, *dot_value, + *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value, *dot_section, dot_section); } @@ -390,8 +703,9 @@ Output_section_element_dot_assignment::set_section_addresses( std::string* fill, Input_section_list*) { - uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, *dot_value, - *dot_section, dot_section); + uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, false, + *dot_value, *dot_section, + dot_section); if (next_dot < *dot_value) gold_error(_("dot may not move backward")); if (next_dot > *dot_value && output_section != NULL) @@ -400,13 +714,14 @@ Output_section_element_dot_assignment::set_section_addresses( - *dot_value); Output_section_data* posd; if (fill->empty()) - posd = new Output_data_fixed_space(length, 0); + posd = new Output_data_zero_fill(length, 0); else { std::string this_fill = this->get_fill_string(fill, length); posd = new Output_data_const(this_fill, 0); } output_section->add_output_section_data(posd); + layout->new_output_section_data_from_script(posd); } *dot_value = next_dot; } @@ -442,7 +757,7 @@ class Output_data_expression : public Output_section_data Output_data_expression(int size, bool is_signed, Expression* val, const Symbol_table* symtab, const Layout* layout, uint64_t dot_value, Output_section* dot_section) - : Output_section_data(size, 0), + : Output_section_data(size, 0, true), is_signed_(is_signed), val_(val), symtab_(symtab), layout_(layout), dot_value_(dot_value), dot_section_(dot_section) { } @@ -456,6 +771,11 @@ class Output_data_expression : public Output_section_data void do_write_to_buffer(unsigned char*); + // Write to a map file. + void + do_print_to_mapfile(Mapfile* mapfile) const + { mapfile->print_output_data(this, _("** expression")); } + private: template void @@ -486,10 +806,10 @@ 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_, - this->dot_value_, + true, this->dot_value_, this->dot_section_, &dummy); - if (parameters->is_big_endian()) + if (parameters->target().is_big_endian()) this->endian_write_to_buffer(val, buf); else this->endian_write_to_buffer(val, buf); @@ -512,7 +832,7 @@ Output_data_expression::endian_write_to_buffer(uint64_t val, elfcpp::Swap_unaligned<32, big_endian>::writeval(buf, val); break; case 8: - if (parameters->get_size() == 32) + if (parameters->target().get_size() == 32) { val &= 0xffffffff; if (this->is_signed_ && (val & 0x80000000) != 0) @@ -534,6 +854,11 @@ class Output_section_element_data : public Output_section_element : size_(size), is_signed_(is_signed), val_(val) { } + // If there is a data item, then we must create an output section. + bool + needs_output_section() const + { return true; } + // Finalize symbols--we just need to update dot. void finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value, @@ -573,13 +898,11 @@ Output_section_element_data::set_section_addresses( Input_section_list*) { gold_assert(os != NULL); - os->add_output_section_data(new Output_data_expression(this->size_, - this->is_signed_, - this->val_, - symtab, - layout, - *dot_value, - *dot_section)); + Output_data_expression* expression = + new Output_data_expression(this->size_, this->is_signed_, this->val_, + symtab, layout, *dot_value, *dot_section); + os->add_output_section_data(expression); + layout->new_output_section_data_from_script(expression); *dot_value += this->size_; } @@ -631,7 +954,7 @@ class Output_section_element_fill : public Output_section_element std::string* fill, Input_section_list*) { Output_section* fill_section; - uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, + uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, false, *dot_value, *dot_section, &fill_section); if (fill_section != NULL) @@ -865,13 +1188,68 @@ Output_section_element_input::match_name(const char* file_name, // Information we use to sort the input sections. -struct Input_section_info +class Input_section_info { - Relobj* relobj; - unsigned int shndx; - std::string section_name; - uint64_t size; - uint64_t addralign; + public: + Input_section_info(const Output_section::Simple_input_section& input_section) + : input_section_(input_section), section_name_(), + size_(0), addralign_(1) + { } + + // Return the simple input section. + const Output_section::Simple_input_section& + input_section() const + { return this->input_section_; } + + // Return the object. + Relobj* + relobj() const + { return this->input_section_.relobj(); } + + // Return the section index. + unsigned int + shndx() + { return this->input_section_.shndx(); } + + // Return the section name. + const std::string& + section_name() const + { return this->section_name_; } + + // Set the section name. + void + set_section_name(const std::string name) + { this->section_name_ = name; } + + // Return the section size. + uint64_t + size() const + { return this->size_; } + + // Set the section size. + void + set_size(uint64_t size) + { this->size_ = size; } + + // Return the address alignment. + uint64_t + addralign() const + { return this->addralign_; } + + // Set the address alignment. + void + set_addralign(uint64_t addralign) + { this->addralign_ = addralign; } + + private: + // Input section, can be a relaxed section. + Output_section::Simple_input_section input_section_; + // Name of the section. + std::string section_name_; + // Section size. + uint64_t size_; + // Address alignment. + uint64_t addralign_; }; // A class to sort the input sections. @@ -898,22 +1276,22 @@ Input_section_sorter::operator()(const Input_section_info& isi1, 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())) { - if (isi1.section_name != isi2.section_name) - return isi1.section_name < isi2.section_name; + if (isi1.section_name() != isi2.section_name()) + return isi1.section_name() < isi2.section_name(); } if (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT || this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT || this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME) { - if (isi1.addralign != isi2.addralign) - return isi1.addralign < isi2.addralign; + if (isi1.addralign() != isi2.addralign()) + return isi1.addralign() < isi2.addralign(); } if (this->filename_sort_ == SORT_WILDCARD_BY_NAME) { - if (isi1.relobj->name() != isi2.relobj->name()) - return isi1.relobj->name() < isi2.relobj->name(); + if (isi1.relobj()->name() != isi2.relobj()->name()) + return (isi1.relobj()->name() < isi2.relobj()->name()); } // Otherwise we leave them in the same order. @@ -927,7 +1305,7 @@ Input_section_sorter::operator()(const Input_section_info& isi1, void Output_section_element_input::set_section_addresses( Symbol_table*, - Layout*, + Layout* layout, Output_section* output_section, uint64_t subalign, uint64_t* dot_value, @@ -951,25 +1329,36 @@ Output_section_element_input::set_section_addresses( Input_section_list::iterator p = input_sections->begin(); while (p != input_sections->end()) { + Relobj* relobj = p->relobj(); + unsigned int shndx = p->shndx(); + Input_section_info isi(*p); + // Calling section_name and section_addralign is not very // efficient. - Input_section_info isi; - isi.relobj = p->first; - isi.shndx = p->second; // Lock the object so that we can get information about the // section. This is OK since we know we are single-threaded // here. { const Task* task = reinterpret_cast(-1); - Task_lock_obj tl(task, p->first); - - isi.section_name = p->first->section_name(p->second); - isi.size = p->first->section_size(p->second); - isi.addralign = p->first->section_addralign(p->second); + Task_lock_obj tl(task, relobj); + + 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 + // have finalized yet. + isi.set_size(p->relaxed_input_section()->current_data_size()); + isi.set_addralign(p->relaxed_input_section()->addralign()); + } + else + { + isi.set_size(relobj->section_size(shndx)); + isi.set_addralign(relobj->section_addralign(shndx)); + } } - if (!this->match_file_name(isi.relobj->name().c_str())) + if (!this->match_file_name(relobj->name().c_str())) ++p; else if (this->input_section_patterns_.empty()) { @@ -983,7 +1372,7 @@ Output_section_element_input::set_section_addresses( { const Input_section_pattern& isp(this->input_section_patterns_[i]); - if (match(isi.section_name.c_str(), isp.pattern.c_str(), + if (match(isi.section_name().c_str(), isp.pattern.c_str(), isp.pattern_is_wildcard)) break; } @@ -1003,6 +1392,7 @@ Output_section_element_input::set_section_addresses( // sections are otherwise equal. Add each input section to the // output section. + uint64_t dot = *dot_value; for (size_t i = 0; i < input_pattern_count; ++i) { if (matching_sections[i].empty()) @@ -1023,30 +1413,37 @@ Output_section_element_input::set_section_addresses( p != matching_sections[i].end(); ++p) { - uint64_t this_subalign = p->addralign; + uint64_t this_subalign = p->addralign(); if (this_subalign < subalign) this_subalign = subalign; - uint64_t address = align_address(*dot_value, this_subalign); + uint64_t address = align_address(dot, this_subalign); - if (address > *dot_value && !fill->empty()) + if (address > dot && !fill->empty()) { section_size_type length = - convert_to_section_size_type(address - *dot_value); + convert_to_section_size_type(address - dot); std::string this_fill = this->get_fill_string(fill, length); Output_section_data* posd = new Output_data_const(this_fill, 0); output_section->add_output_section_data(posd); + layout->new_output_section_data_from_script(posd); } - output_section->add_input_section_for_script(p->relobj, - p->shndx, - p->size, - this_subalign); + output_section->add_simple_input_section(p->input_section(), + p->size(), + this_subalign); - *dot_value = address + p->size; + dot = address + p->size(); } } + // An SHF_TLS/SHT_NOBITS section does not take up any + // address space. + if (output_section == NULL + || (output_section->flags() & elfcpp::SHF_TLS) == 0 + || output_section->type() != elfcpp::SHT_NOBITS) + *dot_value = dot; + this->final_dot_value_ = *dot_value; this->final_dot_section_ = *dot_section; } @@ -1195,6 +1592,20 @@ class Output_section_definition : public Sections_element void add_input_section(const Input_section_spec* spec, bool keep); + // Return whether the output section is relro. + bool + is_relro() const + { return this->is_relro_; } + + // Record that the output section is relro. + void + set_is_relro() + { this->is_relro_ = true; } + + // Create any required output sections. + void + create_sections(Layout*); + // Add any symbols being defined to the symbol table. void add_symbols_to_table(Symbol_table* symtab); @@ -1207,11 +1618,13 @@ class Output_section_definition : public Sections_element // section name. const char* output_section_name(const char* file_name, const char* section_name, - Output_section***); + Output_section***, Script_sections::Section_type*); - // Return whether to place an orphan section after this one. - bool - place_orphan_here(const Output_section *os, bool* exact) const; + // Initialize OSP with an output section. + void + orphan_section_init(Orphan_section_placement* osp, + Script_sections::Elements_iterator p) + { osp->output_section_init(this->name_, this->output_section_, p); } // Set the section address. void @@ -1231,18 +1644,36 @@ class Output_section_definition : public Sections_element alternate_constraint(Output_section_definition*, Section_constraint); // Get the list of segments to use for an allocated section when - // using a PHDRS clause. If this is an allocated section, return - // the Output_section, and set *PHDRS_LIST to the list of PHDRS to - // which it should be attached. If the PHDRS were not specified, - // don't change *PHDRS_LIST. + // using a PHDRS clause. + Output_section* + allocate_to_segment(String_list** phdrs_list, bool* orphan); + + // Look for an output section by name and return the address, the + // load address, the alignment, and the size. This is used when an + // expression refers to an output section which was not actually + // created. This returns true if the section was found, false + // otherwise. + bool + get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*, + uint64_t*) const; + + // Return the associated Output_section if there is one. Output_section* - allocate_to_segment(String_list** phdrs_list); + get_output_section() const + { return this->output_section_; } // Print the contents to the FILE. This is for debugging. void print(FILE*) const; + // Return the output section type if specified or Script_sections::ST_NONE. + Script_sections::Section_type + section_type() const; + private: + static const char* + script_section_type_name(Script_section_type); + typedef std::vector Output_section_elements; // The output section name. @@ -1267,6 +1698,16 @@ class Output_section_definition : public Sections_element // The Output_section created for this definition. This will be // NULL if none was created. Output_section* output_section_; + // The address after it has been evaluated. + uint64_t evaluated_address_; + // The load address after it has been evaluated. + uint64_t evaluated_load_address_; + // The alignment after it has been evaluated. + uint64_t evaluated_addralign_; + // The output section is relro. + bool is_relro_; + // The output section type if specified. + enum Script_section_type script_section_type_; }; // Constructor. @@ -1284,7 +1725,12 @@ Output_section_definition::Output_section_definition( fill_(NULL), phdrs_(NULL), elements_(), - output_section_(NULL) + output_section_(NULL), + evaluated_address_(0), + evaluated_load_address_(0), + evaluated_addralign_(0), + is_relro_(false), + script_section_type_(header->section_type) { } @@ -1365,6 +1811,28 @@ Output_section_definition::add_input_section(const Input_section_spec* spec, this->elements_.push_back(p); } +// Create any required output sections. We need an output section if +// there is a data statement here. + +void +Output_section_definition::create_sections(Layout* layout) +{ + if (this->output_section_ != NULL) + return; + for (Output_section_elements::const_iterator p = this->elements_.begin(); + p != this->elements_.end(); + ++p) + { + if ((*p)->needs_output_section()) + { + const char* name = this->name_.c_str(); + this->output_section_ = + layout->make_output_section_for_script(name, this->section_type()); + return; + } + } +} + // Add any symbols being defined to the symbol table. void @@ -1391,14 +1859,14 @@ Output_section_definition::finalize_symbols(Symbol_table* symtab, if (this->address_ != NULL) { Output_section* dummy; - address = this->address_->eval_with_dot(symtab, layout, + address = this->address_->eval_with_dot(symtab, layout, true, *dot_value, NULL, &dummy); } if (this->align_ != NULL) { Output_section* dummy; - uint64_t align = this->align_->eval_with_dot(symtab, layout, + uint64_t align = this->align_->eval_with_dot(symtab, layout, true, *dot_value, NULL, &dummy); @@ -1417,9 +1885,11 @@ Output_section_definition::finalize_symbols(Symbol_table* symtab, // Return the output section name to use for an input section name. const char* -Output_section_definition::output_section_name(const char* file_name, - const char* section_name, - Output_section*** slot) +Output_section_definition::output_section_name( + const char* file_name, + const char* section_name, + Output_section*** slot, + Script_sections::Section_type *psection_type) { // Ask each element whether it matches NAME. for (Output_section_elements::const_iterator p = this->elements_.begin(); @@ -1431,6 +1901,7 @@ Output_section_definition::output_section_name(const char* file_name, // We found a match for NAME, which means that it should go // into this output section. *slot = &this->output_section_; + *psection_type = this->section_type(); return this->name_.c_str(); } } @@ -1439,121 +1910,6 @@ Output_section_definition::output_section_name(const char* file_name, return NULL; } -// Return whether to place an orphan output section after this -// section. - -bool -Output_section_definition::place_orphan_here(const Output_section *os, - bool* exact) const -{ - // Check for the simple case first. - if (this->output_section_ != NULL - && this->output_section_->type() == os->type() - && this->output_section_->flags() == os->flags()) - { - *exact = true; - return true; - } - - // Otherwise use some heuristics. - - if ((os->flags() & elfcpp::SHF_ALLOC) == 0) - return false; - - if (os->type() == elfcpp::SHT_NOBITS) - { - if (this->name_ == ".bss") - { - *exact = true; - return true; - } - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_NOBITS) - return true; - } - else if (os->type() == elfcpp::SHT_NOTE) - { - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_NOTE) - { - *exact = true; - return true; - } - if (this->name_.compare(0, 5, ".note") == 0) - { - *exact = true; - return true; - } - if (this->name_ == ".interp") - return true; - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_PROGBITS - && (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0) - return true; - } - else if (os->type() == elfcpp::SHT_REL || os->type() == elfcpp::SHT_RELA) - { - if (this->name_.compare(0, 4, ".rel") == 0) - { - *exact = true; - return true; - } - if (this->output_section_ != NULL - && (this->output_section_->type() == elfcpp::SHT_REL - || this->output_section_->type() == elfcpp::SHT_RELA)) - { - *exact = true; - return true; - } - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_PROGBITS - && (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0) - return true; - } - else if (os->type() == elfcpp::SHT_PROGBITS - && (os->flags() & elfcpp::SHF_WRITE) != 0) - { - if (this->name_ == ".data") - { - *exact = true; - return true; - } - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_PROGBITS - && (this->output_section_->flags() & elfcpp::SHF_WRITE) != 0) - return true; - } - else if (os->type() == elfcpp::SHT_PROGBITS - && (os->flags() & elfcpp::SHF_EXECINSTR) != 0) - { - if (this->name_ == ".text") - { - *exact = true; - return true; - } - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_PROGBITS - && (this->output_section_->flags() & elfcpp::SHF_EXECINSTR) != 0) - return true; - } - else if (os->type() == elfcpp::SHT_PROGBITS - || (os->type() != elfcpp::SHT_PROGBITS - && (os->flags() & elfcpp::SHF_WRITE) == 0)) - { - if (this->name_ == ".rodata") - { - *exact = true; - return true; - } - if (this->output_section_ != NULL - && this->output_section_->type() == elfcpp::SHT_PROGBITS - && (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0) - return true; - } - - return false; -} - // 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. @@ -1565,13 +1921,16 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, uint64_t* load_address) { uint64_t address; + uint64_t old_dot_value = *dot_value; + uint64_t old_load_address = *load_address; + if (this->address_ == NULL) address = *dot_value; else { Output_section* dummy; - address = this->address_->eval_with_dot(symtab, layout, *dot_value, - NULL, &dummy); + address = this->address_->eval_with_dot(symtab, layout, true, + *dot_value, NULL, &dummy); } uint64_t align; @@ -1585,7 +1944,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, else { Output_section* align_section; - align = this->align_->eval_with_dot(symtab, layout, *dot_value, + align = this->align_->eval_with_dot(symtab, layout, true, *dot_value, NULL, &align_section); if (align_section != NULL) gold_warning(_("alignment of section %s is not absolute"), @@ -1600,19 +1959,27 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, *dot_value = address; - // The address of non-SHF_ALLOC sections is forced to zero, - // regardless of what the linker script wants. + // Except for NOLOAD sections, the address of non-SHF_ALLOC sections is + // forced to zero, regardless of what the linker script wants. if (this->output_section_ != NULL - && (this->output_section_->flags() & elfcpp::SHF_ALLOC) != 0) + && ((this->output_section_->flags() & elfcpp::SHF_ALLOC) != 0 + || this->output_section_->is_noload())) this->output_section_->set_address(address); - if (this->load_address_ != NULL && this->output_section_ != NULL) + this->evaluated_address_ = address; + this->evaluated_addralign_ = align; + + if (this->load_address_ == NULL) + this->evaluated_load_address_ = address; + else { Output_section* dummy; - uint64_t load_address = - this->load_address_->eval_with_dot(symtab, layout, *dot_value, + uint64_t laddr = + this->load_address_->eval_with_dot(symtab, layout, true, *dot_value, this->output_section_, &dummy); - this->output_section_->set_load_address(load_address); + if (this->output_section_ != NULL) + this->output_section_->set_load_address(laddr); + this->evaluated_load_address_ = laddr; } uint64_t subalign; @@ -1621,8 +1988,9 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, else { Output_section* subalign_section; - subalign = this->subalign_->eval_with_dot(symtab, layout, *dot_value, - NULL, &subalign_section); + subalign = this->subalign_->eval_with_dot(symtab, layout, true, + *dot_value, NULL, + &subalign_section); if (subalign_section != NULL) gold_warning(_("subalign of section %s is not absolute"), this->name_.c_str()); @@ -1634,7 +2002,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, // FIXME: The GNU linker supports fill values of arbitrary // length. Output_section* fill_section; - uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, + uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true, *dot_value, NULL, &fill_section); @@ -1673,6 +2041,21 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, else *load_address = (this->output_section_->load_address() + (*dot_value - start_address)); + + if (this->output_section_ != NULL) + { + if (this->is_relro_) + this->output_section_->set_is_relro(); + else + this->output_section_->clear_is_relro(); + + // If this is a NOLOAD section, keep dot and load address unchanged. + if (this->output_section_->is_noload()) + { + *dot_value = old_dot_value; + *load_address = old_load_address; + } + } } // Check a constraint (ONLY_IF_RO, etc.) on an output section. If @@ -1754,27 +2137,68 @@ Output_section_definition::alternate_constraint( this->output_section_ = posd->output_section_; posd->output_section_ = NULL; + if (this->is_relro_) + this->output_section_->set_is_relro(); + else + this->output_section_->clear_is_relro(); + return true; } // Get the list of segments to use for an allocated section when using -// a PHDRS clause. If this is an allocated section, return the -// Output_section, and set *PHDRS_LIST to the list of PHDRS to which -// it should be attached. If the PHDRS were not specified, don't -// change *PHDRS_LIST. +// a PHDRS clause. Output_section* -Output_section_definition::allocate_to_segment(String_list** phdrs_list) +Output_section_definition::allocate_to_segment(String_list** phdrs_list, + bool* orphan) { if (this->output_section_ == NULL) return NULL; if ((this->output_section_->flags() & elfcpp::SHF_ALLOC) == 0) return NULL; + *orphan = false; if (this->phdrs_ != NULL) *phdrs_list = this->phdrs_; return this->output_section_; } +// Look for an output section by name and return the address, the load +// address, the alignment, and the size. This is used when an +// expression refers to an output section which was not actually +// created. This returns true if the section was found, false +// otherwise. + +bool +Output_section_definition::get_output_section_info(const char* name, + uint64_t* address, + uint64_t* load_address, + uint64_t* addralign, + uint64_t* size) const +{ + if (this->name_ != name) + return false; + + if (this->output_section_ != NULL) + { + *address = this->output_section_->address(); + if (this->output_section_->has_load_address()) + *load_address = this->output_section_->load_address(); + else + *load_address = *address; + *addralign = this->output_section_->addralign(); + *size = this->output_section_->current_data_size(); + } + else + { + *address = this->evaluated_address_; + *load_address = this->evaluated_load_address_; + *addralign = this->evaluated_addralign_; + *size = 0; + } + + return true; +} + // Print for debugging. void @@ -1788,6 +2212,10 @@ Output_section_definition::print(FILE* f) const fprintf(f, " "); } + if (this->script_section_type_ != SCRIPT_SECTION_TYPE_NONE) + fprintf(f, "(%s) ", + this->script_section_type_name(this->script_section_type_)); + fprintf(f, ": "); if (this->load_address_ != NULL) @@ -1837,6 +2265,52 @@ Output_section_definition::print(FILE* f) const fprintf(f, "\n"); } +Script_sections::Section_type +Output_section_definition::section_type() const +{ + switch (this->script_section_type_) + { + case SCRIPT_SECTION_TYPE_NONE: + return Script_sections::ST_NONE; + case SCRIPT_SECTION_TYPE_NOLOAD: + return Script_sections::ST_NOLOAD; + case SCRIPT_SECTION_TYPE_COPY: + case SCRIPT_SECTION_TYPE_DSECT: + case SCRIPT_SECTION_TYPE_INFO: + case SCRIPT_SECTION_TYPE_OVERLAY: + // There are not really support so we treat them as ST_NONE. The + // parse should have issued errors for them already. + return Script_sections::ST_NONE; + default: + gold_unreachable(); + } +} + +// Return the name of a script section type. + +const char* +Output_section_definition::script_section_type_name ( + Script_section_type script_section_type) +{ + switch (script_section_type) + { + case SCRIPT_SECTION_TYPE_NONE: + return "NONE"; + case SCRIPT_SECTION_TYPE_NOLOAD: + return "NOLOAD"; + case SCRIPT_SECTION_TYPE_DSECT: + return "DSECT"; + case SCRIPT_SECTION_TYPE_COPY: + return "COPY"; + case SCRIPT_SECTION_TYPE_INFO: + return "INFO"; + case SCRIPT_SECTION_TYPE_OVERLAY: + return "OVERLAY"; + default: + gold_unreachable(); + } +} + // An output section created to hold orphaned input sections. These // do not actually appear in linker scripts. However, for convenience // when setting the output section addresses, we put a marker to these @@ -1849,19 +2323,33 @@ class Orphan_output_section : public Sections_element : os_(os) { } - // Return whether to place an orphan section after this one. + // Return whether the orphan output section is relro. We can just + // check the output section because we always set the flag, if + // needed, just after we create the Orphan_output_section. bool - place_orphan_here(const Output_section *os, bool* exact) const; + is_relro() const + { return this->os_->is_relro(); } + + // Initialize OSP with an output section. This should have been + // done already. + void + orphan_section_init(Orphan_section_placement*, + Script_sections::Elements_iterator) + { gold_unreachable(); } // Set section addresses. void set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*); // Get the list of segments to use for an allocated section when - // using a PHDRS clause. If this is an allocated section, return - // the Output_section. + // using a PHDRS clause. Output_section* - allocate_to_segment(String_list**); + allocate_to_segment(String_list**, bool*); + + // Return the associated Output_section. + Output_section* + get_output_section() const + { return this->os_; } // Print for debugging. void @@ -1875,21 +2363,6 @@ class Orphan_output_section : public Sections_element Output_section* os_; }; -// Whether to place another orphan section after this one. - -bool -Orphan_output_section::place_orphan_here(const Output_section* os, - bool* exact) const -{ - if (this->os_->type() == os->type() - && this->os_->flags() == os->flags()) - { - *exact = true; - return true; - } - return false; -} - // Set section addresses. void @@ -1897,7 +2370,7 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, uint64_t* dot_value, uint64_t* load_address) { - typedef std::list > Input_section_list; + typedef std::list Input_section_list; bool have_load_address = *load_address != *dot_value; @@ -1922,27 +2395,37 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, uint64_t addralign; uint64_t size; - // We know what are single-threaded, so it is OK to lock the + // We know we are single-threaded, so it is OK to lock the // object. { const Task* task = reinterpret_cast(-1); - Task_lock_obj tl(task, p->first); - addralign = p->first->section_addralign(p->second); - size = p->first->section_size(p->second); + Task_lock_obj tl(task, p->relobj()); + addralign = p->relobj()->section_addralign(p->shndx()); + if (p->is_relaxed_input_section()) + // We use current data size because relxed section sizes may not + // have finalized yet. + size = p->relaxed_input_section()->current_data_size(); + else + size = p->relobj()->section_size(p->shndx()); } address = align_address(address, addralign); - this->os_->add_input_section_for_script(p->first, p->second, size, - addralign); + this->os_->add_simple_input_section(*p, size, addralign); address += size; } - if (!have_load_address) - *load_address = address; - else - *load_address += address - *dot_value; + // 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 (!have_load_address) + *load_address = address; + else + *load_address += address - *dot_value; - *dot_value = address; + *dot_value = address; + } } // Get the list of segments to use for an allocated section when using @@ -1950,10 +2433,11 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, // Output_section. We don't change the list of segments. Output_section* -Orphan_output_section::allocate_to_segment(String_list**) +Orphan_output_section::allocate_to_segment(String_list**, bool* orphan) { if ((this->os_->flags() & elfcpp::SHF_ALLOC) == 0) return NULL; + *orphan = true; return this->os_; } @@ -2002,7 +2486,8 @@ class Phdrs_element eval_load_address(Symbol_table* symtab, Layout* layout) { if (this->load_address_ != NULL) - this->load_address_value_ = this->load_address_->eval(symtab, layout); + this->load_address_value_ = this->load_address_->eval(symtab, layout, + true); } // Return the load address. @@ -2026,6 +2511,11 @@ class Phdrs_element segment() { return this->segment_; } + // Release the segment. + void + release_segment() + { this->segment_ = NULL; } + // Set the segment flags if appropriate. void set_flags_if_valid() @@ -2088,7 +2578,12 @@ Script_sections::Script_sections() in_sections_clause_(false), sections_elements_(NULL), output_section_(NULL), - phdrs_elements_(NULL) + phdrs_elements_(NULL), + orphan_section_placement_(NULL), + data_segment_align_start_(), + saw_data_segment_align_(false), + saw_relro_end_(false), + saw_segment_start_expression_(false) { } @@ -2141,6 +2636,15 @@ Script_sections::add_dot_assignment(Expression* val) this->output_section_->add_dot_assignment(val); else { + // The GNU linker permits assignments to . to appears outside of + // a SECTIONS clause, and treats it as appearing inside, so + // sections_elements_ may be NULL here. + if (this->sections_elements_ == NULL) + { + this->sections_elements_ = new Sections_elements; + this->saw_sections_clause_ = true; + } + Sections_element* p = new Sections_element_dot_assignment(val); this->sections_elements_->push_back(p); } @@ -2216,6 +2720,55 @@ Script_sections::add_input_section(const Input_section_spec* spec, bool keep) this->output_section_->add_input_section(spec, keep); } +// This is called when we see DATA_SEGMENT_ALIGN. It means that any +// subsequent output sections may be relro. + +void +Script_sections::data_segment_align() +{ + if (this->saw_data_segment_align_) + gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script")); + gold_assert(!this->sections_elements_->empty()); + Sections_elements::iterator p = this->sections_elements_->end(); + --p; + this->data_segment_align_start_ = p; + this->saw_data_segment_align_ = true; +} + +// This is called when we see DATA_SEGMENT_RELRO_END. It means that +// any output sections seen since DATA_SEGMENT_ALIGN are relro. + +void +Script_sections::data_segment_relro_end() +{ + if (this->saw_relro_end_) + gold_error(_("DATA_SEGMENT_RELRO_END may only appear once " + "in a linker script")); + this->saw_relro_end_ = true; + + if (!this->saw_data_segment_align_) + gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN")); + else + { + Sections_elements::iterator p = this->data_segment_align_start_; + for (++p; p != this->sections_elements_->end(); ++p) + (*p)->set_is_relro(); + } +} + +// Create any required sections. + +void +Script_sections::create_sections(Layout* layout) +{ + if (!this->saw_sections_clause_) + return; + for (Sections_elements::iterator p = this->sections_elements_->begin(); + p != this->sections_elements_->end(); + ++p) + (*p)->create_sections(layout); +} + // Add any symbols we are defining to the symbol table. void @@ -2247,16 +2800,19 @@ Script_sections::finalize_symbols(Symbol_table* symtab, const Layout* layout) // and section name. const char* -Script_sections::output_section_name(const char* file_name, - const char* section_name, - Output_section*** output_section_slot) +Script_sections::output_section_name( + const char* file_name, + const char* section_name, + Output_section*** output_section_slot, + Script_sections::Section_type *psection_type) { for (Sections_elements::const_iterator p = this->sections_elements_->begin(); p != this->sections_elements_->end(); ++p) { const char* ret = (*p)->output_section_name(file_name, section_name, - output_section_slot); + output_section_slot, + psection_type); if (ret != NULL) { @@ -2265,6 +2821,7 @@ Script_sections::output_section_name(const char* file_name, if (strcmp(ret, "/DISCARD/") == 0) { *output_section_slot = NULL; + *psection_type = Script_sections::ST_NONE; return NULL; } return ret; @@ -2275,6 +2832,7 @@ Script_sections::output_section_name(const char* file_name, // gets the name of the input section. *output_section_slot = NULL; + *psection_type = Script_sections::ST_NONE; return section_name; } @@ -2285,27 +2843,49 @@ Script_sections::output_section_name(const char* file_name, void Script_sections::place_orphan(Output_section* os) { - // Look for an output section definition which matches the output - // section. Put a marker after that section. - Sections_elements::iterator place = this->sections_elements_->end(); - for (Sections_elements::iterator p = this->sections_elements_->begin(); - p != this->sections_elements_->end(); - ++p) + Orphan_section_placement* osp = this->orphan_section_placement_; + if (osp == NULL) { - bool exact; - if ((*p)->place_orphan_here(os, &exact)) - { - place = p; - if (exact) - break; - } + // Initialize the Orphan_section_placement structure. + osp = new Orphan_section_placement(); + for (Sections_elements::iterator p = this->sections_elements_->begin(); + p != this->sections_elements_->end(); + ++p) + (*p)->orphan_section_init(osp, p); + gold_assert(!this->sections_elements_->empty()); + Sections_elements::iterator last = this->sections_elements_->end(); + --last; + osp->last_init(last); + this->orphan_section_placement_ = osp; } - // The insert function puts the new element before the iterator. - if (place != this->sections_elements_->end()) - ++place; + Orphan_output_section* orphan = new Orphan_output_section(os); - this->sections_elements_->insert(place, new Orphan_output_section(os)); + // Look for where to put ORPHAN. + Sections_elements::iterator* where; + if (osp->find_place(os, &where)) + { + if ((**where)->is_relro()) + os->set_is_relro(); + else + os->clear_is_relro(); + + // We want to insert ORPHAN after *WHERE, and then update *WHERE + // so that the next one goes after this one. + Sections_elements::iterator p = *where; + gold_assert(p != this->sections_elements_->end()); + ++p; + *where = this->sections_elements_->insert(p, orphan); + } + else + { + os->clear_is_relro(); + // We don't have a place to put this orphan section. Put it, + // and all other sections like it, at the end, but before the + // sections which always come at the end. + Sections_elements::iterator last = osp->last_place(); + *where = this->sections_elements_->insert(last, orphan); + } } // Set the addresses of all the output sections. Walk through all the @@ -2348,13 +2928,75 @@ Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout) } } + // Force the alignment of the first TLS section to be the maximum + // alignment of all TLS sections. + Output_section* first_tls = NULL; + uint64_t tls_align = 0; + for (Sections_elements::const_iterator p = this->sections_elements_->begin(); + p != this->sections_elements_->end(); + ++p) + { + Output_section *os = (*p)->get_output_section(); + if (os != NULL && (os->flags() & elfcpp::SHF_TLS) != 0) + { + if (first_tls == NULL) + first_tls = os; + if (os->addralign() > tls_align) + tls_align = os->addralign(); + } + } + if (first_tls != NULL) + first_tls->set_addralign(tls_align); + // For a relocatable link, we implicitly set dot to zero. uint64_t dot_value = 0; uint64_t load_address = 0; + + // Check to see if we want to use any of -Ttext, -Tdata and -Tbss options + // to set section addresses. If the script has any SEGMENT_START + // expression, we do not set the section addresses. + bool use_tsection_options = + (!this->saw_segment_start_expression_ + && (parameters->options().user_set_Ttext() + || parameters->options().user_set_Tdata() + || parameters->options().user_set_Tbss())); + for (Sections_elements::iterator p = this->sections_elements_->begin(); p != this->sections_elements_->end(); ++p) - (*p)->set_section_addresses(symtab, layout, &dot_value, &load_address); + { + 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. + if (use_tsection_options + && os != NULL + && (os->flags() & elfcpp::SHF_ALLOC) != 0) + { + uint64_t new_dot_value = dot_value; + + if (parameters->options().user_set_Ttext() + && strcmp(os->name(), ".text") == 0) + new_dot_value = parameters->options().Ttext(); + else if (parameters->options().user_set_Tdata() + && strcmp(os->name(), ".data") == 0) + new_dot_value = parameters->options().Tdata(); + else if (parameters->options().user_set_Tbss() + && strcmp(os->name(), ".bss") == 0) + new_dot_value = parameters->options().Tbss(); + + // Update dot and load address if necessary. + if (new_dot_value < dot_value) + gold_error(_("dot may not move backward")); + else if (new_dot_value != dot_value) + { + dot_value = new_dot_value; + load_address = new_dot_value; + } + } + + (*p)->set_section_addresses(symtab, layout, &dot_value, &load_address); + } if (this->phdrs_elements_ != NULL) { @@ -2406,6 +3048,12 @@ Sort_output_sections::operator()(const Output_section* os1, if (os1->type() == elfcpp::SHT_NOBITS && os2->type() == elfcpp::SHT_PROGBITS) return false; + // 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; } @@ -2430,12 +3078,12 @@ Script_sections::total_header_size(Layout* layout) const size_t segment_count = layout->segment_count(); size_t file_header_size; size_t segment_headers_size; - if (parameters->get_size() == 32) + if (parameters->target().get_size() == 32) { file_header_size = elfcpp::Elf_sizes<32>::ehdr_size; segment_headers_size = segment_count * elfcpp::Elf_sizes<32>::phdr_size; } - else if (parameters->get_size() == 64) + else if (parameters->target().get_size() == 64) { file_header_size = elfcpp::Elf_sizes<64>::ehdr_size; segment_headers_size = segment_count * elfcpp::Elf_sizes<64>::phdr_size; @@ -2455,7 +3103,7 @@ uint64_t Script_sections::header_size_adjustment(uint64_t lma, size_t sizeof_headers) const { - const uint64_t abi_pagesize = parameters->target()->abi_pagesize(); + const uint64_t abi_pagesize = parameters->target().abi_pagesize(); uint64_t hdr_lma = lma - sizeof_headers; hdr_lma &= ~(abi_pagesize - 1); return lma - hdr_lma; @@ -2470,7 +3118,7 @@ Script_sections::create_segments(Layout* layout) { gold_assert(this->saw_sections_clause_); - if (parameters->output_is_object()) + if (parameters->options().relocatable()) return NULL; if (this->saw_phdrs_clause()) @@ -2485,7 +3133,7 @@ Script_sections::create_segments(Layout* layout) this->create_note_and_tls_segments(layout, §ions); // Walk through the sections adding them to PT_LOAD segments. - const uint64_t abi_pagesize = parameters->target()->abi_pagesize(); + const uint64_t abi_pagesize = parameters->target().abi_pagesize(); Output_segment* first_seg = NULL; Output_segment* current_seg = NULL; bool is_current_seg_readonly = true; @@ -2526,7 +3174,8 @@ Script_sections::create_segments(Layout* layout) need_new_segment = true; } else if (is_current_seg_readonly - && ((*p)->flags() & elfcpp::SHF_WRITE) != 0) + && ((*p)->flags() & elfcpp::SHF_WRITE) != 0 + && !parameters->options().omagic()) { // Don't put a writable section in the same segment as a // non-writable section. @@ -2551,7 +3200,7 @@ Script_sections::create_segments(Layout* layout) is_current_seg_readonly = true; } - current_seg->add_output_section(*p, seg_flags); + current_seg->add_output_section(*p, seg_flags, false); if (((*p)->flags() & elfcpp::SHF_WRITE) != 0) is_current_seg_readonly = false; @@ -2575,38 +3224,36 @@ Script_sections::create_segments(Layout* layout) // efficient in any case. We try to use the first PT_LOAD segment // if we can, otherwise we make a new one. + if (first_seg == NULL) + return NULL; + + // -n or -N mean that the program is not demand paged and there is + // no need to put the program headers in a PT_LOAD segment. + if (parameters->options().nmagic() || parameters->options().omagic()) + return NULL; + size_t sizeof_headers = this->total_header_size(layout); - if (first_seg != NULL - && (first_seg->paddr() & (abi_pagesize - 1)) >= sizeof_headers) + uint64_t vma = first_seg->vaddr(); + uint64_t lma = first_seg->paddr(); + + uint64_t subtract = this->header_size_adjustment(lma, sizeof_headers); + + if ((lma & (abi_pagesize - 1)) >= sizeof_headers) { - first_seg->set_addresses(first_seg->vaddr() - sizeof_headers, - first_seg->paddr() - sizeof_headers); + first_seg->set_addresses(vma - subtract, lma - subtract); return first_seg; } + // If there is no room to squeeze in the headers, then punt. The + // resulting executable probably won't run on GNU/Linux, but we + // trust that the user knows what they are doing. + if (lma < subtract || vma < subtract) + return NULL; + Output_segment* load_seg = layout->make_output_segment(elfcpp::PT_LOAD, elfcpp::PF_R); - if (first_seg == NULL) - load_seg->set_addresses(0, 0); - else - { - uint64_t vma = first_seg->vaddr(); - uint64_t lma = first_seg->paddr(); - - uint64_t subtract = this->header_size_adjustment(lma, sizeof_headers); - if (lma >= subtract && vma >= subtract) - load_seg->set_addresses(vma - subtract, lma - subtract); - else - { - // We could handle this case by create the file header - // outside of any PT_LOAD segment, and creating a new - // PT_LOAD segment after the others to hold the segment - // headers. - gold_error(_("sections loaded on first page without room for " - "file and program headers are not supported")); - } - } + load_seg->set_addresses(vma - subtract, lma - subtract); return load_seg; } @@ -2632,7 +3279,7 @@ Script_sections::create_note_and_tls_segments( Layout::section_flags_to_segment((*p)->flags()); Output_segment* oseg = layout->make_output_segment(elfcpp::PT_NOTE, seg_flags); - oseg->add_output_section(*p, seg_flags); + oseg->add_output_section(*p, seg_flags, false); // Incorporate any subsequent SHT_NOTE sections, in the // hopes that the script is sensible. @@ -2641,7 +3288,7 @@ Script_sections::create_note_and_tls_segments( && (*pnext)->type() == elfcpp::SHT_NOTE) { seg_flags = Layout::section_flags_to_segment((*pnext)->flags()); - oseg->add_output_section(*pnext, seg_flags); + oseg->add_output_section(*pnext, seg_flags, false); p = pnext; ++pnext; } @@ -2656,14 +3303,14 @@ Script_sections::create_note_and_tls_segments( Layout::section_flags_to_segment((*p)->flags()); Output_segment* oseg = layout->make_output_segment(elfcpp::PT_TLS, seg_flags); - oseg->add_output_section(*p, seg_flags); + oseg->add_output_section(*p, seg_flags, false); Layout::Section_list::const_iterator pnext = p + 1; while (pnext != sections->end() && ((*pnext)->flags() & elfcpp::SHF_TLS) != 0) { seg_flags = Layout::section_flags_to_segment((*pnext)->flags()); - oseg->add_output_section(*pnext, seg_flags); + oseg->add_output_section(*pnext, seg_flags, false); p = pnext; ++pnext; } @@ -2675,7 +3322,7 @@ Script_sections::create_note_and_tls_segments( // Add a program header. The PHDRS clause is syntactically distinct // from the SECTIONS clause, but we implement it with the SECTIONS -// support becauase PHDRS is useless if there is no SECTIONS clause. +// support because PHDRS is useless if there is no SECTIONS clause. void Script_sections::add_phdr(const char* name, size_t namelen, unsigned int type, @@ -2764,12 +3411,16 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) // 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) { - Output_section* os = (*p)->allocate_to_segment(&phdr_names); + bool orphan; + String_list* old_phdr_names = phdr_names; + Output_section* os = (*p)->allocate_to_segment(&phdr_names, &orphan); if (os == NULL) continue; @@ -2779,6 +3430,24 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) continue; } + // We see a list of segments names. Disable PT_LOAD segment only + // 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) + { + // Enable PT_LOAD segments only filtering until we see another + // list of segment names. + load_segments_only = true; + } + bool in_load_segment = false; for (String_list::const_iterator q = phdr_names->begin(); q != phdr_names->end(); @@ -2789,9 +3458,13 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) gold_error(_("no segment %s"), q->c_str()); else { + if (load_segments_only + && r->second->type() != elfcpp::PT_LOAD) + continue; + elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(os->flags()); - r->second->add_output_section(os, seg_flags); + r->second->add_output_section(os, seg_flags, false); if (r->second->type() == elfcpp::PT_LOAD) { @@ -2920,6 +3593,44 @@ Script_sections::put_headers_in_phdrs(Output_data* file_header, } } +// Look for an output section by name and return the address, the load +// address, the alignment, and the size. This is used when an +// expression refers to an output section which was not actually +// created. This returns true if the section was found, false +// otherwise. + +bool +Script_sections::get_output_section_info(const char* name, uint64_t* address, + uint64_t* load_address, + uint64_t* addralign, + uint64_t* size) const +{ + if (!this->saw_sections_clause_) + return false; + for (Sections_elements::const_iterator p = this->sections_elements_->begin(); + p != this->sections_elements_->end(); + ++p) + if ((*p)->get_output_section_info(name, address, load_address, addralign, + size)) + return true; + return false; +} + +// Release all Output_segments. This remove all pointers to all +// Output_segments. + +void +Script_sections::release_segments() +{ + if (this->saw_phdrs_clause()) + { + for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin(); + p != this->phdrs_elements_->end(); + ++p) + (*p)->release_segment(); + } +} + // Print the SECTIONS clause to F for debugging. void