// reloc.h -- relocate input files for gold -*- C++ -*-
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#define GOLD_RELOC_H
#include <vector>
+#ifdef HAVE_BYTESWAP_H
#include <byteswap.h>
+#endif
#include "elfcpp.h"
#include "workqueue.h"
class Read_relocs : public Task
{
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),
- symtab_lock_(symtab_lock), blocker_(blocker)
+ // THIS_BLOCKER and NEXT_BLOCKER are passed along to a Scan_relocs
+ // or Gc_process_relocs task, so that they run in a deterministic
+ // order.
+ Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Task_token* this_blocker, Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), object_(object),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
{ }
// The standard Task methods.
get_name() const;
private:
- const General_options& options_;
Symbol_table* symtab_;
Layout* layout_;
Relobj* object_;
- Task_token* symtab_lock_;
- Task_token* blocker_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
+};
+
+// Process the relocs to figure out which sections are garbage.
+// Very similar to scan relocs.
+
+class Gc_process_relocs : public Task
+{
+ public:
+ // THIS_BLOCKER prevents this task from running until the previous
+ // one is finished. NEXT_BLOCKER prevents the next task from
+ // running.
+ Gc_process_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Read_relocs_data* rd, Task_token* this_blocker,
+ Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
+ { }
+
+ ~Gc_process_relocs();
+
+ // 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_;
+ Read_relocs_data* rd_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
};
// Scan the relocations for an object to see if they require any
class Scan_relocs : public Task
{
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)
+ // THIS_BLOCKER prevents this task from running until the previous
+ // one is finished. NEXT_BLOCKER prevents the next task from
+ // running.
+ Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
+ Read_relocs_data* rd, Task_token* this_blocker,
+ Task_token* next_blocker)
+ : symtab_(symtab), layout_(layout), object_(object), rd_(rd),
+ this_blocker_(this_blocker), next_blocker_(next_blocker)
{ }
+ ~Scan_relocs();
+
// The standard Task methods.
Task_token*
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_;
+ Task_token* this_blocker_;
+ Task_token* next_blocker_;
};
// A class to perform all the relocations for an object file.
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)
{ }
get_name() const;
private:
- const General_options& options_;
const Symbol_table* symtab_;
const Layout* layout_;
Relobj* object_;
{ 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,
- 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,
- 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.
- 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,
- 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)
- { }
-
- // 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_;
- Output_section* output_section_;
- 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.
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.
+ // applies. This returns -1 if there is no next reloc.
off_t
next_offset() const;
unsigned int
next_symndx() const;
+ // Return the addend of the next reloc. This returns 0 if there is
+ // no next reloc.
+ uint64_t
+ next_addend() const;
+
// Advance to OFFSET within the data section, and return the number
// of relocs which would be skipped.
int
projects / deliverable / binutils-gdb.git / blobdiff