riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

This patch adds IFUNC support for arm gold backend. 

This is a feature required in chromeos arm development work.

Tested:
1) Built passed all-gold on x86_64 machine
2) Tested with basic gold aarch64 ifunc unittests -
   a) global ifunc, statically/non-statically linked
   b) local ifunc, statically/non-statically linked
   c) global/local, other shared library routine mixed,
   statically/non-statically linked
   d) arm/thumb mode ifunc
   e) linking chrome browser passed
gdb-7.10-branch
Han Shen 12 years ago
parent
716db898b7
commit
fa89cc82f5
6 changed files with 613 additions and 50 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      elfcpp/ChangeLog
  2. 5
      elfcpp/arm.h
  3. 48
      gold/ChangeLog
  4. 2
      gold/aarch64.cc
  5. 593
      gold/arm.cc
  6. 11
      gold/output.h

4
elfcpp/ChangeLog
View File

@ -1,3 +1,7 @@
2015-01-22 Han Shen <shenhan@google.com>
* arm.h (R_ARM_IRELATIVE): New dynamic relocation.
2015-01-01 Alan Modra <amodra@gmail.com>
Update year range in copyright notice of all files.

5
elfcpp/arm.h
View File

@ -192,11 +192,12 @@ enum
R_ARM_PRIVATE_14 = 126,
R_ARM_PRIVATE_15 = 127,
R_ARM_ME_TOO = 128, // Obsolete
R_ARM_THM_TLS_DESCSEQ16 = 129,// Static Thumb16
R_ARM_THM_TLS_DESCSEQ16 = 129,// Static Thumb16
R_ARM_THM_TLS_DESCSEQ32 = 130,// Static Thumb32
// 131 - 139 Unallocated
// 140 - 159 Dynamic Reserved for future allocation
// 160 - 255 Unallocated
R_ARM_IRELATIVE = 160, // Dynamic
// 161 - 255 Unallocated
};
// e_flags values used for ARM. We only support flags defined in AAELF.

48
gold/ChangeLog
View File

@ -1,3 +1,51 @@
2015-01-22 Han Shen <shenhan@google.com>
* arm.cc (Target_arm::Target_arm): Add initialization for new members.
(Target_arm::do_plt_address_for_global): New method.
(Target_arm::do_plt_address_for_local): New method.
(Target_arm::rel_irelative_section): New method.
(Target_arm::make_data_plt): Add more parameters for plt ctor.
(Target_arm::do_make_data_plt): Add more parameters for plt ctor.
(Target_arm::Scan::symbol_needs_plt_entry): Add ifunc support.
(Target_arm::Scan::reloc_needs_plt_for_ifunc): Add ifunc support.
(Target_arm::Scan::check_non_pic): Add ifunc support.
(Target_arm::Scan::local): Add ifunc support.
(Target_arm::Scan::global): Add ifunc support.
(Target_arm::make_plt_section): New method.
(Target_arm::make_plt_entry): Change to call to make_plt_section.
(Target_arm::make_local_ifunc_plt_entry): New method.
(Target_arm::got_irelative_): New member.
(Target_arm::rel_irelative_): New member.
(Target_arm::got_section): Add creation for got_irelative_.
(Target_arm::rel_dyn_section): Add creation for rel_irelative_.
(Target_arm::Relocate::relocate): Properly set local ifunc address.
(Target_arm::do_dynsym_value): Properly set global ifunc address.
(Target_arm::scan_reloc_for_stub): Properly set global ifunc address.
(Output_data_plt_arm::IRelative_data): New type.
(Output_data_plt_arm::Output_data_plt_arm): Add more parameters.
(Output_data_plt_arm::add_entry): Add more parameters.
(Output_data_plt_arm::add_relocation): New method.
(Output_data_plt_arm::add_local_ifunc_entry): New method.
(Output_data_plt_arm::rel_irelative): New method.
(Output_data_plt_arm::entry_count): Modified.
(Output_data_plt_arm::address_for_global): New method.
(Output_data_plt_arm::address_for_local): New method.
(Output_data_plt_arm::set_final_data_size): Add irelative_count_.
(Output_data_plt_arm::insert_irelative_data): New method.
(Output_data_plt_arm::irelative_rel_): New member.
(Output_data_plt_arm::got_): New member.
(Output_data_plt_arm::got_irelative_): New member.
(Output_data_plt_arm::irelative_count_): New member.
(Output_data_plt_arm::IRelative_data_vec): New typedef.
(Output_data_plt_arm::irelative_data_vec_): New member.
(Output_data_plt_arm::do_write): Write out irelative entries.
(Output_data_plt_arm_standard::Output_data_plt_arm_standard): Add
more parameters to ctor.
(Output_data_plt_arm_nacl::Output_data_plt_arm_nacl): Add
more parameters to ctor.
* output.h (Output_data_reloc::add_local_relative): New method.
* aarch64.cc (Output_data_plt_aarch64): Fixed typo in comment.
2015-01-29 Alan Modra <amodra@gmail.com>
* powerpc.cc (Target_powerpc::Relocate::relocate): Correct GOT_TLSLD

2
gold/aarch64.cc
View File

@ -3082,7 +3082,7 @@ class Output_data_plt_aarch64 : public Output_section_data
// The number of PLT entries.
unsigned int count_;
// Number of PLT entries with R_X86_64_IRELATIVE relocs. These
// Number of PLT entries with R_AARCH64_IRELATIVE relocs. These
// follow the regular PLT entries.
unsigned int irelative_count_;

593
gold/arm.cc
View File

@ -2119,8 +2119,8 @@ class Target_arm : public Sized_target<32, big_endian>
Target_arm(const Target::Target_info* info = &arm_info)
: Sized_target<32, big_endian>(info),
got_(NULL), plt_(NULL), got_plt_(NULL), rel_dyn_(NULL),
copy_relocs_(elfcpp::R_ARM_COPY),
got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL),
rel_dyn_(NULL), rel_irelative_(NULL), copy_relocs_(elfcpp::R_ARM_COPY),
got_mod_index_offset_(-1U), tls_base_symbol_defined_(false),
stub_tables_(), stub_factory_(Stub_factory::get_instance()),
should_force_pic_veneer_(false),
@ -2258,6 +2258,18 @@ class Target_arm : public Sized_target<32, big_endian>
uint64_t
do_dynsym_value(const Symbol*) const;
// Return the plt address for globals. Since we have irelative plt entries,
// address calculation is not as straightforward as plt_address + plt_offset.
uint64_t
do_plt_address_for_global(const Symbol* gsym) const
{ return this->plt_section()->address_for_global(gsym); }
// Return the plt address for locals. Since we have irelative plt entries,
// address calculation is not as straightforward as plt_address + plt_offset.
uint64_t
do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const
{ return this->plt_section()->address_for_local(relobj, symndx); }
// Relocate a section.
void
relocate_section(const Relocate_info<32, big_endian>*,
@ -2357,6 +2369,10 @@ class Target_arm : public Sized_target<32, big_endian>
unsigned int
plt_entry_size() const;
// Get the section to use for IRELATIVE relocations, create it if necessary.
Reloc_section*
rel_irelative_section(Layout*);
// Map platform-specific reloc types
static unsigned int
get_real_reloc_type(unsigned int r_type);
@ -2448,8 +2464,11 @@ class Target_arm : public Sized_target<32, big_endian>
protected:
// Make the PLT-generator object.
Output_data_plt_arm<big_endian>*
make_data_plt(Layout* layout, Output_data_space* got_plt)
{ return this->do_make_data_plt(layout, got_plt); }
make_data_plt(Layout* layout,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative)
{ return this->do_make_data_plt(layout, got, got_plt, got_irelative); }
// Make an ELF object.
Object*
@ -2530,9 +2549,14 @@ class Target_arm : public Sized_target<32, big_endian>
do_define_standard_symbols(Symbol_table*, Layout*);
virtual Output_data_plt_arm<big_endian>*
do_make_data_plt(Layout* layout, Output_data_space* got_plt)
do_make_data_plt(Layout* layout,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative)
{
return new Output_data_plt_arm_standard<big_endian>(layout, got_plt);
gold_assert(got_plt != NULL && got_irelative != NULL);
return new Output_data_plt_arm_standard<big_endian>(
layout, got, got_plt, got_irelative);
}
private:
@ -2602,6 +2626,9 @@ class Target_arm : public Sized_target<32, big_endian>
if (sym->is_undefined() && !parameters->options().shared())
return false;
if (sym->type() == elfcpp::STT_GNU_IFUNC)
return true;
return (!parameters->doing_static_link()
&& (sym->type() == elfcpp::STT_FUNC
|| sym->type() == elfcpp::STT_ARM_TFUNC)
@ -2613,6 +2640,11 @@ class Target_arm : public Sized_target<32, big_endian>
inline bool
possible_function_pointer_reloc(unsigned int r_type);
// Whether a plt entry is needed for ifunc.
bool
reloc_needs_plt_for_ifunc(Sized_relobj_file<32, big_endian>*,
unsigned int r_type);
// Whether we have issued an error about a non-PIC compilation.
bool issued_non_pic_error_;
};
@ -2718,10 +2750,20 @@ class Target_arm : public Sized_target<32, big_endian>
return this->got_plt_;
}
// Create the PLT section.
void
make_plt_section(Symbol_table* symtab, Layout* layout);
// Create a PLT entry for a global symbol.
void
make_plt_entry(Symbol_table*, Layout*, Symbol*);
// Create a PLT entry for a local STT_GNU_IFUNC symbol.
void
make_local_ifunc_plt_entry(Symbol_table*, Layout*,
Sized_relobj_file<32, big_endian>* relobj,
unsigned int local_sym_index);
// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
void
define_tls_base_symbol(Symbol_table*, Layout*);
@ -2903,8 +2945,12 @@ class Target_arm : public Sized_target<32, big_endian>
Output_data_plt_arm<big_endian>* plt_;
// The GOT PLT section.
Output_data_space* got_plt_;
// The GOT section for IRELATIVE relocations.
Output_data_space* got_irelative_;
// The dynamic reloc section.
Reloc_section* rel_dyn_;
// The section to use for IRELATIVE relocs.
Reloc_section* rel_irelative_;
// Relocs saved to avoid a COPY reloc.
Copy_relocs<elfcpp::SHT_REL, 32, big_endian> copy_relocs_;
// Offset of the GOT entry for the TLS module index.
@ -4244,6 +4290,15 @@ Target_arm<big_endian>::got_section(Symbol_table* symtab, Layout* layout)
elfcpp::STB_LOCAL,
elfcpp::STV_HIDDEN, 0,
false, false);
// If there are any IRELATIVE relocations, they get GOT entries
// in .got.plt after the jump slot entries.
this->got_irelative_ = new Output_data_space(4, "** GOT IRELATIVE PLT");
layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
(elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE),
this->got_irelative_,
got_order, is_got_relro);
}
return this->got_;
}
@ -4257,14 +4312,43 @@ Target_arm<big_endian>::rel_dyn_section(Layout* layout)
if (this->rel_dyn_ == NULL)
{
gold_assert(layout != NULL);
// Create both relocation sections in the same place, so as to ensure
// their relative order in the output section.
this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
this->rel_irelative_ = new Reloc_section(false);
layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
elfcpp::SHF_ALLOC, this->rel_dyn_,
ORDER_DYNAMIC_RELOCS, false);
layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
elfcpp::SHF_ALLOC, this->rel_irelative_,
ORDER_DYNAMIC_RELOCS, false);
}
return this->rel_dyn_;
}
// Get the section to use for IRELATIVE relocs, creating it if necessary. These
// go in .rela.dyn, but only after all other dynamic relocations. They need to
// follow the other dynamic relocations so that they can refer to global
// variables initialized by those relocs.
template<bool big_endian>
typename Target_arm<big_endian>::Reloc_section*
Target_arm<big_endian>::rel_irelative_section(Layout* layout)
{
if (this->rel_irelative_ == NULL)
{
// Delegate the creation to rel_dyn_section so as to ensure their order in
// the output section.
this->rel_dyn_section(layout);
gold_assert(this->rel_irelative_ != NULL
&& (this->rel_dyn_->output_section()
== this->rel_irelative_->output_section()));
}
return this->rel_irelative_;
}
// Insn_template methods.
// Return byte size of an instruction template.
@ -7221,24 +7305,80 @@ template<bool big_endian>
class Output_data_plt_arm : public Output_section_data
{
public:
// Unlike aarch64, which records symbol value in "addend" field of relocations
// and could be done at the same time an IRelative reloc is created for the
// symbol, arm puts the symbol value into "GOT" table, which, however, is
// issued later in Output_data_plt_arm::do_write(). So we have a struct here
// to keep necessary symbol information for later use in do_write. We usually
// have only a very limited number of ifuncs, so the extra data required here
// is also limited.
struct IRelative_data
{
IRelative_data(Sized_symbol<32>* sized_symbol)
: symbol_is_global_(true)
{
u_.global = sized_symbol;
}
IRelative_data(Sized_relobj_file<32, big_endian>* relobj,
unsigned int index)
: symbol_is_global_(false)
{
u_.local.relobj = relobj;
u_.local.index = index;
}
union
{
Sized_symbol<32>* global;
struct
{
Sized_relobj_file<32, big_endian>* relobj;
unsigned int index;
} local;
} u_;
bool symbol_is_global_;
};
typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, big_endian>
Reloc_section;
Output_data_plt_arm(Layout*, uint64_t addralign, Output_data_space*);
Output_data_plt_arm(Layout* layout, uint64_t addralign,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative);
// Add an entry to the PLT.
void
add_entry(Symbol* gsym);
add_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym);
// Add the relocation for a plt entry.
void
add_relocation(Symbol_table* symtab, Layout* layout,
Symbol* gsym, unsigned int got_offset);
// Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
unsigned int
add_local_ifunc_entry(Symbol_table* symtab, Layout*,
Sized_relobj_file<32, big_endian>* relobj,
unsigned int local_sym_index);
// Return the .rel.plt section data.
const Reloc_section*
rel_plt() const
{ return this->rel_; }
// Return the PLT relocation container for IRELATIVE.
Reloc_section*
rel_irelative(Symbol_table*, Layout*);
// Return the number of PLT entries.
unsigned int
entry_count() const
{ return this->count_; }
{ return this->count_ + this->irelative_count_; }
// Return the offset of the first non-reserved PLT entry.
unsigned int
@ -7250,6 +7390,14 @@ class Output_data_plt_arm : public Output_section_data
get_plt_entry_size() const
{ return this->do_get_plt_entry_size(); }
// Return the PLT address for globals.
uint32_t
address_for_global(const Symbol*) const;
// Return the PLT address for locals.
uint32_t
address_for_local(const Relobj*, unsigned int symndx) const;
protected:
// Fill in the first PLT entry.
void
@ -7298,19 +7446,37 @@ class Output_data_plt_arm : public Output_section_data
set_final_data_size()
{
this->set_data_size(this->first_plt_entry_offset()
+ this->count_ * this->get_plt_entry_size());
+ ((this->count_ + this->irelative_count_)
* this->get_plt_entry_size()));
}
// Write out the PLT data.
void
do_write(Output_file*);
// Record irelative symbol data.
void insert_irelative_data(const IRelative_data& idata)
{ irelative_data_vec_.push_back(idata); }
// The reloc section.
Reloc_section* rel_;
// The IRELATIVE relocs, if necessary. These must follow the
// regular PLT relocations.
Reloc_section* irelative_rel_;
// The .got section.
Arm_output_data_got<big_endian>* got_;
// The .got.plt section.
Output_data_space* got_plt_;
// The part of the .got.plt section used for IRELATIVE relocs.
Output_data_space* got_irelative_;
// The number of PLT entries.
unsigned int count_;
// Number of PLT entries with R_ARM_IRELATIVE relocs. These
// follow the regular PLT entries.
unsigned int irelative_count_;
// Vector for irelative data.
typedef std::vector<IRelative_data> IRelative_data_vec;
IRelative_data_vec irelative_data_vec_;
};
// Create the PLT section. The ordinary .got section is an argument,
@ -7318,10 +7484,14 @@ class Output_data_plt_arm : public Output_section_data
// section just for PLT entries.
template<bool big_endian>
Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* layout,
uint64_t addralign,
Output_data_space* got_plt)
: Output_section_data(addralign), got_plt_(got_plt), count_(0)
Output_data_plt_arm<big_endian>::Output_data_plt_arm(
Layout* layout, uint64_t addralign,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative)
: Output_section_data(addralign), irelative_rel_(NULL),
got_(got), got_plt_(got_plt), got_irelative_(got_irelative),
count_(0), irelative_count_(0)
{
this->rel_ = new Reloc_section(false);
layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
@ -7340,40 +7510,210 @@ Output_data_plt_arm<big_endian>::do_adjust_output_section(Output_section* os)
template<bool big_endian>
void
Output_data_plt_arm<big_endian>::add_entry(Symbol* gsym)
Output_data_plt_arm<big_endian>::add_entry(Symbol_table* symtab,
Layout* layout,
Symbol* gsym)
{
gold_assert(!gsym->has_plt_offset());
// Note that when setting the PLT offset we skip the initial
// reserved PLT entry.
gsym->set_plt_offset((this->count_) * this->get_plt_entry_size()
+ this->first_plt_entry_offset());
unsigned int* entry_count;
Output_section_data_build* got;
// We have 2 different types of plt entry here, normal and ifunc.
// For normal plt, the offset begins with first_plt_entry_offset(20), and the
// 1st entry offset would be 20, the second 32, third 44 ... etc.
// For ifunc plt, the offset begins with 0. So the first offset would 0,
// second 12, third 24 ... etc.
// IFunc plt entries *always* come after *normal* plt entries.
// Notice, when computing the plt address of a certain symbol, "plt_address +
// plt_offset" is no longer correct. Use target->plt_address_for_global() or
// target->plt_address_for_local() instead.
int begin_offset = 0;
if (gsym->type() == elfcpp::STT_GNU_IFUNC
&& gsym->can_use_relative_reloc(false))
{
entry_count = &this->irelative_count_;
got = this->got_irelative_;
// For irelative plt entries, offset is relative to the end of normal plt
// entries, so it starts from 0.
begin_offset = 0;
// Record symbol information.
this->insert_irelative_data(
IRelative_data(symtab->get_sized_symbol<32>(gsym)));
}
else
{
entry_count = &this->count_;
got = this->got_plt_;
// Note that for normal plt entries, when setting the PLT offset we skip
// the initial reserved PLT entry.
begin_offset = this->first_plt_entry_offset();
}
gsym->set_plt_offset(begin_offset
+ (*entry_count) * this->get_plt_entry_size());
++this->count_;
++(*entry_count);
section_offset_type got_offset = this->got_plt_->current_data_size();
section_offset_type got_offset = got->current_data_size();
// Every PLT entry needs a GOT entry which points back to the PLT
// entry (this will be changed by the dynamic linker, normally
// lazily when the function is called).
this->got_plt_->set_current_data_size(got_offset + 4);
got->set_current_data_size(got_offset + 4);
// Every PLT entry needs a reloc.
gsym->set_needs_dynsym_entry();
this->rel_->add_global(gsym, elfcpp::R_ARM_JUMP_SLOT, this->got_plt_,
got_offset);
this->add_relocation(symtab, layout, gsym, got_offset);
// Note that we don't need to save the symbol. The contents of the
// PLT are independent of which symbols are used. The symbols only
// appear in the relocations.
}
// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return
// the PLT offset.
template<bool big_endian>
unsigned int
Output_data_plt_arm<big_endian>::add_local_ifunc_entry(
Symbol_table* symtab,
Layout* layout,
Sized_relobj_file<32, big_endian>* relobj,
unsigned int local_sym_index)
{
this->insert_irelative_data(IRelative_data(relobj, local_sym_index));
// Notice, when computingthe plt entry address, "plt_address + plt_offset" is
// no longer correct. Use target->plt_address_for_local() instead.
unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size();
++this->irelative_count_;
section_offset_type got_offset = this->got_irelative_->current_data_size();
// Every PLT entry needs a GOT entry which points back to the PLT
// entry.
this->got_irelative_->set_current_data_size(got_offset + 4);
// Every PLT entry needs a reloc.
Reloc_section* rel = this->rel_irelative(symtab, layout);
rel->add_symbolless_local_addend(relobj, local_sym_index,
elfcpp::R_ARM_IRELATIVE,
this->got_irelative_, got_offset);
return plt_offset;
}
// Add the relocation for a PLT entry.
template<bool big_endian>
void
Output_data_plt_arm<big_endian>::add_relocation(
Symbol_table* symtab, Layout* layout, Symbol* gsym, unsigned int got_offset)
{
if (gsym->type() == elfcpp::STT_GNU_IFUNC
&& gsym->can_use_relative_reloc(false))
{
Reloc_section* rel = this->rel_irelative(symtab, layout);
rel->add_symbolless_global_addend(gsym, elfcpp::R_ARM_IRELATIVE,
this->got_irelative_, got_offset);
}
else
{
gsym->set_needs_dynsym_entry();
this->rel_->add_global(gsym, elfcpp::R_ARM_JUMP_SLOT, this->got_plt_,
got_offset);
}
}
// Create the irelative relocation data.
template<bool big_endian>
typename Output_data_plt_arm<big_endian>::Reloc_section*
Output_data_plt_arm<big_endian>::rel_irelative(Symbol_table* symtab,
Layout* layout)
{
if (this->irelative_rel_ == NULL)
{
// Since irelative relocations goes into 'rel.dyn', we delegate the
// creation of irelative_rel_ to where rel_dyn section gets created.
Target_arm<big_endian>* arm_target =
Target_arm<big_endian>::default_target();
this->irelative_rel_ = arm_target->rel_irelative_section(layout);
// Make sure we have a place for the TLSDESC relocations, in
// case we see any later on.
// this->rel_tlsdesc(layout);
if (parameters->doing_static_link())
{
// A statically linked executable will only have a .rel.plt section to
// hold R_ARM_IRELATIVE relocs for STT_GNU_IFUNC symbols. The library
// will use these symbols to locate the IRELATIVE relocs at program
// startup time.
symtab->define_in_output_data("__rel_iplt_start", NULL,
Symbol_table::PREDEFINED,
this->irelative_rel_, 0, 0,
elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
elfcpp::STV_HIDDEN, 0, false, true);
symtab->define_in_output_data("__rel_iplt_end", NULL,
Symbol_table::PREDEFINED,
this->irelative_rel_, 0, 0,
elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
elfcpp::STV_HIDDEN, 0, true, true);
}
}
return this->irelative_rel_;
}
// Return the PLT address for a global symbol.
template<bool big_endian>
uint32_t
Output_data_plt_arm<big_endian>::address_for_global(const Symbol* gsym) const
{
uint64_t begin_offset = 0;
if (gsym->type() == elfcpp::STT_GNU_IFUNC
&& gsym->can_use_relative_reloc(false))
{
begin_offset = (this->first_plt_entry_offset() +
this->count_ * this->get_plt_entry_size());
}
return this->address() + begin_offset + gsym->plt_offset();
}
// Return the PLT address for a local symbol. These are always
// IRELATIVE relocs.
template<bool big_endian>
uint32_t
Output_data_plt_arm<big_endian>::address_for_local(
const Relobj* object,
unsigned int r_sym) const
{
return (this->address()
+ this->first_plt_entry_offset()
+ this->count_ * this->get_plt_entry_size()
+ object->local_plt_offset(r_sym));
}
template<bool big_endian>
class Output_data_plt_arm_standard : public Output_data_plt_arm<big_endian>
{
public:
Output_data_plt_arm_standard(Layout* layout, Output_data_space* got_plt)
: Output_data_plt_arm<big_endian>(layout, 4, got_plt)
Output_data_plt_arm_standard(Layout* layout,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative)
: Output_data_plt_arm<big_endian>(layout, 4, got, got_plt, got_irelative)
{ }
protected:
@ -7485,8 +7825,11 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of)
unsigned char* const oview = of->get_output_view(offset, oview_size);
const off_t got_file_offset = this->got_plt_->offset();
gold_assert(got_file_offset + this->got_plt_->data_size()
== this->got_irelative_->offset());
const section_size_type got_size =
convert_to_section_size_type(this->got_plt_->data_size());
convert_to_section_size_type(this->got_plt_->data_size()
+ this->got_irelative_->data_size());
unsigned char* const got_view = of->get_output_view(got_file_offset,
got_size);
unsigned char* pov = oview;
@ -7505,7 +7848,8 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of)
unsigned int plt_offset = this->first_plt_entry_offset();
unsigned int got_offset = 12;
const unsigned int count = this->count_;
const unsigned int count = this->count_ + this->irelative_count_;
gold_assert(this->irelative_count_ == this->irelative_data_vec_.size());
for (unsigned int i = 0;
i < count;
++i,
@ -7518,8 +7862,33 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of)
this->fill_plt_entry(pov, got_address, plt_address,
got_offset, plt_offset);
// Set the entry in the GOT.
elfcpp::Swap<32, big_endian>::writeval(got_pov, plt_address);
Arm_address value;
if (i < this->count_)
{
// For non-irelative got entries, the value is the beginning of plt.
value = plt_address;
}
else
{
// For irelative got entries, the value is the (global/local) symbol
// address.
const IRelative_data& idata =
this->irelative_data_vec_[i - this->count_];
if (idata.symbol_is_global_)
{
// Set the entry in the GOT for irelative symbols. The content is
// the address of the ifunc, not the address of plt start.
const Sized_symbol<32>* sized_symbol = idata.u_.global;
gold_assert(sized_symbol->type() == elfcpp::STT_GNU_IFUNC);
value = sized_symbol->value();
}
else
{
value = idata.u_.local.relobj->local_symbol_value(
idata.u_.local.index, 0);
}
}
elfcpp::Swap<32, big_endian>::writeval(got_pov, value);
}
gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
@ -7529,6 +7898,7 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of)
of->write_output_view(got_file_offset, got_size, got_view);
}
// Create a PLT entry for a global symbol.
template<bool big_endian>
@ -7539,21 +7909,59 @@ Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* layout,
if (gsym->has_plt_offset())
return;
if (this->plt_ == NULL)
this->make_plt_section(symtab, layout);
this->plt_->add_entry(symtab, layout, gsym);
}
// Create the PLT section.
template<bool big_endian>
void
Target_arm<big_endian>::make_plt_section(
Symbol_table* symtab, Layout* layout)
{
if (this->plt_ == NULL)
{
// Create the GOT sections first.
// Create the GOT section first.
this->got_section(symtab, layout);
this->plt_ = this->make_data_plt(layout, this->got_plt_);
// GOT for irelatives is create along with got.plt.
gold_assert(this->got_ != NULL
&& this->got_plt_ != NULL
&& this->got_irelative_ != NULL);
this->plt_ = this->make_data_plt(layout, this->got_, this->got_plt_,
this->got_irelative_);
layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
(elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR),
this->plt_, ORDER_PLT, false);
}
this->plt_->add_entry(gsym);
}
// Make a PLT entry for a local STT_GNU_IFUNC symbol.
template<bool big_endian>
void
Target_arm<big_endian>::make_local_ifunc_plt_entry(
Symbol_table* symtab, Layout* layout,
Sized_relobj_file<32, big_endian>* relobj,
unsigned int local_sym_index)
{
if (relobj->local_has_plt_offset(local_sym_index))
return;
if (this->plt_ == NULL)
this->make_plt_section(symtab, layout);
unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout,
relobj,
local_sym_index);
relobj->set_local_plt_offset(local_sym_index, plt_offset);
}
// Return the number of entries in the PLT.
template<bool big_endian>
@ -7823,6 +8231,7 @@ Target_arm<big_endian>::Scan::check_non_pic(Relobj* object,
case elfcpp::R_ARM_JUMP_SLOT:
case elfcpp::R_ARM_ABS32:
case elfcpp::R_ARM_ABS32_NOI:
case elfcpp::R_ARM_IRELATIVE:
case elfcpp::R_ARM_PC24:
// FIXME: The following 3 types are not supported by Android's dynamic
// linker.
@ -7853,6 +8262,27 @@ Target_arm<big_endian>::Scan::check_non_pic(Relobj* object,
}
}
// Return whether we need to make a PLT entry for a relocation of the
// given type against a STT_GNU_IFUNC symbol.
template<bool big_endian>
bool
Target_arm<big_endian>::Scan::reloc_needs_plt_for_ifunc(
Sized_relobj_file<32, big_endian>* object,
unsigned int r_type)
{
int flags = Scan::get_reference_flags(r_type);
if (flags & Symbol::TLS_REF)
{
gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
object->name().c_str(), r_type);
return false;
}
return flags != 0;
}
// Scan a relocation for a local symbol.
// FIXME: This only handles a subset of relocation types used by Android
// on ARM v5te devices.
@ -7874,6 +8304,15 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab,
return;
r_type = get_real_reloc_type(r_type);
// A local STT_GNU_IFUNC symbol may require a PLT entry.
bool is_ifunc = lsym.get_st_type() == elfcpp::STT_GNU_IFUNC;
if (is_ifunc && this->reloc_needs_plt_for_ifunc(object, r_type))
{
unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
}
switch (r_type)
{
case elfcpp::R_ARM_NONE:
@ -7898,7 +8337,7 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab,
// we need to add check_non_pic(object, r_type) here.
rel_dyn->add_local_relative(object, r_sym, elfcpp::R_ARM_RELATIVE,
output_section, data_shndx,
reloc.get_r_offset());
reloc.get_r_offset(), is_ifunc);
}
break;
@ -8265,6 +8704,11 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab,
&& strcmp(gsym->name(), "_GLOBAL_OFFSET_TABLE_") == 0)
target->got_section(symtab, layout);
// A STT_GNU_IFUNC symbol may require a PLT entry.
if (gsym->type() == elfcpp::STT_GNU_IFUNC
&& this->reloc_needs_plt_for_ifunc(object, r_type))
target->make_plt_entry(symtab, layout, gsym);
r_type = get_real_reloc_type(r_type);
switch (r_type)
{
@ -8307,6 +8751,24 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab,
target->copy_reloc(symtab, layout, object,
data_shndx, output_section, gsym, reloc);
}
else if ((r_type == elfcpp::R_ARM_ABS32
|| r_type == elfcpp::R_ARM_ABS32_NOI)
&& gsym->type() == elfcpp::STT_GNU_IFUNC
&& gsym->can_use_relative_reloc(false)
&& !gsym->is_from_dynobj()
&& !gsym->is_undefined()
&& !gsym->is_preemptible())
{
// Use an IRELATIVE reloc for a locally defined STT_GNU_IFUNC
// symbol. This makes a function address in a PIE executable
// match the address in a shared library that it links against.
Reloc_section* rel_irelative =
target->rel_irelative_section(layout);
unsigned int r_type = elfcpp::R_ARM_IRELATIVE;
rel_irelative->add_symbolless_global_addend(
gsym, r_type, output_section, object,
data_shndx, reloc.get_r_offset());
}
else if ((r_type == elfcpp::R_ARM_ABS32
|| r_type == elfcpp::R_ARM_ABS32_NOI)
&& gsym->can_use_relative_reloc(false))
@ -8442,7 +8904,13 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab,
Arm_output_data_got<big_endian>* got =
target->got_section(symtab, layout);
if (gsym->final_value_is_known())
got->add_global(gsym, GOT_TYPE_STANDARD);
{
// For a STT_GNU_IFUNC symbol we want the PLT address.
if (gsym->type() == elfcpp::STT_GNU_IFUNC)
got->add_global_plt(gsym, GOT_TYPE_STANDARD);
else
got->add_global(gsym, GOT_TYPE_STANDARD);
}
else
{
// If this symbol is not fully resolved, we need to add a
@ -8452,12 +8920,29 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab,
|| gsym->is_undefined()
|| gsym->is_preemptible()
|| (gsym->visibility() == elfcpp::STV_PROTECTED
&& parameters->options().shared()))
&& parameters->options().shared())
|| (gsym->type() == elfcpp::STT_GNU_IFUNC
&& parameters->options().output_is_position_independent()))
got->add_global_with_rel(gsym, GOT_TYPE_STANDARD,
rel_dyn, elfcpp::R_ARM_GLOB_DAT);
else
{
if (got->add_global(gsym, GOT_TYPE_STANDARD))
// For a STT_GNU_IFUNC symbol we want to write the PLT
// offset into the GOT, so that function pointer
// comparisons work correctly.
bool is_new;
if (gsym->type() != elfcpp::STT_GNU_IFUNC)
is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
else
{
is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
// Tell the dynamic linker to use the PLT address
// when resolving relocations.
if (gsym->is_from_dynobj()
&& !parameters->options().shared())
gsym->set_needs_dynsym_value();
}
if (is_new)
rel_dyn->add_global_relative(
gsym, elfcpp::R_ARM_RELATIVE, got,
gsym->got_offset(GOT_TYPE_STANDARD));
@ -8919,8 +9404,7 @@ Target_arm<big_endian>::Relocate::relocate(
if (gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
{
// This uses a PLT, change the symbol value.
symval.set_output_value(target->plt_section()->address()
+ gsym->plt_offset());
symval.set_output_value(target->plt_address_for_global(gsym));
psymval = &symval;
}
else if (gsym->is_weak_undefined())
@ -8958,6 +9442,13 @@ Target_arm<big_endian>::Relocate::relocate(
elfcpp::Elf_types<32>::Elf_WXword r_info = rel.get_r_info();
unsigned int r_sym = elfcpp::elf_r_sym<32>(r_info);
thumb_bit = object->local_symbol_is_thumb_function(r_sym) ? 1 : 0;
if (psymval->is_ifunc_symbol() && object->local_has_plt_offset(r_sym))
{
symval.set_output_value(
target->plt_address_for_local(object, r_sym));
psymval = &symval;
}
}
}
else
@ -9936,7 +10427,7 @@ uint64_t
Target_arm<big_endian>::do_dynsym_value(const Symbol* gsym) const
{
gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
return this->plt_section()->address() + gsym->plt_offset();
return this->plt_address_for_global(gsym);
}
// Map platform-specific relocs to real relocs
@ -11091,8 +11582,7 @@ Target_arm<big_endian>::scan_reloc_for_stub(
if (gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
{
// This uses a PLT, change the symbol value.
symval.set_output_value(this->plt_section()->address()
+ gsym->plt_offset());
symval.set_output_value(this->plt_address_for_global(gsym));
psymval = &symval;
target_is_thumb = false;
}
@ -12195,8 +12685,13 @@ class Target_arm_nacl : public Target_arm<big_endian>
protected:
virtual Output_data_plt_arm<big_endian>*
do_make_data_plt(Layout* layout, Output_data_space* got_plt)
{ return new Output_data_plt_arm_nacl<big_endian>(layout, got_plt); }
do_make_data_plt(
Layout* layout,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative)
{ return new Output_data_plt_arm_nacl<big_endian>(
layout, got, got_plt, got_irelative); }
private:
static const Target::Target_info arm_nacl_info;
@ -12233,8 +12728,12 @@ template<bool big_endian>
class Output_data_plt_arm_nacl : public Output_data_plt_arm<big_endian>
{
public:
Output_data_plt_arm_nacl(Layout* layout, Output_data_space* got_plt)
: Output_data_plt_arm<big_endian>(layout, 16, got_plt)
Output_data_plt_arm_nacl(
Layout* layout,
Arm_output_data_got<big_endian>* got,
Output_data_space* got_plt,
Output_data_space* got_irelative)
: Output_data_plt_arm<big_endian>(layout, 16, got, got_plt, got_irelative)
{ }
protected:

11
gold/output.h
View File

@ -1714,6 +1714,17 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
address, true, true, false, false));
}
void
add_local_relative(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
Output_data* od, unsigned int shndx, Address address,
bool use_plt_offset)
{
this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
address, true, true, false,
use_plt_offset));
}
// Add a local relocation which does not use a symbol for the relocation,
// but which gets its addend from a symbol.

Write Preview
Loading…
Cancel
Save