Object(const std::string& name, Input_file* input_file, bool is_dynamic,
off_t offset = 0)
: name_(name), input_file_(input_file), offset_(offset), shnum_(-1U),
- is_dynamic_(is_dynamic), target_(NULL), xindex_(NULL), no_export_(false)
+ is_dynamic_(is_dynamic), uses_split_stack_(false),
+ has_no_split_stack_(false), xindex_(NULL), no_export_(false)
{ input_file->file().add_object(); }
virtual ~Object()
is_dynamic() const
{ return this->is_dynamic_; }
+ // Return whether this object was compiled with -fsplit-stack.
+ bool
+ uses_split_stack() const
+ { return this->uses_split_stack_; }
+
+ // Return whether this object contains any functions compiled with
+ // the no_split_stack attribute.
+ bool
+ has_no_split_stack() const
+ { return this->has_no_split_stack_; }
+
// Returns NULL for Objects that are not plugin objects. This method
// is overridden in the Pluginobj class.
Pluginobj*
pluginobj()
{ return this->do_pluginobj(); }
- // Return the target structure associated with this object.
- Target*
- target() const
- { return this->target_; }
-
// Get the file. We pass on const-ness.
Input_file*
input_file()
just_symbols() const
{ return this->input_file()->just_symbols(); }
- // Return the sized target structure associated with this object.
- // This is like the target method but it returns a pointer of
- // appropriate checked type.
- template<int size, bool big_endian>
- Sized_target<size, big_endian>*
- sized_target() const;
-
// Get the number of sections.
unsigned int
shnum() const
section_flags(unsigned int shndx)
{ return this->do_section_flags(shndx); }
+ // Return the section entsize given a section index.
+ uint64_t
+ section_entsize(unsigned int shndx)
+ { return this->do_section_entsize(shndx); }
+
// Return the section address given a section index.
uint64_t
section_address(unsigned int shndx)
size_t* used) const
{ this->do_get_global_symbol_counts(symtab, defined, used); }
- // Set the target.
- void
- set_target(Target* target)
- { this->target_ = target; }
-
// Return whether this object was found in a system directory.
bool
is_in_system_directory() const
virtual uint64_t
do_section_flags(unsigned int shndx) = 0;
+ // Get section entsize--implemented by child class.
+ virtual uint64_t
+ do_section_entsize(unsigned int shndx) = 0;
+
// Get section address--implemented by child class.
virtual uint64_t
do_section_address(unsigned int shndx) = 0;
virtual void
do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const = 0;
- // Set the target.
- void
- set_target(int machine, int size, bool big_endian, int osabi,
- int abiversion);
-
// Set the number of sections.
void
set_shnum(int shnum)
handle_gnu_warning_section(const char* name, unsigned int shndx,
Symbol_table*);
+ // If NAME is the name of the special section which indicates that
+ // this object was compiled with -fstack-split, mark it accordingly,
+ // and return true. Otherwise return false.
+ bool
+ handle_split_stack_section(const char* name);
+
private:
// This class may not be copied.
Object(const Object&);
unsigned int shnum_;
// Whether this is a dynamic object.
bool is_dynamic_;
- // Target functions--may be NULL if the target is not known.
- Target* target_;
+ // Whether this object was compiled with -fsplit-stack.
+ bool uses_split_stack_;
+ // Whether this object contains any functions compiled with the
+ // no_split_stack attribute.
+ bool has_no_split_stack_;
// Many sections for objects with more than SHN_LORESERVE sections.
Xindex* xindex_;
// True if exclude this object from automatic symbol export.
bool no_export_;
};
-// Implement sized_target inline for efficiency. This approach breaks
-// static type checking, but is made safe using asserts.
-
-template<int size, bool big_endian>
-inline Sized_target<size, big_endian>*
-Object::sized_target() const
-{
- gold_assert(this->target_->get_size() == size);
- gold_assert(this->target_->is_big_endian() ? big_endian : !big_endian);
- return static_cast<Sized_target<size, big_endian>*>(this->target_);
-}
-
// A regular object (ET_REL). This is an abstract base class itself.
// The implementation is the template class Sized_relobj.
output_sections_(),
map_to_relocatable_relocs_(NULL),
object_merge_map_(NULL),
- relocs_must_follow_section_writes_(false)
+ relocs_must_follow_section_writes_(false),
+ sd_(NULL)
{ }
// During garbage collection, the Read_symbols_data pass for
// indexes for the local variables, and set the offset where local
// symbol information will be stored. Returns the new local symbol index.
unsigned int
- finalize_local_symbols(unsigned int index, off_t off)
- { return this->do_finalize_local_symbols(index, off); }
+ finalize_local_symbols(unsigned int index, off_t off, Symbol_table* symtab)
+ { return this->do_finalize_local_symbols(index, off, symtab); }
// Set the output dynamic symbol table indexes for the local variables.
unsigned int
// for the local variables, and set the offset where local symbol
// information will be stored.
virtual unsigned int
- do_finalize_local_symbols(unsigned int, off_t) = 0;
+ do_finalize_local_symbols(unsigned int, off_t, Symbol_table*) = 0;
// Set the output dynamic symbol table indexes for the local variables.
virtual unsigned int
Got_offset_list* got_next_;
};
+// This type is used to modify relocations for -fsplit-stack. It is
+// indexed by relocation index, and means that the relocation at that
+// index should use the symbol from the vector, rather than the one
+// indicated by the relocation.
+
+class Reloc_symbol_changes
+{
+ public:
+ Reloc_symbol_changes(size_t count)
+ : vec_(count, NULL)
+ { }
+
+ void
+ set(size_t i, Symbol* sym)
+ { this->vec_[i] = sym; }
+
+ const Symbol*
+ operator[](size_t i) const
+ { return this->vec_[i]; }
+
+ private:
+ std::vector<Symbol*> vec_;
+};
+
// A regular object file. This is size and endian specific.
template<int size, bool big_endian>
is_output_section_offset_invalid(unsigned int shndx) const
{ return this->get_output_section_offset(shndx) == invalid_address; }
- // Set up the object file based on the ELF header.
+ // Set up the object file based on TARGET.
void
- setup(const typename elfcpp::Ehdr<size, big_endian>&);
+ setup()
+ { this->do_setup(); }
// Return the number of symbols. This is only valid after
// Object::add_symbols has been called.
return this->local_values_[sym].input_shndx(is_ordinary);
}
- // Return the appropriate Sized_target structure.
- Sized_target<size, big_endian>*
- sized_target()
- { return this->Object::sized_target<size, big_endian>(); }
-
// Record that local symbol SYM needs a dynamic symbol entry.
void
set_needs_output_dynsym_entry(unsigned int sym)
Address
map_to_kept_section(unsigned int shndx, bool* found) const;
+ // Make section offset invalid. This is needed for relaxation.
+ void
+ invalidate_section_offset(unsigned int shndx)
+ { this->do_invalidate_section_offset(shndx); }
+
protected:
+ // Set up.
+ virtual void
+ do_setup();
+
// Read the symbols.
void
do_read_symbols(Read_symbols_data*);
// Finalize the local symbols.
unsigned int
- do_finalize_local_symbols(unsigned int, off_t);
+ do_finalize_local_symbols(unsigned int, off_t, Symbol_table*);
// Set the offset where local dynamic symbol information will be stored.
unsigned int
// Return section flags.
uint64_t
- do_section_flags(unsigned int shndx)
- { return this->elf_file_.section_flags(shndx); }
+ do_section_flags(unsigned int shndx);
+
+ // Return section entsize.
+ uint64_t
+ do_section_entsize(unsigned int shndx);
// Return section address.
uint64_t
this->section_offsets_[shndx] = convert_types<Address, uint64_t>(off);
}
+ // Set the offset of a section to invalid_address.
+ virtual void
+ do_invalidate_section_offset(unsigned int shndx)
+ {
+ gold_assert(shndx < this->section_offsets_.size());
+ this->section_offsets_[shndx] = invalid_address;
+ }
+
+ // Adjust a section index if necessary.
+ unsigned int
+ adjust_shndx(unsigned int shndx)
+ {
+ if (shndx >= elfcpp::SHN_LORESERVE)
+ shndx += this->elf_file_.large_shndx_offset();
+ return shndx;
+ }
+
+ // Initialize input to output maps for section symbols in merged
+ // sections.
+ void
+ initialize_input_to_output_maps();
+
+ // Free the input to output maps for section symbols in merged
+ // sections.
+ void
+ free_input_to_output_maps();
+
+ // Return symbol table section index.
+ unsigned int
+ symtab_shndx() const
+ { return this->symtab_shndx_; }
+
+ // Allow a child class to access the ELF file.
+ elfcpp::Elf_file<size, big_endian, Object>*
+ elf_file()
+ { return &this->elf_file_; }
+
+ // Allow a child class to access the local values.
+ Local_values*
+ local_values()
+ { return &this->local_values_; }
+
private:
// For convenience.
typedef Sized_relobj<size, big_endian> This;
// kept section.
struct Kept_comdat_section
{
- Kept_comdat_section(Sized_relobj<size, big_endian>* object,
- unsigned int shndx)
- : object_(object), shndx_(shndx)
+ Kept_comdat_section(Relobj* a_object, unsigned int a_shndx)
+ : object(a_object), shndx(a_shndx)
{ }
- Sized_relobj<size, big_endian>* object_;
- unsigned int shndx_;
+ Relobj* object;
+ unsigned int shndx;
};
- typedef std::map<unsigned int, Kept_comdat_section*>
+ typedef std::map<unsigned int, Kept_comdat_section>
Kept_comdat_section_table;
- // Adjust a section index if necessary.
- unsigned int
- adjust_shndx(unsigned int shndx)
- {
- if (shndx >= elfcpp::SHN_LORESERVE)
- shndx += this->elf_file_.large_shndx_offset();
- return shndx;
- }
-
// Find the SHT_SYMTAB section, given the section headers.
void
find_symtab(const unsigned char* pshdrs);
unsigned char* reloc_view,
section_size_type reloc_view_size);
- // Initialize input to output maps for section symbols in merged
- // sections.
+ // A type shared by split_stack_adjust_reltype and find_functions.
+ typedef std::map<section_offset_type, section_size_type> Function_offsets;
+
+ // Check for -fsplit-stack routines calling non-split-stack routines.
void
- initialize_input_to_output_maps();
+ split_stack_adjust(const Symbol_table*, const unsigned char* pshdrs,
+ unsigned int sh_type, unsigned int shndx,
+ const unsigned char* prelocs, size_t reloc_count,
+ unsigned char* view, section_size_type view_size,
+ Reloc_symbol_changes** reloc_map);
- // Free the input to output maps for section symbols in merged
- // sections.
+ template<int sh_type>
void
- free_input_to_output_maps();
+ split_stack_adjust_reltype(const Symbol_table*, const unsigned char* pshdrs,
+ unsigned int shndx, const unsigned char* prelocs,
+ size_t reloc_count, unsigned char* view,
+ section_size_type view_size,
+ Reloc_symbol_changes** reloc_map);
+
+ // Find all functions in a section.
+ void
+ find_functions(const unsigned char* pshdrs, unsigned int shndx,
+ Function_offsets*);
// Write out the local symbols.
void
// Record a mapping from discarded section SHNDX to the corresponding
// kept section.
void
- set_kept_comdat_section(unsigned int shndx, Kept_comdat_section* kept)
+ set_kept_comdat_section(unsigned int shndx, Relobj* kept_object,
+ unsigned int kept_shndx)
{
- this->kept_comdat_sections_[shndx] = kept;
+ Kept_comdat_section kept(kept_object, kept_shndx);
+ this->kept_comdat_sections_.insert(std::make_pair(shndx, kept));
}
- // Find the kept section corresponding to the discarded section SHNDX.
- Kept_comdat_section*
- get_kept_comdat_section(unsigned int shndx) const
+ // Find the kept section corresponding to the discarded section
+ // SHNDX. Return true if found.
+ bool
+ get_kept_comdat_section(unsigned int shndx, Relobj** kept_object,
+ unsigned int* kept_shndx) const
{
typename Kept_comdat_section_table::const_iterator p =
this->kept_comdat_sections_.find(shndx);
if (p == this->kept_comdat_sections_.end())
- return NULL;
- return p->second;
+ return false;
+ *kept_object = p->second.object;
+ *kept_shndx = p->second.shndx;
+ return true;
}
// The GOT offsets of local symbols. This map also stores GOT offsets
Kept_comdat_section_table kept_comdat_sections_;
// Whether this object has a GNU style .eh_frame section.
bool has_eh_frame_;
+ // If this object has a GNU style .eh_frame section that is discarded in
+ // output, record the index here. Otherwise it is -1U.
+ unsigned int discarded_eh_frame_shndx_;
// The list of sections whose layout was deferred.
std::vector<Deferred_layout> deferred_layout_;
};
projects / deliverable / binutils-gdb.git / blobdiff