// layout.cc -- lay out output file sections for gold
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
-// Free Software Foundation, Inc.
+// Copyright (C) 2006-2021 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include "libiberty.h"
#include "md5.h"
#include "sha1.h"
+#ifdef __MINGW32__
+#include <windows.h>
+#include <rpcdce.h>
+#endif
#include "parameters.h"
#include "options.h"
program_name, Free_list::num_allocate_visits);
}
+// A Hash_task computes the MD5 checksum of an array of char.
+
+class Hash_task : public Task
+{
+ public:
+ Hash_task(Output_file* of,
+ size_t offset,
+ size_t size,
+ unsigned char* dst,
+ Task_token* final_blocker)
+ : of_(of), offset_(offset), size_(size), dst_(dst),
+ final_blocker_(final_blocker)
+ { }
+
+ void
+ run(Workqueue*)
+ {
+ const unsigned char* iv =
+ this->of_->get_input_view(this->offset_, this->size_);
+ md5_buffer(reinterpret_cast<const char*>(iv), this->size_, this->dst_);
+ this->of_->free_input_view(this->offset_, this->size_, iv);
+ }
+
+ Task_token*
+ is_runnable()
+ { return NULL; }
+
+ // Unblock FINAL_BLOCKER_ when done.
+ void
+ locks(Task_locker* tl)
+ { tl->add(this, this->final_blocker_); }
+
+ std::string
+ get_name() const
+ { return "Hash_task"; }
+
+ private:
+ Output_file* of_;
+ const size_t offset_;
+ const size_t size_;
+ unsigned char* const dst_;
+ Task_token* const final_blocker_;
+};
+
// Layout::Relaxation_debug_check methods.
// Check that sections and special data are in reset states.
void
Layout::Relaxation_debug_check::check_output_data_for_reset_values(
const Layout::Section_list& sections,
- const Layout::Data_list& special_outputs)
+ const Layout::Data_list& special_outputs,
+ const Layout::Data_list& relax_outputs)
{
for(Layout::Section_list::const_iterator p = sections.begin();
p != sections.end();
p != special_outputs.end();
++p)
gold_assert((*p)->address_and_file_offset_have_reset_values());
+
+ gold_assert(relax_outputs.empty());
}
// Save information of SECTIONS for checking later.
section_list_(),
unattached_section_list_(),
special_output_list_(),
+ relax_output_list_(),
section_headers_(NULL),
tls_segment_(NULL),
relro_segment_(NULL),
unique_segment_for_sections_specified_(false),
incremental_inputs_(NULL),
record_output_section_data_from_script_(false),
+ lto_slim_object_(false),
script_output_section_data_list_(),
segment_states_(NULL),
relaxation_debug_check_(NULL),
input_section_position_(),
input_section_glob_(),
incremental_base_(NULL),
- free_list_()
+ free_list_(),
+ gnu_properties_()
{
// Make space for more than enough segments for a typical file.
// This is just for efficiency--it's OK if we wind up needing more.
"addr", // Fission extension
// "aranges", // not used by gdb as of 7.4
"frame",
+ "gdb_scripts",
"info",
"types",
"line",
"macro",
// "pubnames", // not used by gdb as of 7.4
// "pubtypes", // not used by gdb as of 7.4
+ // "gnu_pubnames", // Fission extension
+ // "gnu_pubtypes", // Fission extension
"ranges",
"str",
+ "str_offsets",
};
// This is the minimum set of sections needed for line numbers.
// "addr", // Fission extension
// "aranges", // not used by gdb as of 7.4
// "frame",
+ // "gdb_scripts",
"info",
// "types",
"line",
// "macro",
// "pubnames", // not used by gdb as of 7.4
// "pubtypes", // not used by gdb as of 7.4
+ // "gnu_pubnames", // Fission extension
+ // "gnu_pubtypes", // Fission extension
// "ranges",
"str",
+ "str_offsets", // Fission extension
};
// These sections are the DWARF fast-lookup tables, and are not needed
{
"aranges",
"pubnames",
+ "gnu_pubnames",
"pubtypes",
+ "gnu_pubtypes",
};
// Returns whether the given debug section is in the list of
return (is_prefix_of(".zdebug", secname));
}
+std::string
+corresponding_uncompressed_section_name(std::string secname)
+{
+ gold_assert(secname[0] == '.' && secname[1] == 'z');
+ std::string ret(".");
+ ret.append(secname, 2, std::string::npos);
+ return ret;
+}
+
// Whether to include this section in the link.
template<int size, bool big_endian>
&& (shdr.get_sh_flags() & elfcpp::SHF_EXCLUDE))
return false;
- switch (shdr.get_sh_type())
+ elfcpp::Elf_Word sh_type = shdr.get_sh_type();
+
+ if ((sh_type >= elfcpp::SHT_LOOS && sh_type <= elfcpp::SHT_HIOS)
+ || (sh_type >= elfcpp::SHT_LOPROC && sh_type <= elfcpp::SHT_HIPROC))
+ return parameters->target().should_include_section(sh_type);
+
+ switch (sh_type)
{
case elfcpp::SHT_NULL:
case elfcpp::SHT_SYMTAB:
bool keep;
name = ss->output_section_name(file_name, name, &output_section_slot,
- &script_section_type, &keep);
+ &script_section_type, &keep, true);
return name != NULL && keep;
}
// copied to the output section.
input_section_flags &= ~ (elfcpp::SHF_INFO_LINK
| elfcpp::SHF_GROUP
+ | elfcpp::SHF_COMPRESSED
| elfcpp::SHF_MERGE
| elfcpp::SHF_STRINGS);
// choosing an output section for an input section found in a input
// file. ORDER is where this section should appear in the output
// sections. IS_RELRO is true for a relro section. This will return
-// NULL if the input section should be discarded.
+// NULL if the input section should be discarded. MATCH_INPUT_SPEC
+// is true if the section name should be matched against input specs
+// in a linker script.
Output_section*
Layout::choose_output_section(const Relobj* relobj, const char* name,
elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
bool is_input_section, Output_section_order order,
- bool is_relro)
+ bool is_relro, bool is_reloc,
+ bool match_input_spec)
{
// We should not see any input sections after we have attached
// sections to segments.
flags = this->get_output_section_flags(flags);
- if (this->script_options_->saw_sections_clause())
+ if (this->script_options_->saw_sections_clause() && !is_reloc)
{
// We are using a SECTIONS clause, so the output section is
// chosen based only on the name.
const char* orig_name = name;
bool keep;
name = ss->output_section_name(file_name, name, &output_section_slot,
- &script_section_type, &keep);
+ &script_section_type, &keep,
+ match_input_spec);
if (name == NULL)
{
// FIXME: Handle SHF_OS_NONCONFORMING somewhere.
size_t len = strlen(name);
- char* uncompressed_name = NULL;
+ std::string uncompressed_name;
// Compressed debug sections should be mapped to the corresponding
// uncompressed section.
if (is_compressed_debug_section(name))
{
- uncompressed_name = new char[len];
- uncompressed_name[0] = '.';
- gold_assert(name[0] == '.' && name[1] == 'z');
- strncpy(&uncompressed_name[1], &name[2], len - 2);
- uncompressed_name[len - 1] = '\0';
- len -= 1;
- name = uncompressed_name;
+ uncompressed_name =
+ corresponding_uncompressed_section_name(std::string(name, len));
+ name = uncompressed_name.c_str();
+ len = uncompressed_name.length();
}
// Turn NAME from the name of the input section into the name of the
Stringpool::Key name_key;
name = this->namepool_.add_with_length(name, len, true, &name_key);
- if (uncompressed_name != NULL)
- delete[] uncompressed_name;
-
// Find or make the output section. The output section is selected
// based on the section name, type, and flags.
return this->get_output_section(name, name_key, type, flags, order, is_relro);
typename elfcpp::Elf_types<size>::Elf_Addr sh_addr = shdr.get_sh_addr();
typename elfcpp::Elf_types<size>::Elf_Off sh_offset = shdr.get_sh_offset();
typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size();
- typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
+ typename elfcpp::Elf_types<size>::Elf_WXword sh_flags =
+ this->get_output_section_flags(shdr.get_sh_flags());
typename elfcpp::Elf_types<size>::Elf_WXword sh_addralign =
shdr.get_sh_addralign();
// wind up in the .text section. Sections that start with these
// prefixes must appear first, and must appear in the order listed
// here.
- static const char* const text_section_sort[] =
+ static const char* const text_section_sort[] =
{
".text.unlikely",
".text.exit",
".text.startup",
- ".text.hot"
+ ".text.hot",
+ ".text.sorted"
};
for (size_t i = 0;
Output_section*
Layout::layout(Sized_relobj_file<size, big_endian>* object, unsigned int shndx,
const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
- unsigned int reloc_shndx, unsigned int, off_t* off)
+ unsigned int sh_type, unsigned int reloc_shndx,
+ unsigned int, off_t* off)
{
*off = 0;
if (!this->include_section(object, name, shdr))
return NULL;
- elfcpp::Elf_Word sh_type = shdr.get_sh_type();
-
// In a relocatable link a grouped section must not be combined with
// any other sections.
Output_section* os;
if (parameters->options().relocatable()
&& (shdr.get_sh_flags() & elfcpp::SHF_GROUP) != 0)
{
+ // Some flags in the input section should not be automatically
+ // copied to the output section.
+ elfcpp::Elf_Xword sh_flags = (shdr.get_sh_flags()
+ & ~ elfcpp::SHF_COMPRESSED);
name = this->namepool_.add(name, true, NULL);
- os = this->make_output_section(name, sh_type, shdr.get_sh_flags(),
- ORDER_INVALID, false);
+ os = this->make_output_section(name, sh_type, sh_flags, ORDER_INVALID,
+ false);
}
else
{
- // Plugins can choose to place one or more subsets of sections in
- // unique segments and this is done by mapping these section subsets
- // to unique output sections. Check if this section needs to be
- // remapped to a unique output section.
- Section_segment_map::iterator it
- = this->section_segment_map_.find(Const_section_id(object, shndx));
- if (it == this->section_segment_map_.end())
+ // Get the section flags and mask out any flags that do not
+ // take part in section matching.
+ elfcpp::Elf_Xword sh_flags
+ = (this->get_output_section_flags(shdr.get_sh_flags())
+ & ~object->osabi().ignored_sh_flags());
+
+ // All ".text.unlikely.*" sections can be moved to a unique
+ // segment with --text-unlikely-segment option.
+ bool text_unlikely_segment
+ = (parameters->options().text_unlikely_segment()
+ && is_prefix_of(".text.unlikely",
+ object->section_name(shndx).c_str()));
+ if (text_unlikely_segment)
{
- os = this->choose_output_section(object, name, sh_type,
- shdr.get_sh_flags(), true,
- ORDER_INVALID, false);
+ Stringpool::Key name_key;
+ const char* os_name = this->namepool_.add(".text.unlikely", true,
+ &name_key);
+ os = this->get_output_section(os_name, name_key, sh_type, sh_flags,
+ ORDER_INVALID, false);
+ // Map this output section to a unique segment. This is done to
+ // separate "text" that is not likely to be executed from "text"
+ // that is likely executed.
+ os->set_is_unique_segment();
}
else
{
- // We know the name of the output section, directly call
- // get_output_section here by-passing choose_output_section.
- elfcpp::Elf_Xword flags
- = this->get_output_section_flags(shdr.get_sh_flags());
-
- const char* os_name = it->second->name;
- Stringpool::Key name_key;
- os_name = this->namepool_.add(os_name, true, &name_key);
- os = this->get_output_section(os_name, name_key, sh_type, flags,
- ORDER_INVALID, false);
- if (!os->is_unique_segment())
+ // Plugins can choose to place one or more subsets of sections in
+ // unique segments and this is done by mapping these section subsets
+ // to unique output sections. Check if this section needs to be
+ // remapped to a unique output section.
+ Section_segment_map::iterator it
+ = this->section_segment_map_.find(Const_section_id(object, shndx));
+ if (it == this->section_segment_map_.end())
{
- os->set_is_unique_segment();
- os->set_extra_segment_flags(it->second->flags);
- os->set_segment_alignment(it->second->align);
+ os = this->choose_output_section(object, name, sh_type,
+ sh_flags, true, ORDER_INVALID,
+ false, false, true);
}
- }
+ else
+ {
+ // We know the name of the output section, directly call
+ // get_output_section here by-passing choose_output_section.
+ const char* os_name = it->second->name;
+ Stringpool::Key name_key;
+ os_name = this->namepool_.add(os_name, true, &name_key);
+ os = this->get_output_section(os_name, name_key, sh_type,
+ sh_flags, ORDER_INVALID, false);
+ if (!os->is_unique_segment())
+ {
+ os->set_is_unique_segment();
+ os->set_extra_segment_flags(it->second->flags);
+ os->set_segment_alignment(it->second->align);
+ }
+ }
+ }
if (os == NULL)
return NULL;
}
Layout::insert_section_segment_map(Const_section_id secn,
Unique_segment_info *s)
{
- gold_assert(this->unique_segment_for_sections_specified_);
+ gold_assert(this->unique_segment_for_sections_specified_);
this->section_segment_map_[secn] = s;
}
template<int size, bool big_endian>
Output_section*
-Layout::layout_reloc(Sized_relobj_file<size, big_endian>* object,
+Layout::layout_reloc(Sized_relobj_file<size, big_endian>*,
unsigned int,
const elfcpp::Shdr<size, big_endian>& shdr,
Output_section* data_section,
gold_unreachable();
name += data_section->name();
- // In a relocatable link relocs for a grouped section must not be
- // combined with other reloc sections.
- Output_section* os;
- if (!parameters->options().relocatable()
- || (data_section->flags() & elfcpp::SHF_GROUP) == 0)
- os = this->choose_output_section(object, name.c_str(), sh_type,
- shdr.get_sh_flags(), false,
- ORDER_INVALID, false);
- else
+ // If the output data section already has a reloc section, use that;
+ // otherwise, make a new one.
+ Output_section* os = data_section->reloc_section();
+ if (os == NULL)
{
const char* n = this->namepool_.add(name.c_str(), true, NULL);
os = this->make_output_section(n, sh_type, shdr.get_sh_flags(),
ORDER_INVALID, false);
+ os->set_should_link_to_symtab();
+ os->set_info_section(data_section);
+ data_section->set_reloc_section(os);
}
- os->set_should_link_to_symtab();
- os->set_info_section(data_section);
-
Output_section_data* posd;
if (sh_type == elfcpp::SHT_REL)
{
unsigned int reloc_shndx, unsigned int reloc_type,
off_t* off)
{
+ const unsigned int unwind_section_type =
+ parameters->target().unwind_section_type();
+
gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS
- || shdr.get_sh_type() == elfcpp::SHT_X86_64_UNWIND);
+ || shdr.get_sh_type() == unwind_section_type);
gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
Output_section* os = this->make_eh_frame_section(object);
elfcpp::Elf_Xword orig_flags = os->flags();
- if (!parameters->incremental()
- && this->eh_frame_data_->add_ehframe_input_section(object,
- symbols,
- symbols_size,
- symbol_names,
- symbol_names_size,
- shndx,
- reloc_shndx,
- reloc_type))
+ Eh_frame::Eh_frame_section_disposition disp =
+ Eh_frame::EH_UNRECOGNIZED_SECTION;
+ if (!parameters->incremental())
+ {
+ disp = this->eh_frame_data_->add_ehframe_input_section(object,
+ symbols,
+ symbols_size,
+ symbol_names,
+ symbol_names_size,
+ shndx,
+ reloc_shndx,
+ reloc_type);
+ }
+
+ if (disp == Eh_frame::EH_OPTIMIZABLE_SECTION)
{
os->update_flags_for_input_section(shdr.get_sh_flags());
os->set_order(ORDER_RELRO);
}
- // We found a .eh_frame section we are going to optimize, so now
- // we can add the set of optimized sections to the output
- // section. We need to postpone adding this until we've found a
- // section we can optimize so that the .eh_frame section in
- // crtbegin.o winds up at the start of the output section.
- if (!this->added_eh_frame_data_)
- {
- os->add_output_section_data(this->eh_frame_data_);
- this->added_eh_frame_data_ = true;
- }
*off = -1;
+ return os;
}
- else
+
+ if (disp == Eh_frame::EH_END_MARKER_SECTION && !this->added_eh_frame_data_)
{
- // We couldn't handle this .eh_frame section for some reason.
- // Add it as a normal section.
- bool saw_sections_clause = this->script_options_->saw_sections_clause();
- *off = os->add_input_section(this, object, shndx, ".eh_frame", shdr,
- reloc_shndx, saw_sections_clause);
- this->have_added_input_section_ = true;
+ // We found the end marker section, so now we can add the set of
+ // optimized sections to the output section. We need to postpone
+ // adding this until we've found a section we can optimize so that
+ // the .eh_frame section in crtbeginT.o winds up at the start of
+ // the output section.
+ os->add_output_section_data(this->eh_frame_data_);
+ this->added_eh_frame_data_ = true;
+ }
- if ((orig_flags & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR))
- != (os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR)))
- os->set_order(this->default_section_order(os, false));
- }
+ // We couldn't handle this .eh_frame section for some reason.
+ // Add it as a normal section.
+ bool saw_sections_clause = this->script_options_->saw_sections_clause();
+ *off = os->add_input_section(this, object, shndx, ".eh_frame", shdr,
+ reloc_shndx, saw_sections_clause);
+ this->have_added_input_section_ = true;
+
+ if ((orig_flags & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR))
+ != (os->flags() & (elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR)))
+ os->set_order(this->default_section_order(os, false));
return os;
}
+void
+Layout::finalize_eh_frame_section()
+{
+ // If we never found an end marker section, we need to add the
+ // optimized eh sections to the output section now.
+ if (!parameters->incremental()
+ && this->eh_frame_section_ != NULL
+ && !this->added_eh_frame_data_)
+ {
+ this->eh_frame_section_->add_output_section_data(this->eh_frame_data_);
+ this->added_eh_frame_data_ = true;
+ }
+}
+
// Create and return the magic .eh_frame section. Create
// .eh_frame_hdr also if appropriate. OBJECT is the object with the
// input .eh_frame section; it may be NULL.
Output_section*
Layout::make_eh_frame_section(const Relobj* object)
{
- // FIXME: On x86_64, this could use SHT_X86_64_UNWIND rather than
- // SHT_PROGBITS.
+ const unsigned int unwind_section_type =
+ parameters->target().unwind_section_type();
+
Output_section* os = this->choose_output_section(object, ".eh_frame",
- elfcpp::SHT_PROGBITS,
+ unwind_section_type,
elfcpp::SHF_ALLOC, false,
- ORDER_EHFRAME, false);
+ ORDER_EHFRAME, false, false,
+ false);
if (os == NULL)
return NULL;
{
Output_section* hdr_os =
this->choose_output_section(NULL, ".eh_frame_hdr",
- elfcpp::SHT_PROGBITS,
+ unwind_section_type,
elfcpp::SHF_ALLOC, false,
- ORDER_EHFRAME, false);
+ ORDER_EHFRAME, false, false,
+ false);
if (hdr_os != NULL)
{
}
}
+// Remove all post-map .eh_frame information for a PLT.
+
+void
+Layout::remove_eh_frame_for_plt(Output_data* plt, const unsigned char* cie_data,
+ size_t cie_length)
+{
+ if (parameters->incremental())
+ {
+ // FIXME: Maybe this could work some day....
+ return;
+ }
+ this->eh_frame_data_->remove_ehframe_for_plt(plt, cie_data, cie_length);
+}
+
// Scan a .debug_info or .debug_types section, and add summary
// information to the .gdb_index section.
Output_section* os = this->choose_output_section(NULL, ".gdb_index",
elfcpp::SHT_PROGBITS, 0,
false, ORDER_INVALID,
- false);
+ false, false, false);
if (os == NULL)
return;
Output_section_order order, bool is_relro)
{
Output_section* os = this->choose_output_section(NULL, name, type, flags,
- false, order, is_relro);
+ false, order, is_relro,
+ false, false);
if (os != NULL)
os->add_output_section_data(posd);
return os;
&& strcmp(name, ".text") == 0)
os->set_may_sort_attached_input_sections();
+ // GNU linker sorts section by name with --sort-section=name.
+ if (strcmp(parameters->options().sort_section(), "name") == 0)
+ os->set_must_sort_attached_input_sections();
+
// Check for .stab*str sections, as .stab* sections need to link to
// them.
if (type == elfcpp::SHT_STRTAB
return ORDER_INIT;
else if (strcmp(os->name(), ".fini") == 0)
return ORDER_FINI;
+ else if (parameters->options().keep_text_section_prefix())
+ {
+ // -z,keep-text-section-prefix introduces additional
+ // output sections.
+ if (strcmp(os->name(), ".text.hot") == 0)
+ return ORDER_TEXT_HOT;
+ else if (strcmp(os->name(), ".text.startup") == 0)
+ return ORDER_TEXT_STARTUP;
+ else if (strcmp(os->name(), ".text.exit") == 0)
+ return ORDER_TEXT_EXIT;
+ else if (strcmp(os->name(), ".text.unlikely") == 0)
+ return ORDER_TEXT_UNLIKELY;
+ }
}
return is_execinstr ? ORDER_TEXT : ORDER_READONLY;
}
if (!os->is_unique_segment())
{
for (p = this->segment_list_.begin();
- p != this->segment_list_.end();
+ p != this->segment_list_.end();
++p)
{
- if ((*p)->type() != elfcpp::PT_LOAD)
- continue;
- if ((*p)->is_unique_segment())
- continue;
- if (!parameters->options().omagic()
- && ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W))
- continue;
- if ((target->isolate_execinstr() || 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())
- {
- if ((os->type() == elfcpp::SHT_NOBITS)
- == (*p)->has_any_data_sections())
- continue;
- }
- if (os->is_large_data_section() && !(*p)->is_large_data_segment())
- continue;
-
- if (is_address_set)
- {
- if ((*p)->are_addresses_set())
- continue;
-
- (*p)->add_initial_output_data(os);
- (*p)->update_flags_for_output_section(seg_flags);
- (*p)->set_addresses(addr, addr);
- break;
- }
-
- (*p)->add_output_section_to_load(this, os, seg_flags);
- break;
- }
+ if ((*p)->type() != elfcpp::PT_LOAD)
+ continue;
+ if ((*p)->is_unique_segment())
+ continue;
+ if (!parameters->options().omagic()
+ && ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W))
+ continue;
+ if ((target->isolate_execinstr() || 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())
+ {
+ if ((os->type() == elfcpp::SHT_NOBITS)
+ == (*p)->has_any_data_sections())
+ continue;
+ }
+ if (os->is_large_data_section() && !(*p)->is_large_data_segment())
+ continue;
+
+ if (is_address_set)
+ {
+ if ((*p)->are_addresses_set())
+ continue;
+
+ (*p)->add_initial_output_data(os);
+ (*p)->update_flags_for_output_section(seg_flags);
+ (*p)->set_addresses(addr, addr);
+ break;
+ }
+
+ (*p)->add_output_section_to_load(this, os, seg_flags);
+ break;
+ }
}
if (p == this->segment_list_.end()
// segment.
if (os->type() == elfcpp::SHT_NOTE)
{
+ uint64_t os_align = os->addralign();
+
// See if we already have an equivalent PT_NOTE segment.
for (p = this->segment_list_.begin();
p != segment_list_.end();
++p)
{
if ((*p)->type() == elfcpp::PT_NOTE
+ && (*p)->align() == os_align
&& (((*p)->flags() & elfcpp::PF_W)
== (seg_flags & elfcpp::PF_W)))
{
Output_segment* oseg = this->make_output_segment(elfcpp::PT_NOTE,
seg_flags);
oseg->add_output_section_to_nonload(os, seg_flags);
+ oseg->set_align(os_align);
}
}
if ((gnu_stack_flags & elfcpp::SHF_EXECINSTR) != 0)
{
this->input_requires_executable_stack_ = true;
- if (parameters->options().warn_execstack()
- || parameters->options().is_stack_executable())
+ if (parameters->options().warn_execstack())
gold_warning(_("%s: requires executable stack"),
obj->name().c_str());
}
}
}
+// Read a value with given size and endianness.
+
+static inline uint64_t
+read_sized_value(size_t size, const unsigned char* buf, bool is_big_endian,
+ const Object* object)
+{
+ uint64_t val = 0;
+ if (size == 4)
+ {
+ if (is_big_endian)
+ val = elfcpp::Swap<32, true>::readval(buf);
+ else
+ val = elfcpp::Swap<32, false>::readval(buf);
+ }
+ else if (size == 8)
+ {
+ if (is_big_endian)
+ val = elfcpp::Swap<64, true>::readval(buf);
+ else
+ val = elfcpp::Swap<64, false>::readval(buf);
+ }
+ else
+ {
+ gold_warning(_("%s: in .note.gnu.property section, "
+ "pr_datasz must be 4 or 8"),
+ object->name().c_str());
+ }
+ return val;
+}
+
+// Write a value with given size and endianness.
+
+static inline void
+write_sized_value(uint64_t value, size_t size, unsigned char* buf,
+ bool is_big_endian)
+{
+ if (size == 4)
+ {
+ if (is_big_endian)
+ elfcpp::Swap<32, true>::writeval(buf, static_cast<uint32_t>(value));
+ else
+ elfcpp::Swap<32, false>::writeval(buf, static_cast<uint32_t>(value));
+ }
+ else if (size == 8)
+ {
+ if (is_big_endian)
+ elfcpp::Swap<64, true>::writeval(buf, value);
+ else
+ elfcpp::Swap<64, false>::writeval(buf, value);
+ }
+ else
+ {
+ // We will have already complained about this.
+ }
+}
+
+// Handle the .note.gnu.property section at layout time.
+
+void
+Layout::layout_gnu_property(unsigned int note_type,
+ unsigned int pr_type,
+ size_t pr_datasz,
+ const unsigned char* pr_data,
+ const Object* object)
+{
+ // We currently support only the one note type.
+ gold_assert(note_type == elfcpp::NT_GNU_PROPERTY_TYPE_0);
+
+ if (pr_type >= elfcpp::GNU_PROPERTY_LOPROC
+ && pr_type < elfcpp::GNU_PROPERTY_HIPROC)
+ {
+ // Target-dependent property value; call the target to record.
+ const int size = parameters->target().get_size();
+ const bool is_big_endian = parameters->target().is_big_endian();
+ if (size == 32)
+ {
+ if (is_big_endian)
+ {
+#ifdef HAVE_TARGET_32_BIG
+ parameters->sized_target<32, true>()->
+ record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
+ object);
+#else
+ gold_unreachable();
+#endif
+ }
+ else
+ {
+#ifdef HAVE_TARGET_32_LITTLE
+ parameters->sized_target<32, false>()->
+ record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
+ object);
+#else
+ gold_unreachable();
+#endif
+ }
+ }
+ else if (size == 64)
+ {
+ if (is_big_endian)
+ {
+#ifdef HAVE_TARGET_64_BIG
+ parameters->sized_target<64, true>()->
+ record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
+ object);
+#else
+ gold_unreachable();
+#endif
+ }
+ else
+ {
+#ifdef HAVE_TARGET_64_LITTLE
+ parameters->sized_target<64, false>()->
+ record_gnu_property(note_type, pr_type, pr_datasz, pr_data,
+ object);
+#else
+ gold_unreachable();
+#endif
+ }
+ }
+ else
+ gold_unreachable();
+ return;
+ }
+
+ Gnu_properties::iterator pprop = this->gnu_properties_.find(pr_type);
+ if (pprop == this->gnu_properties_.end())
+ {
+ Gnu_property prop;
+ prop.pr_datasz = pr_datasz;
+ prop.pr_data = new unsigned char[pr_datasz];
+ memcpy(prop.pr_data, pr_data, pr_datasz);
+ this->gnu_properties_[pr_type] = prop;
+ }
+ else
+ {
+ const bool is_big_endian = parameters->target().is_big_endian();
+ switch (pr_type)
+ {
+ case elfcpp::GNU_PROPERTY_STACK_SIZE:
+ // Record the maximum value seen.
+ {
+ uint64_t val1 = read_sized_value(pprop->second.pr_datasz,
+ pprop->second.pr_data,
+ is_big_endian, object);
+ uint64_t val2 = read_sized_value(pr_datasz, pr_data,
+ is_big_endian, object);
+ if (val2 > val1)
+ write_sized_value(val2, pprop->second.pr_datasz,
+ pprop->second.pr_data, is_big_endian);
+ }
+ break;
+ case elfcpp::GNU_PROPERTY_NO_COPY_ON_PROTECTED:
+ // No data to merge.
+ break;
+ default:
+ gold_warning(_("%s: unknown program property type %d "
+ "in .note.gnu.property section"),
+ object->name().c_str(), pr_type);
+ }
+ }
+}
+
+// Merge per-object properties with program properties.
+// This lets the target identify objects that are missing certain
+// properties, in cases where properties must be ANDed together.
+
+void
+Layout::merge_gnu_properties(const Object* object)
+{
+ const int size = parameters->target().get_size();
+ const bool is_big_endian = parameters->target().is_big_endian();
+ if (size == 32)
+ {
+ if (is_big_endian)
+ {
+#ifdef HAVE_TARGET_32_BIG
+ parameters->sized_target<32, true>()->merge_gnu_properties(object);
+#else
+ gold_unreachable();
+#endif
+ }
+ else
+ {
+#ifdef HAVE_TARGET_32_LITTLE
+ parameters->sized_target<32, false>()->merge_gnu_properties(object);
+#else
+ gold_unreachable();
+#endif
+ }
+ }
+ else if (size == 64)
+ {
+ if (is_big_endian)
+ {
+#ifdef HAVE_TARGET_64_BIG
+ parameters->sized_target<64, true>()->merge_gnu_properties(object);
+#else
+ gold_unreachable();
+#endif
+ }
+ else
+ {
+#ifdef HAVE_TARGET_64_LITTLE
+ parameters->sized_target<64, false>()->merge_gnu_properties(object);
+#else
+ gold_unreachable();
+#endif
+ }
+ }
+ else
+ gold_unreachable();
+}
+
+// Add a target-specific property for the output .note.gnu.property section.
+
+void
+Layout::add_gnu_property(unsigned int note_type,
+ unsigned int pr_type,
+ size_t pr_datasz,
+ const unsigned char* pr_data)
+{
+ gold_assert(note_type == elfcpp::NT_GNU_PROPERTY_TYPE_0);
+
+ Gnu_property prop;
+ prop.pr_datasz = pr_datasz;
+ prop.pr_data = new unsigned char[pr_datasz];
+ memcpy(prop.pr_data, pr_data, pr_datasz);
+ this->gnu_properties_[pr_type] = prop;
+}
+
// Create automatic note sections.
void
Layout::create_notes()
{
+ this->create_gnu_properties_note();
this->create_gold_note();
- this->create_executable_stack_info();
+ this->create_stack_segment();
this->create_build_id();
}
(elfcpp::SHF_ALLOC
| elfcpp::SHF_WRITE),
false, ORDER_RELRO,
- true);
+ true, false, false);
// A linker script may discard .dynamic, so check for NULL.
if (this->dynamic_section_ != NULL)
void
Layout::define_section_symbols(Symbol_table* symtab)
{
+ const elfcpp::STV visibility = parameters->options().start_stop_visibility_enum();
for (Section_list::const_iterator p = this->section_list_.begin();
p != this->section_list_.end();
++p)
0, // symsize
elfcpp::STT_NOTYPE,
elfcpp::STB_GLOBAL,
- elfcpp::STV_DEFAULT,
+ visibility,
0, // nonvis
false, // offset_is_from_end
true); // only_if_ref
0, // symsize
elfcpp::STT_NOTYPE,
elfcpp::STB_GLOBAL,
- elfcpp::STV_DEFAULT,
+ visibility,
0, // nonvis
true, // offset_is_from_end
true); // only_if_ref
++p)
delete *p;
this->script_output_section_data_list_.clear();
+
+ // Special-case fill output objects are recreated each time through
+ // the relaxation loop.
+ this->reset_relax_output();
+}
+
+void
+Layout::reset_relax_output()
+{
+ for (Data_list::const_iterator p = this->relax_output_list_.begin();
+ p != this->relax_output_list_.end();
+ ++p)
+ delete *p;
+ this->relax_output_list_.clear();
}
// Prepare for relaxation.
if (is_debugging_enabled(DEBUG_RELAXATION))
this->relaxation_debug_check_->check_output_data_for_reset_values(
- this->section_list_, this->special_output_list_);
+ this->section_list_, this->special_output_list_,
+ this->relax_output_list_);
// Also enable recording of output section data from scripts.
this->record_output_section_data_from_script_ = true;
}
+// If the user set the address of the text segment, that may not be
+// compatible with putting the segment headers and file headers into
+// that segment. For isolate_execinstr() targets, it's the rodata
+// segment rather than text where we might put the headers.
+static inline bool
+load_seg_unusable_for_headers(const Target* target)
+{
+ const General_options& options = parameters->options();
+ if (target->isolate_execinstr())
+ return (options.user_set_Trodata_segment()
+ && options.Trodata_segment() % target->abi_pagesize() != 0);
+ else
+ return (options.user_set_Ttext()
+ && options.Ttext() % target->abi_pagesize() != 0);
+}
+
// Relaxation loop body: If target has no relaxation, this runs only once
// Otherwise, the target relaxation hook is called at the end of
// each iteration. If the hook returns true, it means re-layout of
!= General_options::OBJECT_FORMAT_ELF)
load_seg = NULL;
- // If the user set the address of the text segment, that may not be
- // compatible with putting the segment headers and file headers into
- // that segment.
- if (parameters->options().user_set_Ttext()
- && parameters->options().Ttext() % target->abi_pagesize() != 0)
+ if (load_seg_unusable_for_headers(target))
{
load_seg = NULL;
phdr_seg = NULL;
return off;
}
-// Search the list of patterns and find the postion of the given section
+// Search the list of patterns and find the position of the given section
// name in the output section. If the section name matches a glob
// pattern and a non-glob name, then the non-glob position takes
// precedence. Return 0 if no match is found.
gold_fatal(_("unable to open --section-ordering-file file %s: %s"),
filename, strerror(errno));
+ File_read::record_file_read(filename);
+
std::getline(in, line); // this chops off the trailing \n, if any
unsigned int position = 1;
this->set_section_ordering_specified();
Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab,
Target* target, const Task* task)
{
+ unsigned int local_dynamic_count = 0;
+ unsigned int forced_local_dynamic_count = 0;
+
target->finalize_sections(this, input_objects, symtab);
this->count_local_symbols(task, input_objects);
// Create the dynamic symbol table, including the hash table.
Output_section* dynstr;
std::vector<Symbol*> dynamic_symbols;
- unsigned int local_dynamic_count;
Versions versions(*this->script_options()->version_script_info(),
&this->dynpool_);
this->create_dynamic_symtab(input_objects, symtab, &dynstr,
- &local_dynamic_count, &dynamic_symbols,
+ &local_dynamic_count,
+ &forced_local_dynamic_count,
+ &dynamic_symbols,
&versions);
// Create the .interp section to hold the name of the
// Create the version sections. We can't do this until the
// dynamic string table is complete.
- this->create_version_sections(&versions, symtab, local_dynamic_count,
+ this->create_version_sections(&versions, symtab,
+ (local_dynamic_count
+ + forced_local_dynamic_count),
dynamic_symbols, dynstr);
// Set the size of the _DYNAMIC symbol. We can't do this until
// If there is a load segment that contains the file and program headers,
// provide a symbol __ehdr_start pointing there.
// A program can use this to examine itself robustly.
- if (load_seg != NULL)
- symtab->define_in_output_segment("__ehdr_start", NULL,
- Symbol_table::PREDEFINED, load_seg, 0, 0,
- elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
- elfcpp::STV_DEFAULT, 0,
- Symbol::SEGMENT_START, true);
+ Symbol *ehdr_start = symtab->lookup("__ehdr_start");
+ if (ehdr_start != NULL && ehdr_start->is_predefined())
+ {
+ if (load_seg != NULL)
+ ehdr_start->set_output_segment(load_seg, Symbol::SEGMENT_START);
+ else
+ ehdr_start->set_undefined();
+ }
// Set the file offsets of all the non-data sections we've seen so
// far which don't have to wait for the input sections. We need
shndx = this->set_section_indexes(shndx);
// Create the symbol table sections.
- this->create_symtab_sections(input_objects, symtab, shndx, &off);
+ this->create_symtab_sections(input_objects, symtab, shndx, &off,
+ local_dynamic_count);
if (!parameters->doing_static_link())
this->assign_local_dynsym_offsets(input_objects);
#else
const int size = 32;
#endif
+ // The NT_GNU_PROPERTY_TYPE_0 note is aligned to the pointer size.
+ const int addralign = ((note_type == elfcpp::NT_GNU_PROPERTY_TYPE_0
+ ? parameters->target().get_size()
+ : size) / 8);
// The contents of the .note section.
size_t namesz = strlen(name) + 1;
}
Output_section* os = this->choose_output_section(NULL, section_name,
elfcpp::SHT_NOTE,
- flags, false, order, false);
+ flags, false, order, false,
+ false, true);
if (os == NULL)
return NULL;
Output_section_data* posd = new Output_data_const_buffer(buffer, notehdrsz,
- size / 8,
+ addralign,
"** note header");
os->add_output_section_data(posd);
return os;
}
+// Create a .note.gnu.property section to record program properties
+// accumulated from the input files.
+
+void
+Layout::create_gnu_properties_note()
+{
+ parameters->target().finalize_gnu_properties(this);
+
+ if (this->gnu_properties_.empty())
+ return;
+
+ const unsigned int size = parameters->target().get_size();
+ const bool is_big_endian = parameters->target().is_big_endian();
+
+ // Compute the total size of the properties array.
+ size_t descsz = 0;
+ for (Gnu_properties::const_iterator prop = this->gnu_properties_.begin();
+ prop != this->gnu_properties_.end();
+ ++prop)
+ {
+ descsz = align_address(descsz + 8 + prop->second.pr_datasz, size / 8);
+ }
+
+ // Create the note section.
+ size_t trailing_padding;
+ Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_PROPERTY_TYPE_0,
+ ".note.gnu.property", descsz,
+ true, &trailing_padding);
+ if (os == NULL)
+ return;
+ gold_assert(trailing_padding == 0);
+
+ // Allocate and fill the properties array.
+ unsigned char* desc = new unsigned char[descsz];
+ unsigned char* p = desc;
+ for (Gnu_properties::const_iterator prop = this->gnu_properties_.begin();
+ prop != this->gnu_properties_.end();
+ ++prop)
+ {
+ size_t datasz = prop->second.pr_datasz;
+ size_t aligned_datasz = align_address(prop->second.pr_datasz, size / 8);
+ write_sized_value(prop->first, 4, p, is_big_endian);
+ write_sized_value(datasz, 4, p + 4, is_big_endian);
+ memcpy(p + 8, prop->second.pr_data, datasz);
+ if (aligned_datasz > datasz)
+ memset(p + 8 + datasz, 0, aligned_datasz - datasz);
+ p += 8 + aligned_datasz;
+ }
+ Output_section_data* posd = new Output_data_const(desc, descsz, 4);
+ os->add_output_section_data(posd);
+}
+
// For an executable or shared library, create a note to record the
// version of gold used to create the binary.
// executable. Otherwise, if at least one input file a
// .note.GNU-stack section, and some input file has no .note.GNU-stack
// section, we use the target default for whether the stack should be
-// executable. Otherwise, we don't generate a stack note. When
-// generating a object file, we create a .note.GNU-stack section with
-// the appropriate marking. When generating an executable or shared
-// library, we create a PT_GNU_STACK segment.
+// executable. If -z stack-size was used to set a p_memsz value for
+// PT_GNU_STACK, we generate the segment regardless. Otherwise, we
+// don't generate a stack note. When generating a object file, we
+// create a .note.GNU-stack section with the appropriate marking.
+// When generating an executable or shared library, we create a
+// PT_GNU_STACK segment.
void
-Layout::create_executable_stack_info()
+Layout::create_stack_segment()
{
bool is_stack_executable;
if (parameters->options().is_execstack_set())
- is_stack_executable = parameters->options().is_stack_executable();
- else if (!this->input_with_gnu_stack_note_)
+ {
+ is_stack_executable = parameters->options().is_stack_executable();
+ if (!is_stack_executable
+ && this->input_requires_executable_stack_
+ && parameters->options().warn_execstack())
+ gold_warning(_("one or more inputs require executable stack, "
+ "but -z noexecstack was given"));
+ }
+ else if (!this->input_with_gnu_stack_note_
+ && (!parameters->options().user_set_stack_size()
+ || parameters->options().relocatable()))
return;
else
{
int flags = elfcpp::PF_R | elfcpp::PF_W;
if (is_stack_executable)
flags |= elfcpp::PF_X;
- this->make_output_segment(elfcpp::PT_GNU_STACK, flags);
+ Output_segment* seg =
+ this->make_output_segment(elfcpp::PT_GNU_STACK, flags);
+ seg->set_size(parameters->options().stack_size());
+ // BFD lets targets override this default alignment, but the only
+ // targets that do so are ones that Gold does not support so far.
+ seg->set_minimum_p_align(16);
}
}
std::string desc;
if (strcmp(style, "md5") == 0)
descsz = 128 / 8;
- else if (strcmp(style, "sha1") == 0)
+ else if ((strcmp(style, "sha1") == 0) || (strcmp(style, "tree") == 0))
descsz = 160 / 8;
else if (strcmp(style, "uuid") == 0)
{
+#ifndef __MINGW32__
const size_t uuidsz = 128 / 8;
char buffer[uuidsz];
desc.assign(buffer, uuidsz);
descsz = uuidsz;
+#else // __MINGW32__
+ UUID uuid;
+ typedef RPC_STATUS (RPC_ENTRY *UuidCreateFn)(UUID *Uuid);
+
+ HMODULE rpc_library = LoadLibrary("rpcrt4.dll");
+ if (!rpc_library)
+ gold_error(_("--build-id=uuid failed: could not load rpcrt4.dll"));
+ else
+ {
+ UuidCreateFn uuid_create = reinterpret_cast<UuidCreateFn>(
+ GetProcAddress(rpc_library, "UuidCreate"));
+ if (!uuid_create)
+ gold_error(_("--build-id=uuid failed: could not find UuidCreate"));
+ else if (uuid_create(&uuid) != RPC_S_OK)
+ gold_error(_("__build_id=uuid failed: call UuidCreate() failed"));
+ FreeLibrary(rpc_library);
+ }
+ desc.assign(reinterpret_cast<const char *>(&uuid), sizeof(UUID));
+ descsz = sizeof(UUID);
+#endif // __MINGW32__
}
else if (strncmp(style, "0x", 2) == 0)
{
Layout::segment_precedes(const Output_segment* seg1,
const Output_segment* seg2)
{
+ // In order to produce a stable ordering if we're called with the same pointer
+ // return false.
+ if (seg1 == seg2)
+ return false;
+
elfcpp::Elf_Word type1 = seg1->type();
elfcpp::Elf_Word type2 = seg2->type();
// The order of non-PT_LOAD segments is unimportant. We simply sort
// by the numeric segment type and flags values. There should not
- // be more than one segment with the same type and flags.
+ // be more than one segment with the same type and flags, except
+ // when a linker script specifies such.
if (type1 != elfcpp::PT_LOAD)
{
if (type1 != type2)
return type1 < type2;
- gold_assert(flags1 != flags2);
+ uint64_t align1 = seg1->align();
+ uint64_t align2 = seg2->align();
+ // Place segments with larger alignments first.
+ if (align1 != align2)
+ return align1 > align2;
+ gold_assert(flags1 != flags2
+ || this->script_options_->saw_phdrs_clause());
return flags1 < flags2;
}
// here if plugins want unique segments for subsets of sections.
gold_assert(this->script_options_->saw_phdrs_clause()
|| parameters->options().any_section_start()
- || this->is_unique_segment_for_sections_specified());
+ || this->is_unique_segment_for_sections_specified()
+ || parameters->options().text_unlikely_segment());
return false;
}
return aligned_off;
}
+// On targets where the text segment contains only executable code,
+// a non-executable segment is never the text segment.
+
+static inline bool
+is_text_segment(const Target* target, const Output_segment* seg)
+{
+ elfcpp::Elf_Xword flags = seg->flags();
+ if ((flags & elfcpp::PF_W) != 0)
+ return false;
+ if ((flags & elfcpp::PF_X) == 0)
+ return !target->isolate_execinstr();
+ return true;
+}
+
// Set the file offsets of all the segments, and all the sections they
-// contain. They have all been created. LOAD_SEG must be be laid out
+// contain. They have all been created. LOAD_SEG must be laid out
// first. Return the offset of the data to follow.
off_t
}
else if (parameters->options().user_set_Ttext()
&& (parameters->options().omagic()
- || ((*p)->flags() & elfcpp::PF_W) == 0))
+ || is_text_segment(target, *p)))
+ {
+ are_addresses_set = true;
+ }
+ else if (parameters->options().user_set_Trodata_segment()
+ && ((*p)->flags() & (elfcpp::PF_W | elfcpp::PF_X)) == 0)
{
+ addr = parameters->options().Trodata_segment();
are_addresses_set = true;
}
else if (parameters->options().user_set_Tdata()
// 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());
+ uint64_t max_align = (*p)->maximum_alignment();
+ if (max_align > abi_pagesize)
+ addr = align_address(addr, max_align);
aligned_addr = addr;
if (load_seg == *p)
// If the target wants a fixed minimum distance from the
// text segment to the read-only segment, move up now.
- uint64_t min_addr = start_addr + target->rosegment_gap();
+ uint64_t min_addr =
+ start_addr + (parameters->options().user_set_rosegment_gap()
+ ? parameters->options().rosegment_gap()
+ : target->rosegment_gap());
if (addr < min_addr)
addr = min_addr;
if (!parameters->options().nmagic()
&& !parameters->options().omagic())
- off = align_file_offset(off, addr, abi_pagesize);
+ {
+ // Here we are also taking care of the case when
+ // the maximum segment alignment is larger than the page size.
+ off = align_file_offset(off, addr,
+ std::max(abi_pagesize,
+ (*p)->maximum_alignment()));
+ }
else
{
// This is -N or -n with a section script which prevents
unsigned int shndx_hold = *pshndx;
bool has_relro = false;
- uint64_t new_addr = (*p)->set_section_addresses(this, false, addr,
+ uint64_t new_addr = (*p)->set_section_addresses(target, this,
+ false, addr,
&increase_relro,
&has_relro,
&off, pshndx);
increase_relro = 0;
has_relro = false;
- new_addr = (*p)->set_section_addresses(this, true, addr,
+ new_addr = (*p)->set_section_addresses(target, this,
+ true, addr,
&increase_relro,
&has_relro,
&off, pshndx);
// so they land after the segments starting at LOAD_SEG.
off = align_file_offset(off, 0, target->abi_pagesize());
+ this->reset_relax_output();
+
for (Segment_list::iterator p = this->segment_list_.begin();
*p != load_seg;
++p)
bool has_relro = false;
const uint64_t old_addr = (*p)->vaddr();
const uint64_t old_end = old_addr + (*p)->memsz();
- uint64_t new_addr = (*p)->set_section_addresses(this, true,
- old_addr,
+ uint64_t new_addr = (*p)->set_section_addresses(target, this,
+ true, old_addr,
&increase_relro,
&has_relro,
&off,
p != this->segment_list_.end();
++p)
{
- if ((*p)->type() != elfcpp::PT_LOAD)
+ // PT_GNU_STACK was set up correctly when it was created.
+ if ((*p)->type() != elfcpp::PT_LOAD
+ && (*p)->type() != elfcpp::PT_GNU_STACK)
(*p)->set_offset((*p)->type() == elfcpp::PT_GNU_RELRO
? increase_relro
: 0);
(*p)->set_address(0);
(*p)->set_file_offset(off);
(*p)->finalize_data_size();
- off += (*p)->data_size();
+ if ((*p)->type() != elfcpp::SHT_NOBITS)
+ off += (*p)->data_size();
(*p)->set_out_shndx(*pshndx);
++*pshndx;
Layout::create_symtab_sections(const Input_objects* input_objects,
Symbol_table* symtab,
unsigned int shnum,
- off_t* poff)
+ off_t* poff,
+ unsigned int local_dynamic_count)
{
int symsize;
unsigned int align;
gold_assert(static_cast<off_t>(local_symcount * symsize) == off);
off_t dynoff;
- size_t dyn_global_index;
size_t dyncount;
if (this->dynsym_section_ == NULL)
{
dynoff = 0;
- dyn_global_index = 0;
dyncount = 0;
}
else
{
- dyn_global_index = this->dynsym_section_->info();
- off_t locsize = dyn_global_index * this->dynsym_section_->entsize();
+ off_t locsize = local_dynamic_count * this->dynsym_section_->entsize();
dynoff = this->dynsym_section_->offset() + locsize;
dyncount = (this->dynsym_section_->data_size() - locsize) / symsize;
gold_assert(static_cast<off_t>(dyncount * symsize)
}
off_t global_off = off;
- off = symtab->finalize(off, dynoff, dyn_global_index, dyncount,
+ off = symtab->finalize(off, dynoff, local_dynamic_count, dyncount,
&this->sympool_, &local_symcount);
if (!parameters->options().strip_all())
}
// Create the dynamic symbol table.
+// *PLOCAL_DYNAMIC_COUNT will be set to the number of local symbols
+// from input objects, and *PFORCED_LOCAL_DYNAMIC_COUNT will be set
+// to the number of global symbols that have been forced local.
+// We need to remember the former because the forced-local symbols are
+// written along with the global symbols in Symtab::write_globals().
void
Layout::create_dynamic_symtab(const Input_objects* input_objects,
Symbol_table* symtab,
Output_section** pdynstr,
unsigned int* plocal_dynamic_count,
+ unsigned int* pforced_local_dynamic_count,
std::vector<Symbol*>* pdynamic_symbols,
Versions* pversions)
{
}
unsigned int local_symcount = index;
- *plocal_dynamic_count = local_symcount;
+ unsigned int forced_local_count = 0;
+
+ index = symtab->set_dynsym_indexes(index, &forced_local_count,
+ pdynamic_symbols, &this->dynpool_,
+ pversions);
- index = symtab->set_dynsym_indexes(index, pdynamic_symbols,
- &this->dynpool_, pversions);
+ *plocal_dynamic_count = local_symcount;
+ *pforced_local_dynamic_count = forced_local_count;
int symsize;
unsigned int align;
elfcpp::SHF_ALLOC,
false,
ORDER_DYNAMIC_LINKER,
- false);
+ false, false, false);
// Check for NULL as a linker script may discard .dynsym.
if (dynsym != NULL)
"** dynsym");
dynsym->add_output_section_data(odata);
- dynsym->set_info(local_symcount);
+ dynsym->set_info(local_symcount + forced_local_count);
dynsym->set_entsize(symsize);
dynsym->set_addralign(align);
this->choose_output_section(NULL, ".dynsym_shndx",
elfcpp::SHT_SYMTAB_SHNDX,
elfcpp::SHF_ALLOC,
- false, ORDER_DYNAMIC_LINKER, false);
+ false, ORDER_DYNAMIC_LINKER, false, false,
+ false);
if (dynsym_xindex != NULL)
{
elfcpp::SHF_ALLOC,
false,
ORDER_DYNAMIC_LINKER,
- false);
+ false, false, false);
*pdynstr = dynstr;
if (dynstr != NULL)
{
}
}
- // Create the hash tables.
+ // Create the hash tables. The Gnu-style hash table must be
+ // built first, because it changes the order of the symbols
+ // in the dynamic symbol table.
- if (strcmp(parameters->options().hash_style(), "sysv") == 0
+ if (strcmp(parameters->options().hash_style(), "gnu") == 0
|| strcmp(parameters->options().hash_style(), "both") == 0)
{
unsigned char* phash;
unsigned int hashlen;
- Dynobj::create_elf_hash_table(*pdynamic_symbols, local_symcount,
+ Dynobj::create_gnu_hash_table(*pdynamic_symbols,
+ local_symcount + forced_local_count,
&phash, &hashlen);
Output_section* hashsec =
- this->choose_output_section(NULL, ".hash", elfcpp::SHT_HASH,
+ this->choose_output_section(NULL, ".gnu.hash", elfcpp::SHT_GNU_HASH,
elfcpp::SHF_ALLOC, false,
- ORDER_DYNAMIC_LINKER, false);
+ ORDER_DYNAMIC_LINKER, false, false,
+ false);
Output_section_data* hashdata = new Output_data_const_buffer(phash,
hashlen,
{
if (dynsym != NULL)
hashsec->set_link_section(dynsym);
- hashsec->set_entsize(4);
- }
- if (odyn != NULL)
- odyn->add_section_address(elfcpp::DT_HASH, hashsec);
+ // For a 64-bit target, the entries in .gnu.hash do not have
+ // a uniform size, so we only set the entry size for a
+ // 32-bit target.
+ if (parameters->target().get_size() == 32)
+ hashsec->set_entsize(4);
+
+ if (odyn != NULL)
+ odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
+ }
}
- if (strcmp(parameters->options().hash_style(), "gnu") == 0
+ if (strcmp(parameters->options().hash_style(), "sysv") == 0
|| strcmp(parameters->options().hash_style(), "both") == 0)
{
unsigned char* phash;
unsigned int hashlen;
- Dynobj::create_gnu_hash_table(*pdynamic_symbols, local_symcount,
+ Dynobj::create_elf_hash_table(*pdynamic_symbols,
+ local_symcount + forced_local_count,
&phash, &hashlen);
Output_section* hashsec =
- this->choose_output_section(NULL, ".gnu.hash", elfcpp::SHT_GNU_HASH,
+ this->choose_output_section(NULL, ".hash", elfcpp::SHT_HASH,
elfcpp::SHF_ALLOC, false,
- ORDER_DYNAMIC_LINKER, false);
+ ORDER_DYNAMIC_LINKER, false, false,
+ false);
Output_section_data* hashdata = new Output_data_const_buffer(phash,
hashlen,
{
if (dynsym != NULL)
hashsec->set_link_section(dynsym);
-
- // For a 64-bit target, the entries in .gnu.hash do not have
- // a uniform size, so we only set the entry size for a
- // 32-bit target.
- if (parameters->target().get_size() == 32)
- hashsec->set_entsize(4);
-
- if (odyn != NULL)
- odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
+ hashsec->set_entsize(parameters->target().hash_entry_size() / 8);
}
+
+ if (odyn != NULL)
+ odyn->add_section_address(elfcpp::DT_HASH, hashsec);
}
}
elfcpp::SHF_ALLOC,
false,
ORDER_DYNAMIC_LINKER,
- false);
+ false, false, false);
// Check for NULL since a linker script may discard this section.
if (vsec != NULL)
vdsec = this->choose_output_section(NULL, ".gnu.version_d",
elfcpp::SHT_GNU_verdef,
elfcpp::SHF_ALLOC,
- false, ORDER_DYNAMIC_LINKER, false);
+ false, ORDER_DYNAMIC_LINKER, false,
+ false, false);
if (vdsec != NULL)
{
vnsec = this->choose_output_section(NULL, ".gnu.version_r",
elfcpp::SHT_GNU_verneed,
elfcpp::SHF_ALLOC,
- false, ORDER_DYNAMIC_LINKER, false);
+ false, ORDER_DYNAMIC_LINKER, false,
+ false, false);
if (vnsec != NULL)
{
elfcpp::SHT_PROGBITS,
elfcpp::SHF_ALLOC,
false, ORDER_INTERP,
- false);
+ false, false, false);
if (osec != NULL)
osec->add_output_section_data(odata);
}
}
}
+void
+Layout::add_target_specific_dynamic_tag(elfcpp::DT tag, unsigned int val)
+{
+ Output_data_dynamic* odyn = this->dynamic_data_;
+ if (odyn == NULL)
+ return;
+ odyn->add_constant(tag, val);
+}
+
// Finish the .dynamic section and PT_DYNAMIC segment.
void
flags |= elfcpp::DF_STATIC_TLS;
if (parameters->options().origin())
flags |= elfcpp::DF_ORIGIN;
- if (parameters->options().Bsymbolic())
+ if (parameters->options().Bsymbolic()
+ && !parameters->options().have_dynamic_list())
{
flags |= elfcpp::DF_SYMBOLIC;
// Add DT_SYMBOLIC for compatibility with older loaders.
odyn->add_constant(elfcpp::DT_FLAGS, flags);
flags = 0;
+ if (parameters->options().global())
+ flags |= elfcpp::DF_1_GLOBAL;
if (parameters->options().initfirst())
flags |= elfcpp::DF_1_INITFIRST;
if (parameters->options().interpose())
flags |= elfcpp::DF_1_NOW;
if (parameters->options().Bgroup())
flags |= elfcpp::DF_1_GROUP;
+ if (parameters->options().pie())
+ flags |= elfcpp::DF_1_PIE;
if (flags != 0)
odyn->add_constant(elfcpp::DT_FLAGS_1, flags);
+
+ flags = 0;
+ if (parameters->options().unique())
+ flags |= elfcpp::DF_GNU_1_UNIQUE;
+ if (flags != 0)
+ odyn->add_constant(elfcpp::DT_GNU_FLAGS_1, flags);
}
// Set the size of the _DYNAMIC symbol table to be the size of the
MAPPING_INIT(".gnu.linkonce.armextab.", ".ARM.extab"),
MAPPING_INIT(".ARM.exidx", ".ARM.exidx"),
MAPPING_INIT(".gnu.linkonce.armexidx.", ".ARM.exidx"),
+ MAPPING_INIT(".gnu.build.attributes.", ".gnu.build.attributes"),
+};
+
+// Mapping for ".text" section prefixes with -z,keep-text-section-prefix.
+const Layout::Section_name_mapping Layout::text_section_name_mapping[] =
+{
+ MAPPING_INIT(".text.hot.", ".text.hot"),
+ MAPPING_INIT_EXACT(".text.hot", ".text.hot"),
+ MAPPING_INIT(".text.unlikely.", ".text.unlikely"),
+ MAPPING_INIT_EXACT(".text.unlikely", ".text.unlikely"),
+ MAPPING_INIT(".text.startup.", ".text.startup"),
+ MAPPING_INIT_EXACT(".text.startup", ".text.startup"),
+ MAPPING_INIT(".text.exit.", ".text.exit"),
+ MAPPING_INIT_EXACT(".text.exit", ".text.exit"),
+ MAPPING_INIT(".text.", ".text"),
};
#undef MAPPING_INIT
#undef MAPPING_INIT_EXACT
(sizeof(Layout::section_name_mapping)
/ sizeof(Layout::section_name_mapping[0]));
+const int Layout::text_section_name_mapping_count =
+ (sizeof(Layout::text_section_name_mapping)
+ / sizeof(Layout::text_section_name_mapping[0]));
+
+// Find section name NAME in PSNM and return the mapped name if found
+// with the length set in PLEN.
+const char *
+Layout::match_section_name(const Layout::Section_name_mapping* psnm,
+ const int count,
+ const char* name, size_t* plen)
+{
+ for (int i = 0; i < count; ++i, ++psnm)
+ {
+ if (psnm->fromlen > 0)
+ {
+ if (strncmp(name, psnm->from, psnm->fromlen) == 0)
+ {
+ *plen = psnm->tolen;
+ return psnm->to;
+ }
+ }
+ else
+ {
+ if (strcmp(name, psnm->from) == 0)
+ {
+ *plen = psnm->tolen;
+ return psnm->to;
+ }
+ }
+ }
+ return NULL;
+}
+
// Choose the output section name to use given an input section name.
// Set *PLEN to the length of the name. *PLEN is initialized to the
// length of NAME.
// not found in the table, we simply use it as the output section
// name.
- const Section_name_mapping* psnm = section_name_mapping;
- for (int i = 0; i < section_name_mapping_count; ++i, ++psnm)
+ if (parameters->options().keep_text_section_prefix()
+ && is_prefix_of(".text", name))
{
- if (psnm->fromlen > 0)
- {
- if (strncmp(name, psnm->from, psnm->fromlen) == 0)
- {
- *plen = psnm->tolen;
- return psnm->to;
- }
- }
- else
- {
- if (strcmp(name, psnm->from) == 0)
- {
- *plen = psnm->tolen;
- return psnm->to;
- }
- }
+ const char* match = match_section_name(text_section_name_mapping,
+ text_section_name_mapping_count,
+ name, plen);
+ if (match != NULL)
+ return match;
}
+ const char* match = match_section_name(section_name_mapping,
+ section_name_mapping_count, name, plen);
+ if (match != NULL)
+ return match;
+
// As an additional complication, .ctors sections are output in
// either .ctors or .init_array sections, and .dtors sections are
// output in either .dtors or .fini_array sections.
p != this->special_output_list_.end();
++p)
(*p)->write(of);
+
+ // Write out the Output_data which are not in an Output_section
+ // and are regenerated in each iteration of relaxation.
+ for (Data_list::const_iterator p = this->relax_output_list_.begin();
+ p != this->relax_output_list_.end();
+ ++p)
+ (*p)->write(of);
}
// Write out the Output_sections which can only be written after the
this->section_headers_->write(of);
}
-// If the build ID requires computing a checksum, do so here, and
-// write it out. We compute a checksum over the entire file because
-// that is simplest.
+// If a tree-style build ID was requested, the parallel part of that computation
+// is already done, and the final hash-of-hashes is computed here. For other
+// types of build IDs, all the work is done here.
void
-Layout::write_build_id(Output_file* of) const
+Layout::write_build_id(Output_file* of, unsigned char* array_of_hashes,
+ size_t size_of_hashes) const
{
if (this->build_id_note_ == NULL)
return;
- const unsigned char* iv = of->get_input_view(0, this->output_file_size_);
-
unsigned char* ov = of->get_output_view(this->build_id_note_->offset(),
this->build_id_note_->data_size());
- const char* style = parameters->options().build_id();
- if (strcmp(style, "sha1") == 0)
+ if (array_of_hashes == NULL)
{
- sha1_ctx ctx;
- sha1_init_ctx(&ctx);
- sha1_process_bytes(iv, this->output_file_size_, &ctx);
- sha1_finish_ctx(&ctx, ov);
+ const size_t output_file_size = this->output_file_size();
+ const unsigned char* iv = of->get_input_view(0, output_file_size);
+ const char* style = parameters->options().build_id();
+
+ // If we get here with style == "tree" then the output must be
+ // too small for chunking, and we use SHA-1 in that case.
+ if ((strcmp(style, "sha1") == 0) || (strcmp(style, "tree") == 0))
+ sha1_buffer(reinterpret_cast<const char*>(iv), output_file_size, ov);
+ else if (strcmp(style, "md5") == 0)
+ md5_buffer(reinterpret_cast<const char*>(iv), output_file_size, ov);
+ else
+ gold_unreachable();
+
+ of->free_input_view(0, output_file_size, iv);
}
- else if (strcmp(style, "md5") == 0)
+ else
{
- md5_ctx ctx;
- md5_init_ctx(&ctx);
- md5_process_bytes(iv, this->output_file_size_, &ctx);
- md5_finish_ctx(&ctx, ov);
+ // Non-overlapping substrings of the output file have been hashed.
+ // Compute SHA-1 hash of the hashes.
+ sha1_buffer(reinterpret_cast<const char*>(array_of_hashes),
+ size_of_hashes, ov);
+ delete[] array_of_hashes;
}
- else
- gold_unreachable();
of->write_output_view(this->build_id_note_->offset(),
this->build_id_note_->data_size(),
ov);
-
- of->free_input_view(0, this->output_file_size_, iv);
}
// Write out a binary file. This is called after the link is
p != this->segment_list_.end();
++p)
(*p)->print_sections_to_mapfile(mapfile);
+ for (Section_list::const_iterator p = this->unattached_section_list_.begin();
+ p != this->unattached_section_list_.end();
+ ++p)
+ (*p)->print_to_mapfile(mapfile);
}
// Print statistical information to stderr. This is used for --stats.
Write_sections_task::locks(Task_locker* tl)
{
tl->add(this, this->output_sections_blocker_);
+ if (this->input_sections_blocker_ != NULL)
+ tl->add(this, this->input_sections_blocker_);
tl->add(this, this->final_blocker_);
}
this->layout_->write_sections_after_input_sections(this->of_);
}
+// Build IDs can be computed as a "flat" sha1 or md5 of a string of bytes,
+// or as a "tree" where each chunk of the string is hashed and then those
+// hashes are put into a (much smaller) string which is hashed with sha1.
+// We compute a checksum over the entire file because that is simplest.
+
+void
+Build_id_task_runner::run(Workqueue* workqueue, const Task*)
+{
+ Task_token* post_hash_tasks_blocker = new Task_token(true);
+ const Layout* layout = this->layout_;
+ Output_file* of = this->of_;
+ const size_t filesize = (layout->output_file_size() <= 0 ? 0
+ : static_cast<size_t>(layout->output_file_size()));
+ unsigned char* array_of_hashes = NULL;
+ size_t size_of_hashes = 0;
+
+ if (strcmp(this->options_->build_id(), "tree") == 0
+ && this->options_->build_id_chunk_size_for_treehash() > 0
+ && filesize > 0
+ && (filesize >= this->options_->build_id_min_file_size_for_treehash()))
+ {
+ static const size_t MD5_OUTPUT_SIZE_IN_BYTES = 16;
+ const size_t chunk_size =
+ this->options_->build_id_chunk_size_for_treehash();
+ const size_t num_hashes = ((filesize - 1) / chunk_size) + 1;
+ post_hash_tasks_blocker->add_blockers(num_hashes);
+ size_of_hashes = num_hashes * MD5_OUTPUT_SIZE_IN_BYTES;
+ array_of_hashes = new unsigned char[size_of_hashes];
+ unsigned char *dst = array_of_hashes;
+ for (size_t i = 0, src_offset = 0; i < num_hashes;
+ i++, dst += MD5_OUTPUT_SIZE_IN_BYTES, src_offset += chunk_size)
+ {
+ size_t size = std::min(chunk_size, filesize - src_offset);
+ workqueue->queue(new Hash_task(of,
+ src_offset,
+ size,
+ dst,
+ post_hash_tasks_blocker));
+ }
+ }
+
+ // Queue the final task to write the build id and close the output file.
+ workqueue->queue(new Task_function(new Close_task_runner(this->options_,
+ layout,
+ of,
+ array_of_hashes,
+ size_of_hashes),
+ post_hash_tasks_blocker,
+ "Task_function Close_task_runner"));
+}
+
// Close_task_runner methods.
-// Run the task--close the file.
+// Finish up the build ID computation, if necessary, and write a binary file,
+// if necessary. Then close the output file.
void
Close_task_runner::run(Workqueue*, const Task*)
{
- // If we need to compute a checksum for the BUILD if, we do so here.
- this->layout_->write_build_id(this->of_);
+ // At this point the multi-threaded part of the build ID computation,
+ // if any, is done. See Build_id_task_runner.
+ this->layout_->write_build_id(this->of_, this->array_of_hashes_,
+ this->size_of_hashes_);
// If we've been asked to create a binary file, we do so here.
if (this->options_->oformat_enum() != General_options::OBJECT_FORMAT_ELF)
this->layout_->write_binary(this->of_);
+ if (this->options_->dependency_file())
+ File_read::write_dependency_file(this->options_->dependency_file(),
+ this->options_->output_file_name());
+
this->of_->close();
}
unsigned int shndx,
const char* name,
const elfcpp::Shdr<32, false>& shdr,
- unsigned int, unsigned int, off_t*);
+ unsigned int, unsigned int, unsigned int, off_t*);
#endif
#ifdef HAVE_TARGET_32_BIG
unsigned int shndx,
const char* name,
const elfcpp::Shdr<32, true>& shdr,
- unsigned int, unsigned int, off_t*);
+ unsigned int, unsigned int, unsigned int, off_t*);
#endif
#ifdef HAVE_TARGET_64_LITTLE
unsigned int shndx,
const char* name,
const elfcpp::Shdr<64, false>& shdr,
- unsigned int, unsigned int, off_t*);
+ unsigned int, unsigned int, unsigned int, off_t*);
#endif
#ifdef HAVE_TARGET_64_BIG
unsigned int shndx,
const char* name,
const elfcpp::Shdr<64, true>& shdr,
- unsigned int, unsigned int, off_t*);
+ unsigned int, unsigned int, unsigned int, off_t*);
#endif
#ifdef HAVE_TARGET_32_LITTLE
projects / thirdparty / binutils-gdb.git / blobdiff