const char* file_name = relobj == NULL ? NULL : relobj->name().c_str();
Output_section** output_section_slot;
Script_sections::Section_type script_section_type;
+ const char* orig_name = name;
name = ss->output_section_name(file_name, name, &output_section_slot,
&script_section_type);
if (name == NULL)
{
+ gold_debug(DEBUG_SCRIPT, _("Unable to create output section '%s' "
+ "because it is not allowed by the "
+ "SECTIONS clause of the linker script"),
+ orig_name);
// The SECTIONS clause says to discard this input section.
return NULL;
}
bool is_address_set = parameters->options().section_start(os->name(), &addr);
// In general the only thing we really care about for PT_LOAD
- // segments is whether or not they are writable, so that is how we
- // search for them. Large data sections also go into their own
- // PT_LOAD segment. People who need segments sorted on some other
- // basis will have to use a linker script.
+ // segments is whether or not they are writable or executable,
+ // so that is how we search for them.
+ // Large data sections also go into their own PT_LOAD segment.
+ // People who need segments sorted on some other basis will
+ // have to use a linker script.
Segment_list::const_iterator p;
for (p = this->segment_list_.begin();
if (!parameters->options().omagic()
&& ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W))
continue;
+ if (parameters->options().rosegment()
+ && ((*p)->flags() & elfcpp::PF_X) != (seg_flags & elfcpp::PF_X))
+ continue;
// If -Tbss was specified, we need to separate the data and BSS
// segments.
if (parameters->options().user_set_Tbss())
Output_segment*
Layout::find_first_load_seg()
{
+ Output_segment* best = NULL;
for (Segment_list::const_iterator p = this->segment_list_.begin();
p != this->segment_list_.end();
++p)
&& ((*p)->flags() & elfcpp::PF_R) != 0
&& (parameters->options().omagic()
|| ((*p)->flags() & elfcpp::PF_W) == 0))
- return *p;
+ {
+ if (best == NULL || this->segment_precedes(*p, best))
+ best = *p;
+ }
}
+ if (best != NULL)
+ return best;
gold_assert(!this->script_options_->saw_phdrs_clause());
std::string desc = std::string("gold ") + gold::get_version_string();
size_t trailing_padding;
- Output_section *os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
+ Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
".note.gnu.gold-version", desc.size(),
false, &trailing_padding);
if (os == NULL)
incr->create_data_sections(symtab);
// Add the .gnu_incremental_inputs section.
- const char *incremental_inputs_name =
+ const char* incremental_inputs_name =
this->namepool_.add(".gnu_incremental_inputs", false, NULL);
Output_section* incremental_inputs_os =
this->make_output_section(incremental_inputs_name,
incremental_inputs_os->add_output_section_data(incr->inputs_section());
// Add the .gnu_incremental_symtab section.
- const char *incremental_symtab_name =
+ const char* incremental_symtab_name =
this->namepool_.add(".gnu_incremental_symtab", false, NULL);
Output_section* incremental_symtab_os =
this->make_output_section(incremental_symtab_name,
incremental_symtab_os->set_entsize(4);
// Add the .gnu_incremental_relocs section.
- const char *incremental_relocs_name =
+ const char* incremental_relocs_name =
this->namepool_.add(".gnu_incremental_relocs", false, NULL);
Output_section* incremental_relocs_os =
this->make_output_section(incremental_relocs_name,
incremental_relocs_os->add_output_section_data(incr->relocs_section());
incremental_relocs_os->set_entsize(incr->relocs_entsize());
+ // Add the .gnu_incremental_got_plt section.
+ const char* incremental_got_plt_name =
+ this->namepool_.add(".gnu_incremental_got_plt", false, NULL);
+ Output_section* incremental_got_plt_os =
+ this->make_output_section(incremental_got_plt_name,
+ elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT, 0,
+ ORDER_INVALID, false);
+ incremental_got_plt_os->add_output_section_data(incr->got_plt_section());
+
// Add the .gnu_incremental_strtab section.
- const char *incremental_strtab_name =
+ const char* incremental_strtab_name =
this->namepool_.add(".gnu_incremental_strtab", false, NULL);
Output_section* incremental_strtab_os = this->make_output_section(incremental_strtab_name,
elfcpp::SHT_STRTAB, 0,
incremental_inputs_os->set_after_input_sections();
incremental_symtab_os->set_after_input_sections();
incremental_relocs_os->set_after_input_sections();
+ incremental_got_plt_os->set_after_input_sections();
incremental_inputs_os->set_link_section(incremental_strtab_os);
incremental_symtab_os->set_link_section(incremental_inputs_os);
incremental_relocs_os->set_link_section(incremental_inputs_os);
+ incremental_got_plt_os->set_link_section(incremental_inputs_os);
}
// Return whether SEG1 should be before SEG2 in the output file. This
if (section_count1 > 0 && section_count2 == 0)
return false;
- uint64_t paddr1 = seg1->first_section_load_address();
- uint64_t paddr2 = seg2->first_section_load_address();
+ uint64_t paddr1 = (seg1->are_addresses_set()
+ ? seg1->paddr()
+ : seg1->first_section_load_address());
+ uint64_t paddr2 = (seg2->are_addresses_set()
+ ? seg2->paddr()
+ : seg2->first_section_load_address());
+
if (paddr1 != paddr2)
return paddr1 < paddr2;
}
off_t
Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
- unsigned int *pshndx)
+ unsigned int* pshndx)
{
// Sort them into the final order.
std::sort(this->segment_list_.begin(), this->segment_list_.end(),
const bool check_sections = parameters->options().check_sections();
Output_segment* last_load_segment = NULL;
- bool was_readonly = false;
for (Segment_list::iterator p = this->segment_list_.begin();
p != this->segment_list_.end();
++p)
if (!are_addresses_set)
{
- // If the last segment was readonly, and this one is
- // not, then skip the address forward one page,
- // maintaining the same position within the page. This
- // lets us store both segments overlapping on a single
- // page in the file, but the loader will put them on
- // different pages in memory.
+ // Skip the address forward one page, maintaining the same
+ // position within the page. This lets us store both segments
+ // overlapping on a single page in the file, but the loader will
+ // put them on different pages in memory. We will revisit this
+ // decision once we know the size of the segment.
addr = align_address(addr, (*p)->maximum_alignment());
aligned_addr = addr;
- if (was_readonly && ((*p)->flags() & elfcpp::PF_W) != 0)
- {
- if ((addr & (abi_pagesize - 1)) != 0)
- addr = addr + abi_pagesize;
- }
+ if ((addr & (abi_pagesize - 1)) != 0)
+ addr = addr + abi_pagesize;
off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
}
addr = new_addr;
- if (((*p)->flags() & elfcpp::PF_W) == 0)
- was_readonly = true;
-
// Implement --check-sections. We know that the segments
// are sorted by LMA.
if (check_sections && last_load_segment != NULL)
off_t
Layout::set_relocatable_section_offsets(Output_data* file_header,
- unsigned int *pshndx)
+ unsigned int* pshndx)
{
off_t off = 0;
void
Layout::create_dynamic_symtab(const Input_objects* input_objects,
Symbol_table* symtab,
- Output_section **pdynstr,
+ Output_section** pdynstr,
unsigned int* plocal_dynamic_count,
std::vector<Symbol*>* pdynamic_symbols,
Versions* pversions)
if (is_compressed_debug_section(name))
{
size_t len = strlen(name);
- char *uncompressed_name = new char[len];
+ char* uncompressed_name = new char[len];
uncompressed_name[0] = '.';
gold_assert(name[0] == '.' && name[1] == 'z');
strncpy(&uncompressed_name[1], &name[2], len - 2);