// layout.cc -- lay out output file sections for gold
-// Copyright (C) 2006-2015 Free Software Foundation, Inc.
+// Copyright (C) 2006-2017 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"
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>
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);
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 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(),
+ os = this->make_output_section(name, sh_type, flags,
ORDER_INVALID, false);
}
else
{
os = this->choose_output_section(object, name, sh_type,
shdr.get_sh_flags(), true,
- ORDER_INVALID, false);
+ ORDER_INVALID, false, false,
+ true);
}
else
{
|| (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);
+ ORDER_INVALID, false, true, false);
else
{
const char* n = this->namepool_.add(name.c_str(), true, NULL);
Output_section* os = this->choose_output_section(object, ".eh_frame",
elfcpp::SHT_PROGBITS,
elfcpp::SHF_ALLOC, false,
- ORDER_EHFRAME, false);
+ ORDER_EHFRAME, false, false,
+ false);
if (os == NULL)
return NULL;
this->choose_output_section(NULL, ".eh_frame_hdr",
elfcpp::SHT_PROGBITS,
elfcpp::SHF_ALLOC, false,
- ORDER_EHFRAME, false);
+ ORDER_EHFRAME, false, false,
+ false);
if (hdr_os != NULL)
{
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;
Layout::create_notes()
{
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)
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.
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 (load_seg != NULL)
ehdr_start->set_output_segment(load_seg, Symbol::SEGMENT_START);
else
- ehdr_start->set_undefined();
+ ehdr_start->set_undefined();
}
// Set the file offsets of all the non-data sections we've seen so
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);
}
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;
// 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();
if (!is_stack_executable
- && this->input_requires_executable_stack_
- && parameters->options().warn_execstack())
+ && this->input_requires_executable_stack_
+ && parameters->options().warn_execstack())
gold_warning(_("one or more inputs require executable stack, "
- "but -z noexecstack was given"));
+ "but -z noexecstack was given"));
}
- else if (!this->input_with_gnu_stack_note_)
+ 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);
}
}
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();
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);
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, pdynamic_symbols,
- &this->dynpool_, pversions);
+ index = symtab->set_dynsym_indexes(index, &forced_local_count,
+ 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)
{
{
unsigned char* phash;
unsigned int hashlen;
- Dynobj::create_gnu_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, ".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,
{
unsigned char* phash;
unsigned int hashlen;
- Dynobj::create_elf_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, ".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);
- hashsec->set_entsize(4);
+ hashsec->set_entsize(parameters->target().hash_entry_size() / 8);
}
if (odyn != NULL)
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