#include "ehframe.h"
#include "compressed_output.h"
#include "reduced_debug_output.h"
+#include "object.h"
#include "reloc.h"
#include "descriptors.h"
#include "plugin.h"
off_t start = p->start_ > minoff ? p->start_ : minoff;
start = align_address(start, align);
off_t end = start + len;
+ if (end > p->end_ && p->end_ == this->length_ && this->extend_)
+ {
+ this->length_ = end;
+ p->end_ = end;
+ }
if (end <= p->end_)
{
if (p->start_ + 3 >= start && p->end_ <= end + 3)
return start;
}
}
+ if (this->extend_)
+ {
+ off_t start = align_address(this->length_, align);
+ this->length_ = start + len;
+ return start;
+ }
return -1;
}
any_postprocessing_sections_(false),
resized_signatures_(false),
have_stabstr_section_(false),
+ section_ordering_specified_(false),
incremental_inputs_(NULL),
record_output_section_data_from_script_(false),
script_output_section_data_list_(),
segment_states_(NULL),
relaxation_debug_check_(NULL),
+ input_section_position_(),
+ input_section_glob_(),
incremental_base_(NULL),
free_list_()
{
return NULL;
}
+// When we put a .ctors or .dtors section with more than one word into
+// a .init_array or .fini_array section, we need to reverse the words
+// in the .ctors/.dtors section. This is because .init_array executes
+// constructors front to back, where .ctors executes them back to
+// front, and vice-versa for .fini_array/.dtors. Although we do want
+// to remap .ctors/.dtors into .init_array/.fini_array because it can
+// be more efficient, we don't want to change the order in which
+// constructors/destructors are run. This set just keeps track of
+// these sections which need to be reversed. It is only changed by
+// Layout::layout. It should be a private member of Layout, but that
+// would require layout.h to #include object.h to get the definition
+// of Section_id.
+static Unordered_set<Section_id, Section_id_hash> ctors_sections_in_init_array;
+
+// Return whether OBJECT/SHNDX is a .ctors/.dtors section mapped to a
+// .init_array/.fini_array section.
+
+bool
+Layout::is_ctors_in_init_array(Relobj* relobj, unsigned int shndx) const
+{
+ return (ctors_sections_in_init_array.find(Section_id(relobj, shndx))
+ != ctors_sections_in_init_array.end());
+}
+
// Return the output section to use for section NAME with type TYPE
// and section flags FLAGS. NAME must be canonicalized in the string
// pool, and NAME_KEY is the key. ORDER is where this should appear
elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
Output_section_order order, bool is_relro)
{
+ elfcpp::Elf_Word lookup_type = type;
+
+ // For lookup purposes, treat INIT_ARRAY, FINI_ARRAY, and
+ // PREINIT_ARRAY like PROGBITS. This ensures that we combine
+ // .init_array, .fini_array, and .preinit_array sections by name
+ // whatever their type in the input file. We do this because the
+ // types are not always right in the input files.
+ if (lookup_type == elfcpp::SHT_INIT_ARRAY
+ || lookup_type == elfcpp::SHT_FINI_ARRAY
+ || lookup_type == elfcpp::SHT_PREINIT_ARRAY)
+ lookup_type = elfcpp::SHT_PROGBITS;
+
elfcpp::Elf_Xword lookup_flags = flags;
// Ignoring SHF_WRITE and SHF_EXECINSTR here means that we combine
// controlling this.
lookup_flags &= ~(elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
- const Key key(name_key, std::make_pair(type, lookup_flags));
+ const Key key(name_key, std::make_pair(lookup_type, lookup_flags));
const std::pair<Key, Output_section*> v(key, NULL);
std::pair<Section_name_map::iterator, bool> ins(
this->section_name_map_.insert(v));
// there should be an option to control this.
Output_section* os = NULL;
- if (type == elfcpp::SHT_PROGBITS)
+ if (lookup_type == elfcpp::SHT_PROGBITS)
{
if (flags == 0)
{
Output_section* same_name = this->find_output_section(name);
if (same_name != NULL
- && same_name->type() == elfcpp::SHT_PROGBITS
+ && (same_name->type() == elfcpp::SHT_PROGBITS
+ || same_name->type() == elfcpp::SHT_INIT_ARRAY
+ || same_name->type() == elfcpp::SHT_FINI_ARRAY
+ || same_name->type() == elfcpp::SHT_PREINIT_ARRAY)
&& (same_name->flags() & elfcpp::SHF_TLS) == 0)
os = same_name;
}
else if ((flags & elfcpp::SHF_TLS) == 0)
{
elfcpp::Elf_Xword zero_flags = 0;
- const Key zero_key(name_key, std::make_pair(type, zero_flags));
+ const Key zero_key(name_key, std::make_pair(lookup_type,
+ zero_flags));
Section_name_map::iterator p =
this->section_name_map_.find(zero_key);
if (p != this->section_name_map_.end())
if (is_input_section
&& !this->script_options_->saw_sections_clause()
&& !parameters->options().relocatable())
- name = Layout::output_section_name(name, &len);
+ name = Layout::output_section_name(relobj, name, &len);
Stringpool::Key name_key;
name = this->namepool_.add_with_length(name, len, true, &name_key);
if (!this->include_section(object, name, shdr))
return NULL;
- Output_section* os;
-
- // Sometimes .init_array*, .preinit_array* and .fini_array* do not have
- // correct section types. Force them here.
elfcpp::Elf_Word sh_type = shdr.get_sh_type();
- if (sh_type == elfcpp::SHT_PROGBITS)
- {
- static const char init_array_prefix[] = ".init_array";
- static const char preinit_array_prefix[] = ".preinit_array";
- static const char fini_array_prefix[] = ".fini_array";
- static size_t init_array_prefix_size = sizeof(init_array_prefix) - 1;
- static size_t preinit_array_prefix_size =
- sizeof(preinit_array_prefix) - 1;
- static size_t fini_array_prefix_size = sizeof(fini_array_prefix) - 1;
-
- if (strncmp(name, init_array_prefix, init_array_prefix_size) == 0)
- sh_type = elfcpp::SHT_INIT_ARRAY;
- else if (strncmp(name, preinit_array_prefix, preinit_array_prefix_size)
- == 0)
- sh_type = elfcpp::SHT_PREINIT_ARRAY;
- else if (strncmp(name, fini_array_prefix, fini_array_prefix_size) == 0)
- sh_type = elfcpp::SHT_FINI_ARRAY;
- }
// 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)
{
}
// By default the GNU linker sorts input sections whose names match
- // .ctor.*, .dtor.*, .init_array.*, or .fini_array.*. The sections
- // are sorted by name. This is used to implement constructor
- // priority ordering. We are compatible.
+ // .ctors.*, .dtors.*, .init_array.*, or .fini_array.*. The
+ // sections are sorted by name. This is used to implement
+ // constructor priority ordering. We are compatible. When we put
+ // .ctor sections in .init_array and .dtor sections in .fini_array,
+ // we must also sort plain .ctor and .dtor sections.
if (!this->script_options_->saw_sections_clause()
+ && !parameters->options().relocatable()
&& (is_prefix_of(".ctors.", name)
|| is_prefix_of(".dtors.", name)
|| is_prefix_of(".init_array.", name)
- || is_prefix_of(".fini_array.", name)))
+ || is_prefix_of(".fini_array.", name)
+ || (parameters->options().ctors_in_init_array()
+ && (strcmp(name, ".ctors") == 0
+ || strcmp(name, ".dtors") == 0))))
os->set_must_sort_attached_input_sections();
+ // If this is a .ctors or .ctors.* section being mapped to a
+ // .init_array section, or a .dtors or .dtors.* section being mapped
+ // to a .fini_array section, we will need to reverse the words if
+ // there is more than one. Record this section for later. See
+ // ctors_sections_in_init_array above.
+ if (!this->script_options_->saw_sections_clause()
+ && !parameters->options().relocatable()
+ && shdr.get_sh_size() > size / 8
+ && (((strcmp(name, ".ctors") == 0
+ || is_prefix_of(".ctors.", name))
+ && strcmp(os->name(), ".init_array") == 0)
+ || ((strcmp(name, ".dtors") == 0
+ || is_prefix_of(".dtors.", name))
+ && strcmp(os->name(), ".fini_array") == 0)))
+ ctors_sections_in_init_array.insert(Section_id(object, shndx));
+
// FIXME: Handle SHF_LINK_ORDER somewhere.
elfcpp::Elf_Xword orig_flags = os->flags();
unsigned int reloc_shndx, unsigned int reloc_type,
off_t* off)
{
- gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS);
+ gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS
+ || shdr.get_sh_type() == elfcpp::SHT_X86_64_UNWIND);
gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
- const char* const name = ".eh_frame";
- Output_section* os = this->choose_output_section(object, name,
- elfcpp::SHT_PROGBITS,
- elfcpp::SHF_ALLOC, false,
- ORDER_EHFRAME, false);
+ Output_section* os = this->make_eh_frame_section(object);
if (os == NULL)
return NULL;
- if (this->eh_frame_section_ == NULL)
- {
- this->eh_frame_section_ = os;
- this->eh_frame_data_ = new Eh_frame();
-
- // For incremental linking, we do not optimize .eh_frame sections
- // or create a .eh_frame_hdr section.
- if (parameters->options().eh_frame_hdr() && !parameters->incremental())
- {
- Output_section* hdr_os =
- this->choose_output_section(NULL, ".eh_frame_hdr",
- elfcpp::SHT_PROGBITS,
- elfcpp::SHF_ALLOC, false,
- ORDER_EHFRAME, false);
-
- if (hdr_os != NULL)
- {
- Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os,
- this->eh_frame_data_);
- hdr_os->add_output_section_data(hdr_posd);
-
- hdr_os->set_after_input_sections();
-
- if (!this->script_options_->saw_phdrs_clause())
- {
- Output_segment* hdr_oseg;
- hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME,
- elfcpp::PF_R);
- hdr_oseg->add_output_section_to_nonload(hdr_os,
- elfcpp::PF_R);
- }
-
- this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
- }
- }
- }
-
gold_assert(this->eh_frame_section_ == os);
elfcpp::Elf_Xword orig_flags = os->flags();
// 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, name, shdr, reloc_shndx,
- 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))
return os;
}
+// 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.
+ Output_section* os = this->choose_output_section(object, ".eh_frame",
+ elfcpp::SHT_PROGBITS,
+ elfcpp::SHF_ALLOC, false,
+ ORDER_EHFRAME, false);
+ if (os == NULL)
+ return NULL;
+
+ if (this->eh_frame_section_ == NULL)
+ {
+ this->eh_frame_section_ = os;
+ this->eh_frame_data_ = new Eh_frame();
+
+ // For incremental linking, we do not optimize .eh_frame sections
+ // or create a .eh_frame_hdr section.
+ if (parameters->options().eh_frame_hdr() && !parameters->incremental())
+ {
+ Output_section* hdr_os =
+ this->choose_output_section(NULL, ".eh_frame_hdr",
+ elfcpp::SHT_PROGBITS,
+ elfcpp::SHF_ALLOC, false,
+ ORDER_EHFRAME, false);
+
+ if (hdr_os != NULL)
+ {
+ Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os,
+ this->eh_frame_data_);
+ hdr_os->add_output_section_data(hdr_posd);
+
+ hdr_os->set_after_input_sections();
+
+ if (!this->script_options_->saw_phdrs_clause())
+ {
+ Output_segment* hdr_oseg;
+ hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME,
+ elfcpp::PF_R);
+ hdr_oseg->add_output_section_to_nonload(hdr_os,
+ elfcpp::PF_R);
+ }
+
+ this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
+ }
+ }
+ }
+
+ return os;
+}
+
+// Add an exception frame for a PLT. This is called from target code.
+
+void
+Layout::add_eh_frame_for_plt(Output_data* plt, const unsigned char* cie_data,
+ size_t cie_length, const unsigned char* fde_data,
+ size_t fde_length)
+{
+ if (parameters->incremental())
+ {
+ // FIXME: Maybe this could work some day....
+ return;
+ }
+ Output_section* os = this->make_eh_frame_section(NULL);
+ if (os == NULL)
+ return;
+ this->eh_frame_data_->add_ehframe_for_plt(plt, cie_data, cie_length,
+ fde_data, fde_length);
+ if (!this->added_eh_frame_data_)
+ {
+ os->add_output_section_data(this->eh_frame_data_);
+ this->added_eh_frame_data_ = true;
+ }
+}
+
// Add POSD to an output section using NAME, TYPE, and FLAGS. Return
// the output section.
}
else
{
+ // Sometimes .init_array*, .preinit_array* and .fini_array* do
+ // not have correct section types. Force them here.
+ if (type == elfcpp::SHT_PROGBITS)
+ {
+ if (is_prefix_of(".init_array", name))
+ type = elfcpp::SHT_INIT_ARRAY;
+ else if (is_prefix_of(".preinit_array", name))
+ type = elfcpp::SHT_PREINIT_ARRAY;
+ else if (is_prefix_of(".fini_array", name))
+ type = elfcpp::SHT_FINI_ARRAY;
+ }
+
// FIXME: const_cast is ugly.
Target* target = const_cast<Target*>(¶meters->target());
os = target->make_output_section(name, type, flags);
// do the same. We need to know that this might happen before we
// attach any input sections.
if (!this->script_options_->saw_sections_clause()
- && (strcmp(name, ".ctors") == 0
- || strcmp(name, ".dtors") == 0
- || strcmp(name, ".init_array") == 0
- || strcmp(name, ".fini_array") == 0))
+ && !parameters->options().relocatable()
+ && (strcmp(name, ".init_array") == 0
+ || strcmp(name, ".fini_array") == 0
+ || (!parameters->options().ctors_in_init_array()
+ && (strcmp(name, ".ctors") == 0
+ || strcmp(name, ".dtors") == 0))))
os->set_may_sort_attached_input_sections();
// Check for .stab*str sections, as .stab* sections need to link to
&& strcmp(name + strlen(name) - 3, "str") == 0)
this->have_stabstr_section_ = true;
+ // During a full incremental link, we add patch space to most
+ // PROGBITS and NOBITS sections. Flag those that may be
+ // arbitrarily padded.
+ if ((type == elfcpp::SHT_PROGBITS || type == elfcpp::SHT_NOBITS)
+ && order != ORDER_INTERP
+ && order != ORDER_INIT
+ && order != ORDER_PLT
+ && order != ORDER_FINI
+ && order != ORDER_RELRO_LAST
+ && order != ORDER_NON_RELRO_FIRST
+ && strcmp(name, ".ctors") != 0
+ && strcmp(name, ".dtors") != 0
+ && strcmp(name, ".jcr") != 0)
+ os->set_is_patch_space_allowed();
+
// If we have already attached the sections to segments, then we
// need to attach this one now. This happens for sections created
// directly by the linker.
false, ORDER_RELRO,
true);
- this->dynamic_symbol_ =
- symtab->define_in_output_data("_DYNAMIC", NULL, Symbol_table::PREDEFINED,
- this->dynamic_section_, 0, 0,
- elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
- elfcpp::STV_HIDDEN, 0, false, false);
+ // A linker script may discard .dynamic, so check for NULL.
+ if (this->dynamic_section_ != NULL)
+ {
+ this->dynamic_symbol_ =
+ symtab->define_in_output_data("_DYNAMIC", NULL,
+ Symbol_table::PREDEFINED,
+ this->dynamic_section_, 0, 0,
+ elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
+ elfcpp::STV_HIDDEN, 0, false, false);
- this->dynamic_data_ = new Output_data_dynamic(&this->dynpool_);
+ this->dynamic_data_ = new Output_data_dynamic(&this->dynpool_);
- this->dynamic_section_->add_output_section_data(this->dynamic_data_);
+ this->dynamic_section_->add_output_section_data(this->dynamic_data_);
+ }
}
// For each output section whose name can be represented as C symbol,
// 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())
- load_seg = NULL;
+ if (parameters->options().user_set_Ttext()
+ && parameters->options().Ttext() % target->common_pagesize() != 0)
+ {
+ load_seg = NULL;
+ phdr_seg = NULL;
+ }
gold_assert(phdr_seg == NULL
|| load_seg != NULL
}
// Read the sequence of input sections from the file specified with
-// --section-ordering-file.
+// option --section-ordering-file.
void
Layout::read_layout_from_file()
std::getline(in, line); // this chops off the trailing \n, if any
unsigned int position = 1;
+ this->set_section_ordering_specified();
while (in)
{
// Return whether SEG1 should be before SEG2 in the output file. This
// is based entirely on the segment type and flags. When this is
-// called the segment addresses has normally not yet been set.
+// called the segment addresses have normally not yet been set.
bool
Layout::segment_precedes(const Output_segment* seg1,
return (flags1 & elfcpp::PF_R) == 0;
// We shouldn't get here--we shouldn't create segments which we
- // can't distinguish.
- gold_unreachable();
+ // can't distinguish. Unless of course we are using a weird linker
+ // script.
+ gold_assert(this->script_options_->saw_phdrs_clause());
+ return false;
}
// Increase OFF so that it is congruent to ADDR modulo ABI_PAGESIZE.
Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
unsigned int* pshndx)
{
- // Sort them into the final order.
- std::sort(this->segment_list_.begin(), this->segment_list_.end(),
- Layout::Compare_segments());
+ // Sort them into the final order. We use a stable sort so that we
+ // don't randomize the order of indistinguishable segments created
+ // by linker scripts.
+ std::stable_sort(this->segment_list_.begin(), this->segment_list_.end(),
+ Layout::Compare_segments(this));
// Find the PT_LOAD segments, and set their addresses and offsets
// and their section's addresses and offsets.
ORDER_DYNAMIC_LINKER,
false);
- Output_section_data* odata = new Output_data_fixed_space(index * symsize,
- align,
- "** dynsym");
- dynsym->add_output_section_data(odata);
+ // Check for NULL as a linker script may discard .dynsym.
+ if (dynsym != NULL)
+ {
+ Output_section_data* odata = new Output_data_fixed_space(index * symsize,
+ align,
+ "** dynsym");
+ dynsym->add_output_section_data(odata);
- dynsym->set_info(local_symcount);
- dynsym->set_entsize(symsize);
- dynsym->set_addralign(align);
+ dynsym->set_info(local_symcount);
+ dynsym->set_entsize(symsize);
+ dynsym->set_addralign(align);
- this->dynsym_section_ = dynsym;
+ this->dynsym_section_ = dynsym;
+ }
Output_data_dynamic* const odyn = this->dynamic_data_;
- odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
- odyn->add_constant(elfcpp::DT_SYMENT, symsize);
+ if (odyn != NULL)
+ {
+ odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
+ odyn->add_constant(elfcpp::DT_SYMENT, symsize);
+ }
// If there are more than SHN_LORESERVE allocated sections, we
// create a .dynsym_shndx section. It is possible that we don't
elfcpp::SHF_ALLOC,
false, ORDER_DYNAMIC_LINKER, false);
- this->dynsym_xindex_ = new Output_symtab_xindex(index);
+ if (dynsym_xindex != NULL)
+ {
+ this->dynsym_xindex_ = new Output_symtab_xindex(index);
- dynsym_xindex->add_output_section_data(this->dynsym_xindex_);
+ dynsym_xindex->add_output_section_data(this->dynsym_xindex_);
- dynsym_xindex->set_link_section(dynsym);
- dynsym_xindex->set_addralign(4);
- dynsym_xindex->set_entsize(4);
+ dynsym_xindex->set_link_section(dynsym);
+ dynsym_xindex->set_addralign(4);
+ dynsym_xindex->set_entsize(4);
- dynsym_xindex->set_after_input_sections();
+ dynsym_xindex->set_after_input_sections();
- // This tells the driver code to wait until the symbol table has
- // written out before writing out the postprocessing sections,
- // including the .dynsym_shndx section.
- this->any_postprocessing_sections_ = true;
+ // This tells the driver code to wait until the symbol table
+ // has written out before writing out the postprocessing
+ // sections, including the .dynsym_shndx section.
+ this->any_postprocessing_sections_ = true;
+ }
}
// Create the dynamic string table section.
ORDER_DYNAMIC_LINKER,
false);
- Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
- dynstr->add_output_section_data(strdata);
+ if (dynstr != NULL)
+ {
+ Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
+ dynstr->add_output_section_data(strdata);
- dynsym->set_link_section(dynstr);
- this->dynamic_section_->set_link_section(dynstr);
+ if (dynsym != NULL)
+ dynsym->set_link_section(dynstr);
+ if (this->dynamic_section_ != NULL)
+ this->dynamic_section_->set_link_section(dynstr);
- odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
- odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
+ if (odyn != NULL)
+ {
+ odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
+ odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
+ }
- *pdynstr = dynstr;
+ *pdynstr = dynstr;
+ }
// Create the hash tables.
hashlen,
align,
"** hash");
- hashsec->add_output_section_data(hashdata);
+ if (hashsec != NULL && hashdata != NULL)
+ hashsec->add_output_section_data(hashdata);
- hashsec->set_link_section(dynsym);
- hashsec->set_entsize(4);
+ if (hashsec != NULL)
+ {
+ if (dynsym != NULL)
+ hashsec->set_link_section(dynsym);
+ hashsec->set_entsize(4);
+ }
- odyn->add_section_address(elfcpp::DT_HASH, hashsec);
+ if (odyn != NULL)
+ odyn->add_section_address(elfcpp::DT_HASH, hashsec);
}
if (strcmp(parameters->options().hash_style(), "gnu") == 0
hashlen,
align,
"** hash");
- hashsec->add_output_section_data(hashdata);
+ if (hashsec != NULL && hashdata != NULL)
+ hashsec->add_output_section_data(hashdata);
- hashsec->set_link_section(dynsym);
+ if (hashsec != NULL)
+ {
+ 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);
+ // 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);
- odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
+ if (odyn != NULL)
+ odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
+ }
}
}
Layout::assign_local_dynsym_offsets(const Input_objects* input_objects)
{
Output_section* dynsym = this->dynsym_section_;
- gold_assert(dynsym != NULL);
+ if (dynsym == NULL)
+ return;
off_t off = dynsym->offset();
ORDER_DYNAMIC_LINKER,
false);
- unsigned char* vbuf;
- unsigned int vsize;
- versions->symbol_section_contents<size, big_endian>(symtab, &this->dynpool_,
- local_symcount,
- dynamic_symbols,
- &vbuf, &vsize);
-
- Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2,
- "** versions");
-
- vsec->add_output_section_data(vdata);
- vsec->set_entsize(2);
- vsec->set_link_section(this->dynsym_section_);
+ // Check for NULL since a linker script may discard this section.
+ if (vsec != NULL)
+ {
+ unsigned char* vbuf;
+ unsigned int vsize;
+ versions->symbol_section_contents<size, big_endian>(symtab,
+ &this->dynpool_,
+ local_symcount,
+ dynamic_symbols,
+ &vbuf, &vsize);
+
+ Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2,
+ "** versions");
+
+ vsec->add_output_section_data(vdata);
+ vsec->set_entsize(2);
+ vsec->set_link_section(this->dynsym_section_);
+ }
Output_data_dynamic* const odyn = this->dynamic_data_;
- odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
+ if (odyn != NULL && vsec != NULL)
+ odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
if (versions->any_defs())
{
Output_section* vdsec;
- vdsec= this->choose_output_section(NULL, ".gnu.version_d",
- elfcpp::SHT_GNU_verdef,
- elfcpp::SHF_ALLOC,
- false, ORDER_DYNAMIC_LINKER, false);
+ vdsec = this->choose_output_section(NULL, ".gnu.version_d",
+ elfcpp::SHT_GNU_verdef,
+ elfcpp::SHF_ALLOC,
+ false, ORDER_DYNAMIC_LINKER, false);
- unsigned char* vdbuf;
- unsigned int vdsize;
- unsigned int vdentries;
- versions->def_section_contents<size, big_endian>(&this->dynpool_, &vdbuf,
- &vdsize, &vdentries);
+ if (vdsec != NULL)
+ {
+ unsigned char* vdbuf;
+ unsigned int vdsize;
+ unsigned int vdentries;
+ versions->def_section_contents<size, big_endian>(&this->dynpool_,
+ &vdbuf, &vdsize,
+ &vdentries);
- Output_section_data* vddata =
- new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs");
+ Output_section_data* vddata =
+ new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs");
- vdsec->add_output_section_data(vddata);
- vdsec->set_link_section(dynstr);
- vdsec->set_info(vdentries);
+ vdsec->add_output_section_data(vddata);
+ vdsec->set_link_section(dynstr);
+ vdsec->set_info(vdentries);
- odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
- odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
+ if (odyn != NULL)
+ {
+ odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
+ odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
+ }
+ }
}
if (versions->any_needs())
elfcpp::SHF_ALLOC,
false, ORDER_DYNAMIC_LINKER, false);
- unsigned char* vnbuf;
- unsigned int vnsize;
- unsigned int vnentries;
- versions->need_section_contents<size, big_endian>(&this->dynpool_,
- &vnbuf, &vnsize,
- &vnentries);
+ if (vnsec != NULL)
+ {
+ unsigned char* vnbuf;
+ unsigned int vnsize;
+ unsigned int vnentries;
+ versions->need_section_contents<size, big_endian>(&this->dynpool_,
+ &vnbuf, &vnsize,
+ &vnentries);
- Output_section_data* vndata =
- new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs");
+ Output_section_data* vndata =
+ new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs");
- vnsec->add_output_section_data(vndata);
- vnsec->set_link_section(dynstr);
- vnsec->set_info(vnentries);
+ vnsec->add_output_section_data(vndata);
+ vnsec->set_link_section(dynstr);
+ vnsec->set_info(vnentries);
- odyn->add_section_address(elfcpp::DT_VERNEED, vnsec);
- odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries);
+ if (odyn != NULL)
+ {
+ odyn->add_section_address(elfcpp::DT_VERNEED, vnsec);
+ odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries);
+ }
+ }
}
}
elfcpp::SHF_ALLOC,
false, ORDER_INTERP,
false);
- osec->add_output_section_data(odata);
+ if (osec != NULL)
+ osec->add_output_section_data(odata);
}
// Add dynamic tags for the PLT and the dynamic relocs. This is
// some targets have multiple reloc sections in PLT_REL.
// If DYN_REL is not NULL, it is used for DT_REL/DT_RELA,
-// DT_RELSZ/DT_RELASZ, DT_RELENT/DT_RELAENT.
+// DT_RELSZ/DT_RELASZ, DT_RELENT/DT_RELAENT. Again we use the output
+// section.
// If ADD_DEBUG is true, we add a DT_DEBUG entry when generating an
// executable.
if (dyn_rel != NULL && dyn_rel->output_section() != NULL)
{
odyn->add_section_address(use_rel ? elfcpp::DT_REL : elfcpp::DT_RELA,
- dyn_rel);
- if (plt_rel != NULL && dynrel_includes_plt)
+ dyn_rel->output_section());
+ if (plt_rel != NULL
+ && plt_rel->output_section() != NULL
+ && dynrel_includes_plt)
odyn->add_section_size(use_rel ? elfcpp::DT_RELSZ : elfcpp::DT_RELASZ,
- dyn_rel, plt_rel);
+ dyn_rel->output_section(),
+ plt_rel->output_section());
else
odyn->add_section_size(use_rel ? elfcpp::DT_RELSZ : elfcpp::DT_RELASZ,
- dyn_rel);
+ dyn_rel->output_section());
const int size = parameters->target().get_size();
elfcpp::DT rel_tag;
int rel_size;
Layout::finish_dynamic_section(const Input_objects* input_objects,
const Symbol_table* symtab)
{
- if (!this->script_options_->saw_phdrs_clause())
+ if (!this->script_options_->saw_phdrs_clause()
+ && this->dynamic_section_ != NULL)
{
Output_segment* oseg = this->make_output_segment(elfcpp::PT_DYNAMIC,
(elfcpp::PF_R
}
Output_data_dynamic* const odyn = this->dynamic_data_;
+ if (odyn == NULL)
+ return;
for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
p != input_objects->dynobj_end();
}
}
- // Add a DT_FLAGS entry. We add it even if no flags are set so that
- // post-link tools can easily modify these flags if desired.
+ if (parameters->options().filter() != NULL)
+ odyn->add_string(elfcpp::DT_FILTER, parameters->options().filter());
+ if (parameters->options().any_auxiliary())
+ {
+ for (options::String_set::const_iterator p =
+ parameters->options().auxiliary_begin();
+ p != parameters->options().auxiliary_end();
+ ++p)
+ odyn->add_string(elfcpp::DT_AUXILIARY, *p);
+ }
+
+ // Add a DT_FLAGS entry if necessary.
unsigned int flags = 0;
if (have_textrel)
{
flags |= elfcpp::DF_1_ORIGIN;
if (parameters->options().now())
flags |= elfcpp::DF_1_NOW;
+ if (parameters->options().Bgroup())
+ flags |= elfcpp::DF_1_GROUP;
if (flags != 0)
odyn->add_constant(elfcpp::DT_FLAGS_1, flags);
}
Layout::set_dynamic_symbol_size(const Symbol_table* symtab)
{
Output_data_dynamic* const odyn = this->dynamic_data_;
+ if (odyn == NULL)
+ return;
odyn->finalize_data_size();
+ if (this->dynamic_symbol_ == NULL)
+ return;
off_t data_size = odyn->data_size();
const int size = parameters->target().get_size();
if (size == 32)
const Layout::Section_name_mapping Layout::section_name_mapping[] =
{
MAPPING_INIT(".text.", ".text"),
- MAPPING_INIT(".ctors.", ".ctors"),
- MAPPING_INIT(".dtors.", ".dtors"),
MAPPING_INIT(".rodata.", ".rodata"),
MAPPING_INIT(".data.rel.ro.local", ".data.rel.ro.local"),
MAPPING_INIT(".data.rel.ro", ".data.rel.ro"),
// length of NAME.
const char*
-Layout::output_section_name(const char* name, size_t* plen)
+Layout::output_section_name(const Relobj* relobj, const char* name,
+ size_t* plen)
{
// gcc 4.3 generates the following sorts of section names when it
// needs a section name specific to a function:
}
}
+ // 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.
+ if (is_prefix_of(".ctors.", name) || is_prefix_of(".dtors.", name))
+ {
+ if (parameters->options().ctors_in_init_array())
+ {
+ *plen = 11;
+ return name[1] == 'c' ? ".init_array" : ".fini_array";
+ }
+ else
+ {
+ *plen = 6;
+ return name[1] == 'c' ? ".ctors" : ".dtors";
+ }
+ }
+ if (parameters->options().ctors_in_init_array()
+ && (strcmp(name, ".ctors") == 0 || strcmp(name, ".dtors") == 0))
+ {
+ // To make .init_array/.fini_array work with gcc we must exclude
+ // .ctors and .dtors sections from the crtbegin and crtend
+ // files.
+ if (relobj == NULL
+ || (!Layout::match_file_name(relobj, "crtbegin")
+ && !Layout::match_file_name(relobj, "crtend")))
+ {
+ *plen = 11;
+ return name[1] == 'c' ? ".init_array" : ".fini_array";
+ }
+ }
+
return name;
}
+// Return true if RELOBJ is an input file whose base name matches
+// FILE_NAME. The base name must have an extension of ".o", and must
+// be exactly FILE_NAME.o or FILE_NAME, one character, ".o". This is
+// to match crtbegin.o as well as crtbeginS.o without getting confused
+// by other possibilities. Overall matching the file name this way is
+// a dreadful hack, but the GNU linker does it in order to better
+// support gcc, and we need to be compatible.
+
+bool
+Layout::match_file_name(const Relobj* relobj, const char* match)
+{
+ const std::string& file_name(relobj->name());
+ const char* base_name = lbasename(file_name.c_str());
+ size_t match_len = strlen(match);
+ if (strncmp(base_name, match, match_len) != 0)
+ return false;
+ size_t base_len = strlen(base_name);
+ if (base_len != match_len + 2 && base_len != match_len + 3)
+ return false;
+ return memcmp(base_name + base_len - 2, ".o", 2) == 0;
+}
+
// Check if a comdat group or .gnu.linkonce section with the given
// NAME is selected for the link. If there is already a section,
// *KEPT_SECTION is set to point to the existing section and the
return 0;
}
+// Return the section index of the normal symbol table. It may have
+// been stripped by the -s/--strip-all option.
+
+unsigned int
+Layout::symtab_section_shndx() const
+{
+ if (this->symtab_section_ != NULL)
+ return this->symtab_section_->out_shndx();
+ return 0;
+}
+
// Write out the Output_sections. Most won't have anything to write,
// since most of the data will come from input sections which are
// handled elsewhere. But some Output_sections do have Output_data.
projects / deliverable / binutils-gdb.git / blobdiff