// reloc.h -- relocate input files for gold -*- C++ -*-
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#ifndef GOLD_RELOC_H
#define GOLD_RELOC_H
+#include <vector>
#include <byteswap.h>
+#include "elfcpp.h"
#include "workqueue.h"
namespace gold
{
class General_options;
+class Object;
class Relobj;
class Read_relocs_data;
class Symbol;
class Layout;
+class Output_data;
+class Output_section;
template<int size>
class Sized_symbol;
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
+
+ void
+ run(Workqueue*);
+
+ std::string
+ get_name() const;
+
+ private:
+ const General_options& options_;
+ Symbol_table* symtab_;
+ Layout* layout_;
+ Relobj* object_;
+ Task_token* symtab_lock_;
+ Task_token* blocker_;
+};
+
+// Process the relocs to figure out which sections are garbage.
+// Very similar to scan relocs.
+
+class Gc_process_relocs : public Task
+{
+ public:
+ // SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be
+ // unblocked when the task completes.
+ Gc_process_relocs(const General_options& options, Symbol_table* symtab,
+ Layout* layout, Relobj* object, Read_relocs_data* rd,
+ Task_token* symtab_lock, Task_token* blocker)
+ : options_(options), symtab_(symtab), layout_(layout), object_(object),
+ rd_(rd), symtab_lock_(symtab_lock), blocker_(blocker)
+ { }
+
+ // The standard Task methods.
+
+ Task_token*
+ is_runnable();
+
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
+ std::string
+ get_name() const;
+
private:
const General_options& options_;
Symbol_table* symtab_;
Layout* layout_;
Relobj* object_;
+ Read_relocs_data* rd_;
Task_token* symtab_lock_;
Task_token* blocker_;
};
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
- private:
- class Scan_relocs_locker;
+ std::string
+ get_name() const;
+ private:
const General_options& options_;
Symbol_table* symtab_;
Layout* layout_;
public:
Relocate_task(const General_options& options, const Symbol_table* symtab,
const Layout* layout, Relobj* object, Output_file* of,
- Task_token* final_blocker)
+ Task_token* input_sections_blocker,
+ Task_token* output_sections_blocker, Task_token* final_blocker)
: options_(options), symtab_(symtab), layout_(layout), object_(object),
- of_(of), final_blocker_(final_blocker)
+ of_(of), input_sections_blocker_(input_sections_blocker),
+ output_sections_blocker_(output_sections_blocker),
+ final_blocker_(final_blocker)
{ }
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
- private:
- class Relocate_locker;
+ std::string
+ get_name() const;
+ private:
const General_options& options_;
const Symbol_table* symtab_;
const Layout* layout_;
Relobj* object_;
Output_file* of_;
+ Task_token* input_sections_blocker_;
+ Task_token* output_sections_blocker_;
Task_token* final_blocker_;
};
+// During a relocatable link, this class records how relocations
+// should be handled for a single input reloc section. An instance of
+// this class is created while scanning relocs, and it is used while
+// processing relocs.
+
+class Relocatable_relocs
+{
+ public:
+ // We use a vector of unsigned char to indicate how the input relocs
+ // should be handled. Each element is one of the following values.
+ // We create this vector when we initially scan the relocations.
+ enum Reloc_strategy
+ {
+ // Copy the input reloc. Don't modify it other than updating the
+ // r_offset field and the r_sym part of the r_info field.
+ RELOC_COPY,
+ // Copy the input reloc which is against an STT_SECTION symbol.
+ // Update the r_offset and r_sym part of the r_info field. Adjust
+ // the addend by subtracting the value of the old local symbol and
+ // adding the value of the new local symbol. The addend is in the
+ // SHT_RELA reloc and the contents of the data section do not need
+ // to be changed.
+ RELOC_ADJUST_FOR_SECTION_RELA,
+ // Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
+ // adjusted.
+ RELOC_ADJUST_FOR_SECTION_0,
+ // Like RELOC_ADJUST_FOR_SECTION_RELA but the contents of the
+ // section need to be changed. The number indicates the number of
+ // bytes in the addend in the section contents.
+ RELOC_ADJUST_FOR_SECTION_1,
+ RELOC_ADJUST_FOR_SECTION_2,
+ RELOC_ADJUST_FOR_SECTION_4,
+ RELOC_ADJUST_FOR_SECTION_8,
+ // Discard the input reloc--process it completely when relocating
+ // the data section contents.
+ RELOC_DISCARD,
+ // An input reloc which is not discarded, but which requires
+ // target specific processing in order to update it.
+ RELOC_SPECIAL
+ };
+
+ Relocatable_relocs()
+ : reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
+ { }
+
+ // Record the number of relocs.
+ void
+ set_reloc_count(size_t reloc_count)
+ { this->reloc_strategies_.reserve(reloc_count); }
+
+ // Record what to do for the next reloc.
+ void
+ set_next_reloc_strategy(Reloc_strategy strategy)
+ {
+ this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
+ if (strategy != RELOC_DISCARD)
+ ++this->output_reloc_count_;
+ }
+
+ // Record the Output_data associated with this reloc section.
+ void
+ set_output_data(Output_data* posd)
+ {
+ gold_assert(this->posd_ == NULL);
+ this->posd_ = posd;
+ }
+
+ // Return the Output_data associated with this reloc section.
+ Output_data*
+ output_data() const
+ { return this->posd_; }
+
+ // Return what to do for reloc I.
+ Reloc_strategy
+ strategy(unsigned int i) const
+ {
+ gold_assert(i < this->reloc_strategies_.size());
+ return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
+ }
+
+ // Return the number of relocations to create in the output file.
+ size_t
+ output_reloc_count() const
+ { return this->output_reloc_count_; }
+
+ private:
+ typedef std::vector<unsigned char> Reloc_strategies;
+
+ // The strategies for the input reloc. There is one entry in this
+ // vector for each relocation in the input section.
+ Reloc_strategies reloc_strategies_;
+ // The number of relocations to be created in the output file.
+ size_t output_reloc_count_;
+ // The output data structure associated with this relocation.
+ Output_data* posd_;
+};
+
// Standard relocation routines which are used on many targets. Here
// SIZE and BIG_ENDIAN refer to the target, not the relocation type.
elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
}
- // Like rel(), but sign-extends the value to SIZE.
- template<int valsize>
- static inline void
- signedrel(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
- const Symbol_value<size>* psymval)
- {
- typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
- typedef typename elfcpp::Swap<valsize, big_endian>::Signed_valtype
- Signed_valtype;
- typedef typename elfcpp::Swap<size, big_endian>::Valtype Sizetype;
- typedef typename elfcpp::Swap<size, big_endian>::Signed_valtype
- Signed_sizetype;
- Valtype* wv = reinterpret_cast<Valtype*>(view);
- Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
-
- // Sign extend the value.
- Signed_valtype signed_x = static_cast<Signed_valtype>(x);
- Signed_sizetype signed_extended_x = static_cast<Signed_sizetype>(signed_x);
- Sizetype unsigned_extended_x = static_cast<Sizetype>(signed_extended_x);
-
- x = psymval->value(object, unsigned_extended_x);
- elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
- }
-
// Do a simple PC relative relocation with the addend in the section
// contents. VALSIZE is the size of the value.
template<int valsize>
unsigned char addend)
{ This::template rela<8>(view, object, psymval, addend); }
- // Do an 8-bit REL relocation, sign extending the addend to SIZE.
- static inline void
- rel8s(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
- const Symbol_value<size>* psymval)
- { This::template signedrel<8>(view, object, psymval); }
-
// Do a simple 8-bit PC relative relocation with the addend in the
// section contents.
static inline void
elfcpp::Elf_Half addend)
{ This::template rela<16>(view, object, psymval, addend); }
- // Do a 16-bit REL relocation, sign extending the addend to SIZE.
- static inline void
- rel16s(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
- const Symbol_value<size>* psymval)
- { This::template signedrel<16>(view, object, psymval); }
-
// Do a simple 16-bit PC relative REL relocation with the addend in
// the section contents.
static inline void
elfcpp::Elf_Word addend)
{ This::template rela<32>(view, object, psymval, addend); }
- // Do a 32-bit REL relocation, sign extending the addend to SIZE.
- static inline void
- rel32s(unsigned char* view,
- const Sized_relobj<size, big_endian>* object,
- const Symbol_value<size>* psymval)
- { This::template signedrel<32>(view, object, psymval); }
-
// Do a simple 32-bit PC relative REL relocation with the addend in
// the section contents.
static inline void
{ This::template pcrela<64>(view, object, psymval, addend, address); }
};
-// We try to avoid COPY relocations 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.
+// Track relocations while reading a section. This lets you ask for
+// the relocation at a certain offset, and see how relocs occur
+// between points of interest.
template<int size, bool big_endian>
-class Copy_relocs
+class Track_relocs
{
public:
- Copy_relocs()
- : entries_()
+ Track_relocs()
+ : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
{ }
- // Return whether we need a COPY reloc for a reloc against GSYM,
- // which is being applied to section SHNDX in OBJECT.
- static bool
- need_copy_reloc(const General_options*, Relobj* object, unsigned int shndx,
- Sized_symbol<size>* gsym);
-
- // Save a Rel against SYM for possible emission later. SHNDX is the
- // index of the section to which the reloc is being applied.
- void
- save(Symbol* sym, Relobj*, unsigned int shndx,
- const elfcpp::Rel<size, big_endian>&);
-
- // Save a Rela against SYM for possible emission later.
- void
- save(Symbol* sym, Relobj*, unsigned int shndx,
- const elfcpp::Rela<size, big_endian>&);
-
- // Return whether there are any relocs to emit. This also discards
- // entries which need not be emitted.
+ // Initialize the Track_relocs object. OBJECT is the object holding
+ // the reloc section, RELOC_SHNDX is the section index of the reloc
+ // section, and RELOC_TYPE is the type of the reloc section
+ // (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
+ // something went wrong.
bool
- any_to_emit();
+ initialize(Object* object, unsigned int reloc_shndx,
+ unsigned int reloc_type);
- // Emit relocs for each symbol which did not get a COPY reloc (i.e.,
- // is still defined in the dynamic object).
- template<int sh_type>
- void
- emit(Output_data_reloc<sh_type, true, size, big_endian>*);
+ // Return the offset in the data section to which the next reloc
+ // applies. THis returns -1 if there is no next reloc.
+ off_t
+ next_offset() const;
- private:
- typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
- typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
+ // Return the symbol index of the next reloc. This returns -1U if
+ // there is no next reloc.
+ unsigned int
+ next_symndx() const;
- // This POD class holds the entries we are saving.
- class Copy_reloc_entry
- {
- public:
- Copy_reloc_entry(Symbol* sym, unsigned int reloc_type,
- Relobj* relobj, unsigned int shndx,
- Address address, Addend addend)
- : sym_(sym), reloc_type_(reloc_type), relobj_(relobj),
- shndx_(shndx), address_(address), addend_(addend)
- { }
-
- // Return whether we should emit this reloc. If we should not
- // emit, we clear it.
- bool
- should_emit();
-
- // Emit this reloc.
-
- void
- emit(Output_data_reloc<elfcpp::SHT_REL, true, size, big_endian>*);
-
- void
- emit(Output_data_reloc<elfcpp::SHT_RELA, true, size, big_endian>*);
-
- private:
- Symbol* sym_;
- unsigned int reloc_type_;
- Relobj* relobj_;
- unsigned int shndx_;
- Address address_;
- Addend addend_;
- };
+ // Advance to OFFSET within the data section, and return the number
+ // of relocs which would be skipped.
+ int
+ advance(off_t offset);
- // A list of relocs to be saved.
- typedef std::vector<Copy_reloc_entry> Copy_reloc_entries;
-
- // The list of relocs we are saving.
- Copy_reloc_entries entries_;
+ private:
+ // The contents of the input object's reloc section.
+ const unsigned char* prelocs_;
+ // The length of the reloc section.
+ section_size_type len_;
+ // Our current position in the reloc section.
+ section_size_type pos_;
+ // The size of the relocs in the section.
+ int reloc_size_;
};
} // End namespace gold.
projects / binutils-gdb.git / blobdiff