// object.cc -- support for an object file for linking in gold
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
-// Free Software Foundation, Inc.
+// Copyright (C) 2006-2015 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include "plugin.h"
#include "compressed_output.h"
#include "incremental.h"
+#include "merge.h"
namespace gold
{
// Class Relobj
+template<int size>
+void
+Relobj::initialize_input_to_output_map(unsigned int shndx,
+ typename elfcpp::Elf_types<size>::Elf_Addr starting_address,
+ Unordered_map<section_offset_type,
+ typename elfcpp::Elf_types<size>::Elf_Addr>* output_addresses) const {
+ Object_merge_map *map = this->object_merge_map_;
+ map->initialize_input_to_output_map<size>(shndx, starting_address,
+ output_addresses);
+}
+
+void
+Relobj::add_merge_mapping(Output_section_data *output_data,
+ unsigned int shndx, section_offset_type offset,
+ section_size_type length,
+ section_offset_type output_offset) {
+ if (this->object_merge_map_ == NULL)
+ {
+ this->object_merge_map_ = new Object_merge_map();
+ }
+
+ this->object_merge_map_->add_mapping(output_data, shndx, offset, length,
+ output_offset);
+}
+
+bool
+Relobj::merge_output_offset(unsigned int shndx, section_offset_type offset,
+ section_offset_type *poutput) const {
+ Object_merge_map* object_merge_map = this->object_merge_map_;
+ if (object_merge_map == NULL)
+ return false;
+ return object_merge_map->get_output_offset(shndx, offset, poutput);
+}
+
+bool
+Relobj::is_merge_section_for(const Output_section_data* output_data,
+ unsigned int shndx) const {
+ Object_merge_map* object_merge_map = this->object_merge_map_;
+ if (object_merge_map == NULL)
+ return false;
+ return object_merge_map->is_merge_section_for(output_data, shndx);
+
+}
+
// To copy the symbols data read from the file to a local data structure.
// This function is called from do_layout only while doing garbage
// collection.
|| (is_prefix_of(".sdata", name)
&& strstr(name, "personality"))
|| (is_prefix_of(".gnu.linkonce.d", name)
- && strstr(name, "personality")))
+ && strstr(name, "personality"))
+ || (is_prefix_of(".rodata", name)
+ && strstr(name, "nptl_version")))
{
return true;
}
}
}
+// Get the address of an output section.
+
+template<int size, bool big_endian>
+uint64_t
+Sized_relobj<size, big_endian>::do_output_section_address(
+ unsigned int shndx)
+{
+ // If the input file is linked as --just-symbols, the output
+ // section address is the input section address.
+ if (this->just_symbols())
+ return this->section_address(shndx);
+
+ const Output_section* os = this->do_output_section(shndx);
+ gold_assert(os != NULL);
+ return os->address();
+}
+
// Class Sized_relobj_file.
template<int size, bool big_endian>
kept_comdat_sections_(),
has_eh_frame_(false),
discarded_eh_frame_shndx_(-1U),
+ is_deferred_layout_(false),
deferred_layout_(),
deferred_layout_relocs_(),
compressed_sections_()
template<int size, bool big_endian>
void
Sized_relobj_file<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
+{
+ this->base_read_symbols(sd);
+}
+
+// Read the sections and symbols from an object file. This is common
+// code for all target-specific overrides of do_read_symbols().
+
+template<int size, bool big_endian>
+void
+Sized_relobj_file<size, big_endian>::base_read_symbols(Read_symbols_data* sd)
{
this->read_section_data(&this->elf_file_, sd);
{
parameters->options().plugins()->add_deferred_layout_object(this);
this->deferred_layout_.reserve(num_sections_to_defer);
+ this->is_deferred_layout_ = true;
}
// Whether we've seen a .note.GNU-stack section.
{
if (is_pass_one)
{
- out_sections[i] = reinterpret_cast<Output_section*>(1);
+ if (this->is_deferred_layout())
+ out_sections[i] = reinterpret_cast<Output_section*>(2);
+ else
+ out_sections[i] = reinterpret_cast<Output_section*>(1);
out_section_offsets[i] = invalid_address;
}
- else if (should_defer_layout)
+ else if (this->is_deferred_layout())
this->deferred_layout_.push_back(Deferred_layout(i, name,
pshdrs,
reloc_shndx[i],
symtab->icf()->get_folded_section(this, i);
Relobj* folded_obj =
reinterpret_cast<Relobj*>(folded.first);
- gold_info(_("%s: ICF folding section '%s' in file '%s'"
+ gold_info(_("%s: ICF folding section '%s' in file '%s' "
"into '%s' in file '%s'"),
program_name, this->section_name(i).c_str(),
this->name().c_str(),
}
// Defer layout here if input files are claimed by plugins. When gc
- // is turned on this function is called twice. For the second call
- // should_defer_layout should be false.
- if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
+ // is turned on this function is called twice; we only want to do this
+ // on the first pass.
+ if (!is_pass_two
+ && this->is_deferred_layout()
+ && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC))
{
- gold_assert(!is_pass_two);
this->deferred_layout_.push_back(Deferred_layout(i, name,
pshdrs,
reloc_shndx[i],
if (!is_pass_two)
layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this);
+ // Handle the .eh_frame sections after the other sections.
+ gold_assert(!is_pass_one || eh_frame_sections.empty());
+ for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
+ p != eh_frame_sections.end();
+ ++p)
+ {
+ unsigned int i = *p;
+ const unsigned char* pshdr;
+ pshdr = section_headers_data + i * This::shdr_size;
+ typename This::Shdr shdr(pshdr);
+
+ this->layout_eh_frame_section(layout,
+ symbols_data,
+ symbols_size,
+ symbol_names_data,
+ symbol_names_size,
+ i,
+ shdr,
+ reloc_shndx[i],
+ reloc_type[i]);
+ }
+
// When doing a relocatable link handle the reloc sections at the
// end. Garbage collection and Identical Code Folding is not
// turned on for relocatable code.
Output_section* data_section = out_sections[data_shndx];
if (data_section == reinterpret_cast<Output_section*>(2))
{
+ if (is_pass_two)
+ continue;
// The layout for the data section was deferred, so we need
// to defer the relocation section, too.
const char* name = pnames + shdr.get_sh_name();
out_section_offsets[i] = invalid_address;
}
- // Handle the .eh_frame sections at the end.
- gold_assert(!is_pass_one || eh_frame_sections.empty());
- for (std::vector<unsigned int>::const_iterator p = eh_frame_sections.begin();
- p != eh_frame_sections.end();
- ++p)
- {
- unsigned int i = *p;
- const unsigned char* pshdr;
- pshdr = section_headers_data + i * This::shdr_size;
- typename This::Shdr shdr(pshdr);
-
- this->layout_eh_frame_section(layout,
- symbols_data,
- symbols_size,
- symbol_names_data,
- symbol_names_size,
- i,
- shdr,
- reloc_shndx[i],
- reloc_type[i]);
- }
-
// When building a .gdb_index section, scan the .debug_info and
// .debug_types sections.
gold_assert(!is_pass_one
// Reading the symbols again here may be slow.
Read_symbols_data sd;
- this->read_symbols(&sd);
+ this->base_read_symbols(&sd);
this->layout_eh_frame_section(layout,
sd.symbols->data(),
sd.symbols_size,
lv_out->set_merged_symbol_value(msv);
}
}
- else if (lv_in->is_tls_symbol())
+ else if (lv_in->is_tls_symbol()
+ || (lv_in->is_section_symbol()
+ && (os->flags() & elfcpp::SHF_TLS)))
lv_out->set_output_value(os->tls_offset()
+ secoffset
+ lv_in->input_value());
dyn_oview = of->get_output_view(this->local_dynsym_offset_,
dyn_output_size);
- const Output_sections out_sections(this->output_sections());
+ const Output_sections& out_sections(this->output_sections());
gold_assert(this->local_values_.size() == loccount);
// Instantiate the templates we need.
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+template
+void
+Relobj::initialize_input_to_output_map<64>(unsigned int shndx,
+ elfcpp::Elf_types<64>::Elf_Addr starting_address,
+ Unordered_map<section_offset_type,
+ elfcpp::Elf_types<64>::Elf_Addr>* output_addresses) const;
+#endif
+
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
+template
+void
+Relobj::initialize_input_to_output_map<32>(unsigned int shndx,
+ elfcpp::Elf_types<32>::Elf_Addr starting_address,
+ Unordered_map<section_offset_type,
+ elfcpp::Elf_types<32>::Elf_Addr>* output_addresses) const;
+#endif
+
#ifdef HAVE_TARGET_32_LITTLE
template
void
#endif
#ifdef HAVE_TARGET_32_LITTLE
+template
+class Sized_relobj<32, false>;
+
template
class Sized_relobj_file<32, false>;
#endif
#ifdef HAVE_TARGET_32_BIG
+template
+class Sized_relobj<32, true>;
+
template
class Sized_relobj_file<32, true>;
#endif
#ifdef HAVE_TARGET_64_LITTLE
+template
+class Sized_relobj<64, false>;
+
template
class Sized_relobj_file<64, false>;
#endif
#ifdef HAVE_TARGET_64_BIG
+template
+class Sized_relobj<64, true>;
+
template
class Sized_relobj_file<64, true>;
#endif