X-Git-Url: https://oss.titaniummirror.com/gitweb?p=msp430-binutils.git;a=blobdiff_plain;f=gold%2Fcopy-relocs.h;fp=gold%2Fcopy-relocs.h;h=2fe6a245e072f0295ee6b394f67260c33d55d5cb;hp=0000000000000000000000000000000000000000;hb=d5da4f291af551c0b8b79e1d4a9b173d60e5c10e;hpb=7b5ea4fcdf2819e070665ab5610f8b48e3867c10 diff --git a/gold/copy-relocs.h b/gold/copy-relocs.h new file mode 100644 index 0000000..2fe6a24 --- /dev/null +++ b/gold/copy-relocs.h @@ -0,0 +1,155 @@ +// copy-relocs.h -- handle COPY relocations for gold -*- C++ -*- + +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. +// Written by Ian Lance Taylor . + +// 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 +class Copy_relocs +{ + private: + typedef typename Reloc_types::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* sym, + Sized_relobj* object, + unsigned int shndx, Output_section* output_section, + const Reloc& rel, + Output_data_reloc*); + + // 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*); + + private: + typedef typename elfcpp::Elf_types::Elf_Addr Address; + typedef typename elfcpp::Elf_types::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* 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*); + + private: + Symbol* sym_; + unsigned int reloc_type_; + Sized_relobj* relobj_; + unsigned int shndx_; + Output_section* output_section_; + Address address_; + Addend addend_; + }; + + // A list of relocs to be saved. + typedef std::vector Copy_reloc_entries; + + // Return whether we need a COPY reloc. + bool + need_copy_reloc(Sized_symbol* gsym, + Sized_relobj* object, + unsigned int shndx) const; + + // Emit a COPY reloc. + void + emit_copy_reloc(Symbol_table*, Layout*, Sized_symbol*, + Output_data_reloc*); + + // Add a COPY reloc to the dynamic reloc section. + void + add_copy_reloc(Symbol*, section_size_type, + Output_data_reloc*); + + // Save a reloc against SYM for possible emission later. + void + save(Symbol*, Sized_relobj*, 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)