X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Fscript-sections.cc;h=c42827f4f094f3ea2f6b6b94a1b264a40aa97439;hb=1704fca7dab2f0c1d64ccdade61275de4ef41e94;hp=57e5279dd2a1bb4c73e8f4be8ea742ca8bc3e56f;hpb=eb3730490ec71b6e8a9d63a0348b40d484041db5;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/script-sections.cc b/gold/script-sections.cc index 57e5279dd2..c42827f4f0 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-2016 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -93,7 +93,23 @@ class Memory_region script_exp_binary_add(this->start_, script_exp_integer(this->current_offset_)); } - + + void + set_address(uint64_t addr, const Symbol_table* symtab, const Layout* layout) + { + 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_offset(std::string section_name, uint64_t amount, const Symbol_table* symtab, const Layout* layout) @@ -105,7 +121,7 @@ class Memory_region gold_error(_("section %s overflows end of region %s"), 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 @@ -120,7 +136,7 @@ class Memory_region // 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) { @@ -582,7 +598,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*) { return NULL; } // Initialize OSP with an output section. @@ -592,7 +608,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*) @@ -680,7 +696,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. @@ -714,7 +730,7 @@ class Sections_element_dot_assignment : public Sections_element // output section definition the dot symbol is always considered // to be absolute. *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value, - NULL, NULL, NULL); + NULL, NULL, NULL, false); } // Update the dot symbol while setting section addresses. @@ -724,7 +740,7 @@ class Sections_element_dot_assignment : public Sections_element uint64_t* load_address) { *dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value, - NULL, NULL, dot_alignment); + NULL, NULL, dot_alignment, false); *load_address = *dot_value; } @@ -800,11 +816,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*, @@ -866,9 +882,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. @@ -892,20 +910,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 @@ -936,7 +962,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) @@ -1037,7 +1064,8 @@ Output_data_expression::do_write_to_buffer(unsigned char* buf) { uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_, true, this->dot_value_, - this->dot_section_, NULL, NULL); + this->dot_section_, NULL, NULL, + false); if (parameters->target().is_big_endian()) this->endian_write_to_buffer(val, buf); @@ -1187,7 +1215,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. @@ -1226,10 +1254,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 @@ -1381,15 +1409,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; @@ -1441,7 +1473,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 @@ -1539,9 +1576,33 @@ 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) + 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 (input_pattern_count == 0 || !any_patterns_with_sort) input_pattern_count = 1; Matching_sections matching_sections(input_pattern_count); @@ -1604,6 +1665,8 @@ Output_section_element_input::set_section_addresses( ++p; else { + if (!any_patterns_with_sort) + i = 0; matching_sections[i].push_back(isi); p = input_sections->erase(p); } @@ -1849,7 +1912,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*); // Initialize OSP with an output section. void @@ -2108,13 +2172,13 @@ Output_section_definition::finalize_symbols(Symbol_table* symtab, { address = this->address_->eval_with_dot(symtab, layout, true, *dot_value, NULL, - NULL, NULL); + NULL, NULL, false); } if (this->align_ != NULL) { uint64_t align = this->align_->eval_with_dot(symtab, layout, true, *dot_value, NULL, - NULL, NULL); + NULL, NULL, false); address = align_address(address, align); } *dot_value = address; @@ -2134,14 +2198,15 @@ 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) { // 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. @@ -2188,6 +2253,7 @@ 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) @@ -2233,14 +2299,18 @@ Script_sections::find_memory_region( } } - // 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 - && (*mr)->attributes_compatible(out_sec->flags(), - out_sec->type())) - first_match = *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 @@ -2275,6 +2345,15 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, uint64_t old_dot_value = *dot_value; uint64_t old_load_address = *load_address; + // 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, @@ -2291,8 +2370,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, ; else if (this->address_ == NULL) { - vma_region = script_sections->find_memory_region(this, true, NULL); - + 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); @@ -2300,9 +2378,15 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, address = *dot_value; } else - address = this->address_->eval_with_dot(symtab, layout, true, - *dot_value, NULL, NULL, - dot_alignment); + { + 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; if (this->align_ == NULL) { @@ -2315,7 +2399,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()); @@ -2346,7 +2430,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, 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, + lma_region = script_sections->find_memory_region(this, false, false, &previous_section); if (lma_region != NULL) @@ -2400,7 +2484,7 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, laddr = this->load_address_->eval_with_dot(symtab, layout, true, *dot_value, this->output_section_, - NULL, NULL); + NULL, NULL, false); if (this->output_section_ != NULL) this->output_section_->set_load_address(laddr); } @@ -2415,7 +2499,8 @@ Output_section_definition::set_section_addresses(Symbol_table* symtab, Output_section* subalign_section; subalign = this->subalign_->eval_with_dot(symtab, layout, true, *dot_value, NULL, - &subalign_section, NULL); + &subalign_section, NULL, + false); if (subalign_section != NULL) gold_warning(_("subalign of section %s is not absolute"), this->name_.c_str()); @@ -2430,7 +2515,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()); @@ -2845,6 +2930,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); @@ -2869,11 +2974,17 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, 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 @@ -3119,7 +3230,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) { } @@ -3340,7 +3452,8 @@ 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) { for (Sections_elements::const_iterator p = this->sections_elements_->begin(); p != this->sections_elements_->end(); @@ -3348,7 +3461,7 @@ Script_sections::output_section_name( { const char* ret = (*p)->output_section_name(file_name, section_name, output_section_slot, - psection_type); + psection_type, keep); if (ret != NULL) { @@ -3560,8 +3673,8 @@ class Sort_output_sections operator()(const Output_section* os1, const Output_section* os2) const; private: - bool - is_before(const Output_section* os1, const Output_section* os2) const; + int + script_compare(const Output_section* os1, const Output_section* os2) const; private: const Script_sections::Sections_elements* elements_; @@ -3585,55 +3698,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; - - // The sections have the same address. Check the section positions - // in accordance with the linker script. - return this->is_before(os1, os2); + + // The sections seem practically identical. Sort by name to get a + // stable sort. + return os1->name() < os2->name(); } -// Return true if OS1 comes before OS2 in ELEMENTS_. This ensures -// that we keep empty sections in the order in which they appear in a -// linker script. +// 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. -bool -Sort_output_sections::is_before(const Output_section* os1, - const Output_section* os2) const +int +Sort_output_sections::script_compare(const Output_section* os1, + const Output_section* os2) const { if (this->elements_ == NULL) - return false; + 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 (os1 == (*p)->get_output_section()) + if (os2 == (*p)->get_output_section()) { - for (++p; p != this->elements_->end(); ++p) - if (os2 == (*p)->get_output_section()) - return true; - break; + if (found_os1) + return -1; + found_os2 = true; + } + else if (os1 == (*p)->get_output_section()) + { + if (found_os2) + return 1; + found_os1 = true; } } - return false; + return 0; } // Return whether OS is a BSS section. This is a SHT_NOBITS section. @@ -3672,7 +3800,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. @@ -3909,7 +4037,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 @@ -3937,6 +4079,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(); @@ -3948,6 +4094,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) @@ -3971,6 +4118,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; @@ -3999,6 +4155,7 @@ 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 @@ -4011,15 +4168,37 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) 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; } @@ -4034,7 +4213,7 @@ Script_sections::attach_sections_using_phdrs_clause(Layout* layout) // 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. @@ -4055,9 +4234,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