// 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>
+#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
+#endif
+#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;
public:
// SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be
// unblocked when the Scan_relocs task completes.
- Read_relocs(const General_options& options, Symbol_table* symtab,
- Layout* layout, Relobj* object, Task_token* symtab_lock,
- Task_token* blocker)
- : options_(options), symtab_(symtab), layout_(layout), object_(object),
+ Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Task_token* symtab_lock, Task_token* blocker)
+ : symtab_(symtab), layout_(layout), object_(object),
+ 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:
+ 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(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Read_relocs_data* rd, Task_token* symtab_lock,
+ Task_token* blocker)
+ : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
symtab_lock_(symtab_lock), blocker_(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*);
+ 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_;
};
public:
// SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be
// unblocked when the task completes.
- Scan_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)
+ Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Read_relocs_data* rd, Task_token* symtab_lock,
+ Task_token* blocker)
+ : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
+ symtab_lock_(symtab_lock), blocker_(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;
- const General_options& options_;
+ private:
Symbol_table* symtab_;
Layout* layout_;
Relobj* object_;
class Relocate_task : public Task
{
public:
- Relocate_task(const General_options& options, const Symbol_table* symtab,
- const Layout* layout, Relobj* object, Output_file* of,
+ Relocate_task(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)
- : options_(options), symtab_(symtab), layout_(layout), object_(object),
- of_(of), input_sections_blocker_(input_sections_blocker),
+ : symtab_(symtab), layout_(layout), object_(object), 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;
- const General_options& options_;
+ private:
const Symbol_table* symtab_;
const Layout* layout_;
Relobj* object_;
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 astrategy)
+ {
+ this->reloc_strategies_.push_back(static_cast<unsigned char>(astrategy));
+ if (astrategy != 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.
{ 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.
-
-template<int size, bool big_endian>
-class Copy_relocs
-{
- public:
- Copy_relocs()
- : entries_()
- { }
-
- // 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.
- bool
- any_to_emit();
-
- // 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>*);
-
- private:
- typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
- typedef typename elfcpp::Elf_types<size>::Elf_Addr Addend;
-
- // 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_;
- };
-
- // 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_;
-};
-
// 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.
{
public:
Track_relocs()
- : object_(NULL), prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
+ : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
{ }
// Initialize the Track_relocs object. OBJECT is the object holding
// (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
// something went wrong.
bool
- initialize(Sized_relobj<size, big_endian>* object, unsigned int reloc_shndx,
+ initialize(Object* object, unsigned int reloc_shndx,
unsigned int reloc_type);
// Return the offset in the data section to which the next reloc
advance(off_t offset);
private:
- // The object file.
- Sized_relobj<size, big_endian>* object_;
- // The contents of the reloc section.
+ // The contents of the input object's reloc section.
const unsigned char* prelocs_;
// The length of the reloc section.
- off_t len_;
+ section_size_type len_;
// Our current position in the reloc section.
- off_t pos_;
+ section_size_type pos_;
// The size of the relocs in the section.
int reloc_size_;
};
projects / deliverable / binutils-gdb.git / blobdiff