// output.cc -- manage the output file for gold
-// Copyright (C) 2006-2015 Free Software Foundation, Inc.
+// Copyright (C) 2006-2016 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
os->set_should_link_to_dynsym();
}
+// Standard relocation writer, which just calls Output_reloc::write().
+
+template<int sh_type, bool dynamic, int size, bool big_endian>
+struct Output_reloc_writer
+{
+ typedef Output_reloc<sh_type, dynamic, size, big_endian> Output_reloc_type;
+ typedef std::vector<Output_reloc_type> Relocs;
+
+ static void
+ write(typename Relocs::const_iterator p, unsigned char* pov)
+ { p->write(pov); }
+};
+
// Write out relocation data.
template<int sh_type, bool dynamic, int size, bool big_endian>
Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
Output_file* of)
{
- const off_t off = this->offset();
- const off_t oview_size = this->data_size();
- unsigned char* const oview = of->get_output_view(off, oview_size);
-
- if (this->sort_relocs())
- {
- gold_assert(dynamic);
- std::sort(this->relocs_.begin(), this->relocs_.end(),
- Sort_relocs_comparison());
- }
-
- unsigned char* pov = oview;
- for (typename Relocs::const_iterator p = this->relocs_.begin();
- p != this->relocs_.end();
- ++p)
- {
- p->write(pov);
- pov += reloc_size;
- }
-
- gold_assert(pov - oview == oview_size);
-
- of->write_output_view(off, oview_size, oview);
-
- // We no longer need the relocation entries.
- this->relocs_.clear();
+ typedef Output_reloc_writer<sh_type, dynamic, size, big_endian> Writer;
+ this->do_write_generic<Writer>(of);
}
// Class Output_relocatable_relocs.
val = parameters->target().plt_address_for_local(object, lsi);
else
{
- uint64_t lval = object->local_symbol_value(lsi, 0);
+ uint64_t lval = object->local_symbol_value(lsi, this->addend_);
val = convert_types<Valtype, uint64_t>(lval);
if (this->use_plt_or_tls_offset_ && is_tls)
val += parameters->target().tls_offset_for_local(object, lsi,
return true;
}
+// Add an entry for a local symbol plus ADDEND to the GOT. This returns
+// true if this is a new GOT entry, false if the symbol already has a GOT
+// entry.
+
+template<int got_size, bool big_endian>
+bool
+Output_data_got<got_size, big_endian>::add_local(
+ Relobj* object,
+ unsigned int symndx,
+ unsigned int got_type,
+ uint64_t addend)
+{
+ if (object->local_has_got_offset(symndx, got_type, addend))
+ return false;
+
+ unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
+ false, addend));
+ object->set_local_got_offset(symndx, got_type, got_offset, addend);
+ return true;
+}
+
// Like add_local, but use the PLT offset.
template<int got_size, bool big_endian>
rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0);
}
+// Add an entry for a local symbol plus ADDEND to the GOT, and add a dynamic
+// relocation of type R_TYPE for the GOT entry.
+
+template<int got_size, bool big_endian>
+void
+Output_data_got<got_size, big_endian>::add_local_with_rel(
+ Relobj* object,
+ unsigned int symndx,
+ unsigned int got_type,
+ Output_data_reloc_generic* rel_dyn,
+ unsigned int r_type, uint64_t addend)
+{
+ if (object->local_has_got_offset(symndx, got_type, addend))
+ return;
+
+ unsigned int got_offset = this->add_got_entry(Got_entry());
+ object->set_local_got_offset(symndx, got_type, got_offset, addend);
+ rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset,
+ addend);
+}
+
// Add a pair of entries for a local symbol to the GOT, and add
// a dynamic relocation of type R_TYPE using the section symbol of
// the output section to which input section SHNDX maps, on the first.
rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0);
}
+// Add a pair of entries for a local symbol plus ADDEND to the GOT, and add
+// a dynamic relocation of type R_TYPE using the section symbol of
+// the output section to which input section SHNDX maps, on the first.
+// The first got entry will have a value of zero, the second the
+// value of the local symbol.
+template<int got_size, bool big_endian>
+void
+Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
+ Relobj* object,
+ unsigned int symndx,
+ unsigned int shndx,
+ unsigned int got_type,
+ Output_data_reloc_generic* rel_dyn,
+ unsigned int r_type, uint64_t addend)
+{
+ if (object->local_has_got_offset(symndx, got_type, addend))
+ return;
+
+ unsigned int got_offset =
+ this->add_got_entry_pair(Got_entry(),
+ Got_entry(object, symndx, false, addend));
+ object->set_local_got_offset(symndx, got_type, got_offset, addend);
+ Output_section* os = object->output_section(shndx);
+ rel_dyn->add_output_section_generic(os, r_type, this, got_offset, addend);
+}
+
// Add a pair of entries for a local symbol to the GOT, and add
// a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
// The first got entry will have a value of zero, the second the
gold_unreachable();
}
+// Get a dynamic entry offset.
+
+unsigned int
+Output_data_dynamic::get_entry_offset(elfcpp::DT tag) const
+{
+ int dyn_size;
+
+ if (parameters->target().get_size() == 32)
+ dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
+ else if (parameters->target().get_size() == 64)
+ dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
+ else
+ gold_unreachable();
+
+ for (size_t i = 0; i < entries_.size(); ++i)
+ if (entries_[i].tag() == tag)
+ return i * dyn_size;
+
+ return -1U;
+}
+
// Set the final data size.
void
}
}
-// Return whether this is the merge section for the input section
-// SHNDX in OBJECT.
-
-inline bool
-Output_section::Input_section::is_merge_section_for(const Relobj* object,
- unsigned int shndx) const
-{
- if (this->is_input_section())
- return false;
- return this->u2_.posd->is_merge_section_for(object, shndx);
-}
-
// Write out the data. We don't have to do anything for an input
// section--they are handled via Object::relocate--but this is where
// we write out the data for an Output_section_data.
this->lookup_maps_->add_merge_section(msp, pomb);
}
- // Add input section to new merge section and link input section to new
- // merge section in map.
- this->lookup_maps_->add_merge_input_section(object, shndx, pomb);
return true;
}
else
// Find the merge section into which an input section with index SHNDX in
// OBJECT has been added. Return NULL if none found.
-Output_section_data*
+const Output_section_data*
Output_section::find_merge_section(const Relobj* object,
unsigned int shndx) const
{
- if (!this->lookup_maps_->is_valid())
- this->build_lookup_maps();
- return this->lookup_maps_->find_merge_section(object, shndx);
+ return object->find_merge_section(shndx);
}
-// Build the lookup maps for merge and relaxed sections. This is needs
-// to be declared as a const methods so that it is callable with a const
+// Build the lookup maps for relaxed sections. This needs
+// to be declared as a const method so that it is callable with a const
// Output_section pointer. The method only updates states of the maps.
void
p != this->input_sections_.end();
++p)
{
- if (p->is_merge_section())
- {
- Output_merge_base* pomb = p->output_merge_base();
- Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
- pomb->addralign());
- this->lookup_maps_->add_merge_section(msp, pomb);
- for (Output_merge_base::Input_sections::const_iterator is =
- pomb->input_sections_begin();
- is != pomb->input_sections_end();
- ++is)
- {
- const Const_section_id& csid = *is;
- this->lookup_maps_->add_merge_input_section(csid.first,
- csid.second, pomb);
- }
-
- }
- else if (p->is_relaxed_input_section())
+ if (p->is_relaxed_input_section())
{
Output_relaxed_input_section* poris = p->relaxed_input_section();
this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
{
section_offset_type output_offset;
bool found = posd->output_offset(object, shndx, offset, &output_offset);
- gold_assert(found);
+ // By default we assume that the address is mapped. See comment at the
+ // end.
+ if (!found)
+ return true;
return output_offset != -1;
}
unsigned int shndx,
uint64_t* paddr) const
{
+ const Output_section_data* data = this->find_merge_section(object, shndx);
+ if (data == NULL)
+ return false;
+
// FIXME: This becomes a bottle-neck if we have many relaxed sections.
// Looking up the merge section map does not always work as we sometimes
// find a merge section without its address set.
// method to get the output offset of input offset 0.
// Unfortunately we don't know for sure that input offset 0 is
// mapped at all.
- if (p->is_merge_section_for(object, shndx))
+ if (!p->is_input_section() && p->output_section_data() == data)
{
*paddr = addr;
return true;
if (p->is_input_section()
|| p->is_relaxed_input_section())
{
- Object* obj = (p->is_input_section()
+ Relobj* obj = (p->is_input_section()
? p->relobj()
: p->relaxed_input_section()->relobj());
unsigned int shndx = p->shndx();
// Update fast lookup maps if necessary.
if (this->lookup_maps_->is_valid())
{
- if (sis.is_merge_section())
- {
- Output_merge_base* pomb = sis.output_merge_base();
- Merge_section_properties msp(pomb->is_string(), pomb->entsize(),
- pomb->addralign());
- this->lookup_maps_->add_merge_section(msp, pomb);
- for (Output_merge_base::Input_sections::const_iterator p =
- pomb->input_sections_begin();
- p != pomb->input_sections_end();
- ++p)
- this->lookup_maps_->add_merge_input_section(p->first, p->second,
- pomb);
- }
- else if (sis.is_relaxed_input_section())
+ if (sis.is_relaxed_input_section())
{
Output_relaxed_input_section* poris = sis.relaxed_input_section();
this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
{
for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
{
- if (i == static_cast<int>(ORDER_TLS_DATA)
- || i == static_cast<int>(ORDER_TLS_BSS))
+ if (i == static_cast<int>(ORDER_TLS_BSS))
continue;
const Output_data_list* pdl = &this->output_lists_[i];
if (!pdl->empty())
align = max_align;
in_tls = false;
}
- relro_size = align_address(relro_size, align);
// Ignore the size of the .tbss section.
if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)
&& (*p)->is_section_type(elfcpp::SHT_NOBITS))
continue;
+ relro_size = align_address(relro_size, align);
if ((*p)->is_address_valid())
relro_size += (*p)->data_size();
else