old-cross-binutils/gold/copy-relocs.h
Ian Lance Taylor ef9beddf72 Handle output sections with more than 0x7fffffff bytes.
* object.h (class Relobj): Change map_to_output_ to
	output_sections_, and just keep a section pointer.  Change all
	uses.  Move comdat group support to Sized_relobj.
	(Relobj::is_section_specially_mapped): Remove.
	(Relobj::output_section): Remove poff parameter.  Change all
	callers.
	(Relobj::output_section_offset): New function.
	(Relobj::set_section_offset): Rewrite.
	(Relobj::map_to_output): Remove.
	(Relobj::output_sections): New function.
	(Relobj::do_output_section_offset): New pure virtual function.
	(Relobj::do_set_section_offset): Likewise.
	(class Sized_relobj): Add section_offsets_ field.  Add comdat
	group support from Relobj.  Update declarations.
	(Sized_relobj::get_output_section_offset): New function.
	(Sized_relobj::do_output_section_offset): New function.
	(Sized_relobj::do_set_section_offset): New function.
	* object.cc (Relobj::output_section_address): Remove.
	(Sized_relobj::Sized_relobj): Initialize new fields.
	(Sized_relobj::include_section_group): Cast find_kept_object to
	Sized_relobj.
	(Sized_relobj::include_linkonce_section): Likewise.
	(Sized_relobj::do_layout): Use separate arrays for output section
	and output offset.
	(Sized_relobj::do_count_local_symbols): Change map_to_output to
	output_sections.
	(Sized_relobj::do_finalize_local_symbols): Change map_to_output to
	output_sections and section_offsets.
	(Sized_relobj::write_local_symbols): Likewise.
	(map_to_kept_section): Compute output address directly.
	* reloc.cc (Sized_relobj::do_read_relocs): Change map_to_output to
	output_sections and section_offsets.
	(Sized_relobj::write_sections): Likewise.
	(Sized_relobj::relocate_sections): Likewise.
	* symtab.cc (sized_finalize_symbol): Use output_section_offset.
	* output.h (class Output_reloc): Update declarations.  Change
	u2_.relobj to Sized_relobj*.
	(class Output_data_reloc): Change add functions to use
	Sized_relobj*.
	* output.cc (Output_reloc::Output_reloc): Change relobj to
	Sized_relobj*.
	(Output_reloc::local_section_offset): Change return type to
	Elf_Addr.  Use get_output_section_offset.
	(Output_reloc::get_address): Likewise.
	(Output_section::is_input_address_mapped): Don't call
	is_section_specially_mapped.
	(Output_section::output_offset): Likewise.
	(Output_section::output_address): Likewise.
	(Output_section::starting_output_address): Likewise.
	* copy-relocs.cc (Copy_relocs::copy_reloc): Change object
	parameter to Sized_relobj*.
	(Copy_relocs::need_copy_reloc): Likewise.
	(Copy_relocs::save): Likewise.
	* copy-relocs.h (class Copy_relocs): Update declarations.
	(class Copy_relocs::Copy_reloc_entry): Change constructor to use
	Sized_relobj*.  Change relobj_ field to Sized_relobj*.
	* target-reloc.h (relocate_for_relocatable): Change
	offset_in_output_section type to Elf_Addr.  Change code that uses
	it as well.
	* layout.cc (Layout::layout): Always set *off.
	* mapfile.cc (Mapfile::print_input_section): Use
	output_section_offset.
	* i386.cc (Target_i386::copy_reloc): Change object parameter to
	Sized_relobj*.
	* powerpc.cc (Target_powerpc::copy_reloc): Likewise.
	* sparc.cc (Target_sparc::copy_reloc): Likewise.
	* x86_64.cc (Target_x86_64::copy_reloc): Likewise.
2008-07-10 23:01:20 +00:00

155 lines
5.5 KiB
C++

// copy-relocs.h -- handle COPY relocations for gold -*- C++ -*-
// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
// MA 02110-1301, USA.
#ifndef GOLD_COPY_RELOCS_H
#define GOLD_COPY_RELOCS_H
#include "elfcpp.h"
#include "reloc-types.h"
#include "output.h"
namespace gold
{
// This class is used to manage COPY relocations. We try to avoid
// them when possible. A COPY relocation may be required when an
// executable refers to a variable defined in a shared library. COPY
// relocations are problematic because they tie the executable to the
// exact size of the variable in the shared library. We can avoid
// them if all the references to the variable are in a writeable
// section. In that case we can simply use dynamic relocations.
// However, when scanning relocs, we don't know when we see the
// relocation whether we will be forced to use a COPY relocation or
// not. So we have to save the relocation during the reloc scanning,
// and then emit it as a dynamic relocation if necessary. This class
// implements that. It is used by the target specific code.
// The template parameter SH_TYPE is the type of the reloc section to
// be used for COPY relocs: elfcpp::SHT_REL or elfcpp::SHT_RELA.
template<int sh_type, int size, bool big_endian>
class Copy_relocs
{
private:
typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reloc;
public:
Copy_relocs(unsigned int copy_reloc_type)
: copy_reloc_type_(copy_reloc_type), dynbss_(NULL), entries_()
{ }
// This is called while scanning relocs if we see a relocation
// against a symbol which may force us to generate a COPY reloc.
// SYM is the symbol. OBJECT is the object whose relocs we are
// scanning. The relocation is being applied to section SHNDX in
// OBJECT. OUTPUT_SECTION is the output section where section SHNDX
// will wind up. REL is the reloc itself. The Output_data_reloc
// section is where the dynamic relocs are put.
void
copy_reloc(Symbol_table*, Layout*, Sized_symbol<size>* sym,
Sized_relobj<size, big_endian>* object,
unsigned int shndx, Output_section* output_section,
const Reloc& rel,
Output_data_reloc<sh_type, true, size, big_endian>*);
// Return whether there are any saved relocations.
bool
any_saved_relocs() const
{ return !this->entries_.empty(); }
// Emit any saved relocations which turn out to be needed. This is
// called after all the relocs have been scanned.
void
emit(Output_data_reloc<sh_type, true, size, big_endian>*);
private:
typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
// This POD class holds the relocations we are saving. We will emit
// these relocations if it turns out that the symbol does not
// require a COPY relocation.
class Copy_reloc_entry
{
public:
Copy_reloc_entry(Symbol* sym, unsigned int reloc_type,
Sized_relobj<size, big_endian>* relobj,
unsigned int shndx,
Output_section* output_section,
Address address, Addend addend)
: sym_(sym), reloc_type_(reloc_type), relobj_(relobj),
shndx_(shndx), output_section_(output_section),
address_(address), addend_(addend)
{ }
// Emit this reloc if appropriate. This is called after we have
// scanned all the relocations, so we know whether we emitted a
// COPY relocation for SYM_.
void
emit(Output_data_reloc<sh_type, true, size, big_endian>*);
private:
Symbol* sym_;
unsigned int reloc_type_;
Sized_relobj<size, big_endian>* relobj_;
unsigned int shndx_;
Output_section* output_section_;
Address address_;
Addend addend_;
};
// A list of relocs to be saved.
typedef std::vector<Copy_reloc_entry> Copy_reloc_entries;
// Return whether we need a COPY reloc.
bool
need_copy_reloc(Sized_symbol<size>* gsym,
Sized_relobj<size, big_endian>* object,
unsigned int shndx) const;
// Emit a COPY reloc.
void
emit_copy_reloc(Symbol_table*, Layout*, Sized_symbol<size>*,
Output_data_reloc<sh_type, true, size, big_endian>*);
// Add a COPY reloc to the dynamic reloc section.
void
add_copy_reloc(Symbol*, section_size_type,
Output_data_reloc<sh_type, true, size, big_endian>*);
// Save a reloc against SYM for possible emission later.
void
save(Symbol*, Sized_relobj<size, big_endian>*, unsigned int shndx,
Output_section*, const Reloc& rel);
// The target specific relocation type of the COPY relocation.
const unsigned int copy_reloc_type_;
// The dynamic BSS data which goes into the .bss section. This is
// where variables which require COPY relocations are placed.
Output_data_space* dynbss_;
// The list of relocs we are saving.
Copy_reloc_entries entries_;
};
} // End namespace gold.
#endif // !defined(GOLD_COPY_RELOCS_H)