#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_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_;
// 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_;
};
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<size, big_endian>::Valtype Sizetype;
- Valtype* wv = reinterpret_cast<Valtype*>(view);
- Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
- // Fancy formula to sign-extend x to size.
- const Sizetype mask = 1U << (sizeof(valsize) * 8 - 1);
- Sizetype sign_extended_x = x;
- sign_extended_x = (sign_extended_x ^ mask) - mask;
- x = psymval->value(object, sign_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>
// Do an 8-bit RELA relocation with the addend in the relocation.
static inline void
- rel8a(unsigned char* view, unsigned char value, unsigned char addend)
+ rela8(unsigned char* view, unsigned char value, unsigned char addend)
{ This::template rela<8>(view, value, addend); }
static inline void
- rel8a(unsigned char* view,
+ rela8(unsigned char* view,
const Sized_relobj<size, big_endian>* object,
const Symbol_value<size>* psymval,
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
// 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>&);
+ Output_section* output_section, 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>&);
+ Output_section* output_section, const elfcpp::Rela<size, big_endian>&);
// Return whether there are any relocs to emit. This also discards
// entries which need not be emitted.
public:
Copy_reloc_entry(Symbol* sym, unsigned int reloc_type,
Relobj* relobj, unsigned int shndx,
+ Output_section* output_section,
Address address, Addend addend)
: sym_(sym), reloc_type_(reloc_type), relobj_(relobj),
- shndx_(shndx), address_(address), addend_(addend)
+ shndx_(shndx), output_section_(output_section),
+ address_(address), addend_(addend)
{ }
// Return whether we should emit this reloc. If we should not
unsigned int reloc_type_;
Relobj* relobj_;
unsigned int shndx_;
+ Output_section* output_section_;
Address address_;
Addend addend_;
};
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.
+
+template<int size, bool big_endian>
+class Track_relocs
+{
+ public:
+ Track_relocs()
+ : prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
+ { }
+
+ // 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
+ initialize(Object* object, unsigned int reloc_shndx,
+ unsigned int reloc_type);
+
+ // 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;
+
+ // Return the symbol index of the next reloc. This returns -1U if
+ // there is no next reloc.
+ unsigned int
+ next_symndx() const;
+
+ // Advance to OFFSET within the data section, and return the number
+ // of relocs which would be skipped.
+ int
+ advance(off_t offset);
+
+ 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.
#endif // !defined(GOLD_RELOC_H)
projects / deliverable / binutils-gdb.git / blobdiff