using namespace gold;
-class Output_data_plt_x86_64;
+// A class to handle the PLT data.
+
+class Output_data_plt_x86_64 : public Output_section_data
+{
+ public:
+ typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;
+
+ Output_data_plt_x86_64(Symbol_table*, Layout*, Output_data_got<64, false>*,
+ Output_data_space*);
+
+ // Add an entry to the PLT.
+ void
+ add_entry(Symbol* gsym);
+
+ // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
+ unsigned int
+ add_local_ifunc_entry(Sized_relobj<64, false>* relobj,
+ unsigned int local_sym_index);
+
+ // Add the reserved TLSDESC_PLT entry to the PLT.
+ void
+ reserve_tlsdesc_entry(unsigned int got_offset)
+ { this->tlsdesc_got_offset_ = got_offset; }
+
+ // Return true if a TLSDESC_PLT entry has been reserved.
+ bool
+ has_tlsdesc_entry() const
+ { return this->tlsdesc_got_offset_ != -1U; }
+
+ // Return the GOT offset for the reserved TLSDESC_PLT entry.
+ unsigned int
+ get_tlsdesc_got_offset() const
+ { return this->tlsdesc_got_offset_; }
+
+ // Return the offset of the reserved TLSDESC_PLT entry.
+ unsigned int
+ get_tlsdesc_plt_offset() const
+ { return (this->count_ + 1) * plt_entry_size; }
+
+ // Return the .rela.plt section data.
+ Reloc_section*
+ rela_plt()
+ { return this->rel_; }
+
+ // Return where the TLSDESC relocations should go.
+ Reloc_section*
+ rela_tlsdesc(Layout*);
+
+ // Return the number of PLT entries.
+ unsigned int
+ entry_count() const
+ { return this->count_; }
+
+ // Return the offset of the first non-reserved PLT entry.
+ static unsigned int
+ first_plt_entry_offset()
+ { return plt_entry_size; }
+
+ // Return the size of a PLT entry.
+ static unsigned int
+ get_plt_entry_size()
+ { return plt_entry_size; }
+
+ protected:
+ void
+ do_adjust_output_section(Output_section* os);
+
+ // Write to a map file.
+ void
+ do_print_to_mapfile(Mapfile* mapfile) const
+ { mapfile->print_output_data(this, _("** PLT")); }
+
+ private:
+ // The size of an entry in the PLT.
+ static const int plt_entry_size = 16;
+
+ // The first entry in the PLT.
+ // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same
+ // procedure linkage table for both programs and shared objects."
+ static unsigned char first_plt_entry[plt_entry_size];
+
+ // Other entries in the PLT for an executable.
+ static unsigned char plt_entry[plt_entry_size];
+
+ // The reserved TLSDESC entry in the PLT for an executable.
+ static unsigned char tlsdesc_plt_entry[plt_entry_size];
+
+ // Set the final size.
+ void
+ set_final_data_size();
+
+ // Write out the PLT data.
+ void
+ do_write(Output_file*);
+
+ // The reloc section.
+ Reloc_section* rel_;
+ // The TLSDESC relocs, if necessary. These must follow the regular
+ // PLT relocs.
+ Reloc_section* tlsdesc_rel_;
+ // The .got section.
+ Output_data_got<64, false>* got_;
+ // The .got.plt section.
+ Output_data_space* got_plt_;
+ // The number of PLT entries.
+ unsigned int count_;
+ // Offset of the reserved TLSDESC_GOT entry when needed.
+ unsigned int tlsdesc_got_offset_;
+};
// The x86_64 target class.
// See the ABI at
uint64_t
do_reloc_addend(void* arg, unsigned int r_type, uint64_t addend) const;
+ // Return the PLT section.
+ Output_data*
+ do_plt_section_for_global(const Symbol*) const
+ { return this->plt_section(); }
+
+ Output_data*
+ do_plt_section_for_local(const Relobj*, unsigned int) const
+ { return this->plt_section(); }
+
// Adjust -fstack-split code which calls non-stack-split code.
void
do_calls_non_split(Relobj* object, unsigned int shndx,
// Return the size of the GOT section.
section_size_type
- got_size()
+ got_size() const
{
gold_assert(this->got_ != NULL);
return this->got_->data_size();
}
+ // Return the number of entries in the GOT.
+ unsigned int
+ got_entry_count() const
+ {
+ if (this->got_ == NULL)
+ return 0;
+ return this->got_size() / 8;
+ }
+
+ // Return the number of entries in the PLT.
+ unsigned int
+ plt_entry_count() const;
+
+ // Return the offset of the first non-reserved PLT entry.
+ unsigned int
+ first_plt_entry_offset() const;
+
+ // Return the size of each PLT entry.
+ unsigned int
+ plt_entry_size() const;
+
// Add a new reloc argument, returning the index in the vector.
size_t
add_tlsdesc_info(Sized_relobj<64, false>* object, unsigned int r_sym)
inline bool
possible_function_pointer_reloc(unsigned int r_type);
+ bool
+ reloc_needs_plt_for_ifunc(Sized_relobj<64, false>*, unsigned int r_type);
+
// Whether we have issued an error about a non-PIC compilation.
bool issued_non_pic_error_;
};
{
public:
Relocate()
- : skip_call_tls_get_addr_(false), saw_tls_block_reloc_(false)
+ : skip_call_tls_get_addr_(false)
{ }
~Relocate()
// This is set if we should skip the next reloc, which should be a
// PLT32 reloc against ___tls_get_addr.
bool skip_call_tls_get_addr_;
-
- // This is set if we see a relocation which could load the address
- // of the TLS block. Whether we see such a relocation determines
- // how we handle the R_X86_64_DTPOFF32 relocation, which is used
- // in debugging sections.
- bool saw_tls_block_reloc_;
};
// A class which returns the size required for a relocation type,
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<64, false>* relobj,
+ unsigned int local_sym_index);
+
// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
void
define_tls_base_symbol(Symbol_table*, Layout*);
// general Target structure.
static const Target::Target_info x86_64_info;
+ // The types of GOT entries needed for this platform.
+ // These values are exposed to the ABI in an incremental link.
+ // Do not renumber existing values without changing the version
+ // number of the .gnu_incremental_inputs section.
enum Got_type
{
GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
// we handle the SHF_X86_64_LARGE.
void
-Target_x86_64::do_new_output_section(Output_section *os) const
+Target_x86_64::do_new_output_section(Output_section* os) const
{
if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0)
os->set_is_large_section();
return this->rela_dyn_;
}
-// A class to handle the PLT data.
-
-class Output_data_plt_x86_64 : public Output_section_data
-{
- public:
- typedef Output_data_reloc<elfcpp::SHT_RELA, true, 64, false> Reloc_section;
-
- Output_data_plt_x86_64(Layout*, Output_data_got<64, false>*,
- Output_data_space*);
-
- // Add an entry to the PLT.
- void
- add_entry(Symbol* gsym);
-
- // Add the reserved TLSDESC_PLT entry to the PLT.
- void
- reserve_tlsdesc_entry(unsigned int got_offset)
- { this->tlsdesc_got_offset_ = got_offset; }
-
- // Return true if a TLSDESC_PLT entry has been reserved.
- bool
- has_tlsdesc_entry() const
- { return this->tlsdesc_got_offset_ != -1U; }
-
- // Return the GOT offset for the reserved TLSDESC_PLT entry.
- unsigned int
- get_tlsdesc_got_offset() const
- { return this->tlsdesc_got_offset_; }
-
- // Return the offset of the reserved TLSDESC_PLT entry.
- unsigned int
- get_tlsdesc_plt_offset() const
- { return (this->count_ + 1) * plt_entry_size; }
-
- // Return the .rela.plt section data.
- const Reloc_section*
- rela_plt() const
- { return this->rel_; }
-
- // Return where the TLSDESC relocations should go.
- Reloc_section*
- rela_tlsdesc(Layout*);
-
- protected:
- void
- do_adjust_output_section(Output_section* os);
-
- // Write to a map file.
- void
- do_print_to_mapfile(Mapfile* mapfile) const
- { mapfile->print_output_data(this, _("** PLT")); }
-
- private:
- // The size of an entry in the PLT.
- static const int plt_entry_size = 16;
-
- // The first entry in the PLT.
- // From the AMD64 ABI: "Unlike Intel386 ABI, this ABI uses the same
- // procedure linkage table for both programs and shared objects."
- static unsigned char first_plt_entry[plt_entry_size];
-
- // Other entries in the PLT for an executable.
- static unsigned char plt_entry[plt_entry_size];
-
- // The reserved TLSDESC entry in the PLT for an executable.
- static unsigned char tlsdesc_plt_entry[plt_entry_size];
-
- // Set the final size.
- void
- set_final_data_size();
-
- // Write out the PLT data.
- void
- do_write(Output_file*);
-
- // The reloc section.
- Reloc_section* rel_;
- // The TLSDESC relocs, if necessary. These must follow the regular
- // PLT relocs.
- Reloc_section* tlsdesc_rel_;
- // The .got section.
- Output_data_got<64, false>* got_;
- // The .got.plt section.
- Output_data_space* got_plt_;
- // The number of PLT entries.
- unsigned int count_;
- // Offset of the reserved TLSDESC_GOT entry when needed.
- unsigned int tlsdesc_got_offset_;
-};
-
// Create the PLT section. The ordinary .got section is an argument,
// since we need to refer to the start. We also create our own .got
// section just for PLT entries.
-Output_data_plt_x86_64::Output_data_plt_x86_64(Layout* layout,
+Output_data_plt_x86_64::Output_data_plt_x86_64(Symbol_table* symtab,
+ Layout* layout,
Output_data_got<64, false>* got,
Output_data_space* got_plt)
: Output_section_data(8), tlsdesc_rel_(NULL), got_(got), got_plt_(got_plt),
layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
elfcpp::SHF_ALLOC, this->rel_,
ORDER_DYNAMIC_PLT_RELOCS, false);
+
+ if (parameters->doing_static_link())
+ {
+ // A statically linked executable will only have a .rela.plt
+ // section to hold R_X86_64_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("__rela_iplt_start", NULL,
+ Symbol_table::PREDEFINED,
+ this->rel_, 0, 0, elfcpp::STT_NOTYPE,
+ elfcpp::STB_GLOBAL, elfcpp::STV_HIDDEN,
+ 0, false, true);
+ symtab->define_in_output_data("__rela_iplt_end", NULL,
+ Symbol_table::PREDEFINED,
+ this->rel_, 0, 0, elfcpp::STT_NOTYPE,
+ elfcpp::STB_GLOBAL, elfcpp::STV_HIDDEN,
+ 0, true, true);
+ }
}
void
this->got_plt_->set_current_data_size(got_offset + 8);
// Every PLT entry needs a reloc.
- gsym->set_needs_dynsym_entry();
- this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_,
- got_offset, 0);
+ if (gsym->type() == elfcpp::STT_GNU_IFUNC
+ && gsym->can_use_relative_reloc(false))
+ this->rel_->add_symbolless_global_addend(gsym, elfcpp::R_X86_64_IRELATIVE,
+ this->got_plt_, got_offset, 0);
+ else
+ {
+ gsym->set_needs_dynsym_entry();
+ this->rel_->add_global(gsym, elfcpp::R_X86_64_JUMP_SLOT, this->got_plt_,
+ got_offset, 0);
+ }
// 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.
+
+unsigned int
+Output_data_plt_x86_64::add_local_ifunc_entry(Sized_relobj<64, false>* relobj,
+ unsigned int local_sym_index)
+{
+ unsigned int plt_offset = (this->count_ + 1) * plt_entry_size;
+ ++this->count_;
+
+ section_offset_type got_offset = this->got_plt_->current_data_size();
+
+ // Every PLT entry needs a GOT entry which points back to the PLT
+ // entry.
+ this->got_plt_->set_current_data_size(got_offset + 8);
+
+ // Every PLT entry needs a reloc.
+ this->rel_->add_symbolless_local_addend(relobj, local_sym_index,
+ elfcpp::R_X86_64_IRELATIVE,
+ this->got_plt_, got_offset, 0);
+
+ return plt_offset;
+}
+
// Return where the TLSDESC relocations should go, creating it if
// necessary. These follow the JUMP_SLOT relocations.
// Create the GOT sections first.
this->got_section(symtab, layout);
- this->plt_ = new Output_data_plt_x86_64(layout, this->got_,
+ this->plt_ = new Output_data_plt_x86_64(symtab, layout, this->got_,
this->got_plt_);
layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
(elfcpp::SHF_ALLOC
| elfcpp::SHF_EXECINSTR),
this->plt_, ORDER_PLT, false);
+
+ // Make the sh_info field of .rela.plt point to .plt.
+ Output_section* rela_plt_os = this->plt_->rela_plt()->output_section();
+ rela_plt_os->set_info_section(this->plt_->output_section());
}
}
this->plt_->add_entry(gsym);
}
+// Make a PLT entry for a local STT_GNU_IFUNC symbol.
+
+void
+Target_x86_64::make_local_ifunc_plt_entry(Symbol_table* symtab, Layout* layout,
+ Sized_relobj<64, false>* 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(relobj,
+ local_sym_index);
+ relobj->set_local_plt_offset(local_sym_index, plt_offset);
+}
+
+// Return the number of entries in the PLT.
+
+unsigned int
+Target_x86_64::plt_entry_count() const
+{
+ if (this->plt_ == NULL)
+ return 0;
+ return this->plt_->entry_count();
+}
+
+// Return the offset of the first non-reserved PLT entry.
+
+unsigned int
+Target_x86_64::first_plt_entry_offset() const
+{
+ return Output_data_plt_x86_64::first_plt_entry_offset();
+}
+
+// Return the size of each PLT entry.
+
+unsigned int
+Target_x86_64::plt_entry_size() const
+{
+ return Output_data_plt_x86_64::get_plt_entry_size();
+}
+
// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
void
{
// These are the relocation types supported by glibc for x86_64.
case elfcpp::R_X86_64_RELATIVE:
+ case elfcpp::R_X86_64_IRELATIVE:
case elfcpp::R_X86_64_GLOB_DAT:
case elfcpp::R_X86_64_JUMP_SLOT:
case elfcpp::R_X86_64_DTPMOD64:
}
}
+// Return whether we need to make a PLT entry for a relocation of the
+// given type against a STT_GNU_IFUNC symbol.
+
+bool
+Target_x86_64::Scan::reloc_needs_plt_for_ifunc(Sized_relobj<64, false>* object,
+ unsigned int r_type)
+{
+ switch (r_type)
+ {
+ case elfcpp::R_X86_64_NONE:
+ case elfcpp::R_X86_64_GNU_VTINHERIT:
+ case elfcpp::R_X86_64_GNU_VTENTRY:
+ return false;
+
+ case elfcpp::R_X86_64_64:
+ case elfcpp::R_X86_64_32:
+ case elfcpp::R_X86_64_32S:
+ case elfcpp::R_X86_64_16:
+ case elfcpp::R_X86_64_8:
+ case elfcpp::R_X86_64_PC64:
+ case elfcpp::R_X86_64_PC32:
+ case elfcpp::R_X86_64_PC16:
+ case elfcpp::R_X86_64_PC8:
+ case elfcpp::R_X86_64_PLT32:
+ case elfcpp::R_X86_64_GOTPC32:
+ case elfcpp::R_X86_64_GOTOFF64:
+ case elfcpp::R_X86_64_GOTPC64:
+ case elfcpp::R_X86_64_PLTOFF64:
+ case elfcpp::R_X86_64_GOT64:
+ case elfcpp::R_X86_64_GOT32:
+ case elfcpp::R_X86_64_GOTPCREL64:
+ case elfcpp::R_X86_64_GOTPCREL:
+ case elfcpp::R_X86_64_GOTPLT64:
+ return true;
+
+ case elfcpp::R_X86_64_COPY:
+ case elfcpp::R_X86_64_GLOB_DAT:
+ case elfcpp::R_X86_64_JUMP_SLOT:
+ case elfcpp::R_X86_64_RELATIVE:
+ case elfcpp::R_X86_64_IRELATIVE:
+ case elfcpp::R_X86_64_TPOFF64:
+ case elfcpp::R_X86_64_DTPMOD64:
+ case elfcpp::R_X86_64_TLSDESC:
+ // We will give an error later.
+ return false;
+
+ case elfcpp::R_X86_64_TLSGD:
+ case elfcpp::R_X86_64_GOTPC32_TLSDESC:
+ case elfcpp::R_X86_64_TLSDESC_CALL:
+ case elfcpp::R_X86_64_TLSLD:
+ case elfcpp::R_X86_64_DTPOFF32:
+ case elfcpp::R_X86_64_DTPOFF64:
+ case elfcpp::R_X86_64_GOTTPOFF:
+ case elfcpp::R_X86_64_TPOFF32:
+ gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
+ object->name().c_str(), r_type);
+ return false;
+
+ case elfcpp::R_X86_64_SIZE32:
+ case elfcpp::R_X86_64_SIZE64:
+ default:
+ // We will give an error later.
+ return false;
+ }
+}
+
// Scan a relocation for a local symbol.
inline void
unsigned int r_type,
const elfcpp::Sym<64, false>& lsym)
{
+ // A local STT_GNU_IFUNC symbol may require a PLT entry.
+ if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC
+ && this->reloc_needs_plt_for_ifunc(object, r_type))
+ {
+ unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
+ target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
+ }
+
switch (r_type)
{
case elfcpp::R_X86_64_NONE:
{
unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
- rela_dyn->add_local_relative(object, r_sym,
- elfcpp::R_X86_64_RELATIVE,
- output_section, data_shndx,
- reloc.get_r_offset(),
- reloc.get_r_addend());
+ rela_dyn->add_local_relative(object, r_sym,
+ elfcpp::R_X86_64_RELATIVE,
+ output_section, data_shndx,
+ reloc.get_r_offset(),
+ reloc.get_r_addend());
}
break;
// The symbol requires a GOT entry.
Output_data_got<64, false>* got = target->got_section(symtab, layout);
unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
- if (got->add_local(object, r_sym, GOT_TYPE_STANDARD))
+
+ // For a STT_GNU_IFUNC symbol we want the PLT offset. That
+ // lets function pointers compare correctly with shared
+ // libraries. Otherwise we would need an IRELATIVE reloc.
+ bool is_new;
+ if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC)
+ is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
+ else
+ is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
+ if (is_new)
{
// If we are generating a shared object, we need to add a
// dynamic relocation for this symbol's GOT entry.
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
// R_X86_64_RELATIVE assumes a 64-bit relocation.
if (r_type != elfcpp::R_X86_64_GOT32)
- rela_dyn->add_local_relative(
- object, r_sym, elfcpp::R_X86_64_RELATIVE, got,
- object->local_got_offset(r_sym, GOT_TYPE_STANDARD), 0);
+ {
+ unsigned int got_offset =
+ object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
+ rela_dyn->add_local_relative(object, r_sym,
+ elfcpp::R_X86_64_RELATIVE,
+ got, got_offset, 0);
+ }
else
{
this->check_non_pic(object, r_type);
case elfcpp::R_X86_64_GLOB_DAT:
case elfcpp::R_X86_64_JUMP_SLOT:
case elfcpp::R_X86_64_RELATIVE:
+ case elfcpp::R_X86_64_IRELATIVE:
// These are outstanding tls relocs, which are unexpected when linking
case elfcpp::R_X86_64_TPOFF64:
case elfcpp::R_X86_64_DTPMOD64:
unsigned int r_type,
Symbol* gsym)
{
+ // 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);
+
switch (r_type)
{
case elfcpp::R_X86_64_NONE:
target->copy_reloc(symtab, layout, object,
data_shndx, output_section, gsym, reloc);
}
+ else if (r_type == elfcpp::R_X86_64_64
+ && 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* rela_dyn = target->rela_dyn_section(layout);
+ unsigned int r_type = elfcpp::R_X86_64_IRELATIVE;
+ rela_dyn->add_symbolless_global_addend(gsym, r_type,
+ output_section, object,
+ data_shndx,
+ reloc.get_r_offset(),
+ reloc.get_r_addend());
+ }
else if (r_type == elfcpp::R_X86_64_64
&& gsym->can_use_relative_reloc(false))
{
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
- rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
- output_section, object,
- data_shndx, reloc.get_r_offset(),
- reloc.get_r_addend());
+ rela_dyn->add_global_relative(gsym, elfcpp::R_X86_64_RELATIVE,
+ output_section, object,
+ data_shndx,
+ reloc.get_r_offset(),
+ reloc.get_r_addend());
}
else
{
// The symbol requires a GOT entry.
Output_data_got<64, false>* 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
// dynamic relocation for it.
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
- if (gsym->is_from_dynobj()
- || gsym->is_undefined()
- || gsym->is_preemptible())
+ if (gsym->is_from_dynobj()
+ || gsym->is_undefined()
+ || gsym->is_preemptible()
+ || (gsym->type() == elfcpp::STT_GNU_IFUNC
+ && parameters->options().output_is_position_independent()))
got->add_global_with_rela(gsym, GOT_TYPE_STANDARD, rela_dyn,
elfcpp::R_X86_64_GLOB_DAT);
else
{
- if (got->add_global(gsym, GOT_TYPE_STANDARD))
- rela_dyn->add_global_relative(
- gsym, elfcpp::R_X86_64_RELATIVE, got,
- gsym->got_offset(GOT_TYPE_STANDARD), 0);
+ // 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)
+ {
+ unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
+ rela_dyn->add_global_relative(gsym,
+ elfcpp::R_X86_64_RELATIVE,
+ got, got_off, 0);
+ }
}
}
// For GOTPLT64, we also need a PLT entry (but only if the
case elfcpp::R_X86_64_GLOB_DAT:
case elfcpp::R_X86_64_JUMP_SLOT:
case elfcpp::R_X86_64_RELATIVE:
+ case elfcpp::R_X86_64_IRELATIVE:
// These are outstanding tls relocs, which are unexpected when linking
case elfcpp::R_X86_64_TPOFF64:
case elfcpp::R_X86_64_DTPMOD64:
// the section has been created.
target->got_section(symtab, layout);
Output_data_got<64, false>* got = target->got_tlsdesc_section();
- Reloc_section *rt = target->rela_tlsdesc_section(layout);
+ Reloc_section* rt = target->rela_tlsdesc_section(layout);
got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_DESC, rt,
elfcpp::R_X86_64_TLSDESC, 0);
}
}
}
- // Pick the value to use for symbols defined in shared objects.
+ const Sized_relobj<64, false>* object = relinfo->object;
+
+ // Pick the value to use for symbols defined in the PLT.
Symbol_value<64> symval;
if (gsym != NULL
&& gsym->use_plt_offset(r_type == elfcpp::R_X86_64_PC64
+ gsym->plt_offset());
psymval = &symval;
}
+ else if (gsym == NULL && psymval->is_ifunc_symbol())
+ {
+ unsigned int r_sym = elfcpp::elf_r_sym<64>(rela.get_r_info());
+ if (object->local_has_plt_offset(r_sym))
+ {
+ symval.set_output_value(target->plt_section()->address()
+ + object->local_plt_offset(r_sym));
+ psymval = &symval;
+ }
+ }
- const Sized_relobj<64, false>* object = relinfo->object;
const elfcpp::Elf_Xword addend = rela.get_r_addend();
// Get the GOT offset if needed.
case elfcpp::R_X86_64_GLOB_DAT:
case elfcpp::R_X86_64_JUMP_SLOT:
case elfcpp::R_X86_64_RELATIVE:
+ case elfcpp::R_X86_64_IRELATIVE:
// These are outstanding tls relocs, which are unexpected when linking
case elfcpp::R_X86_64_TPOFF64:
case elfcpp::R_X86_64_DTPMOD64:
const Sized_relobj<64, false>* object = relinfo->object;
const elfcpp::Elf_Xword addend = rela.get_r_addend();
+ elfcpp::Shdr<64, false> data_shdr(relinfo->data_shdr);
+ bool is_executable = (data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0;
elfcpp::Elf_types<64>::Elf_Addr value = psymval->value(relinfo->object, 0);
const bool is_final = (gsym == NULL
? !parameters->options().shared()
: gsym->final_value_is_known());
- const tls::Tls_optimization optimized_type
+ tls::Tls_optimization optimized_type
= Target_x86_64::optimize_tls_reloc(is_final, r_type);
switch (r_type)
{
case elfcpp::R_X86_64_TLSGD: // Global-dynamic
- this->saw_tls_block_reloc_ = true;
+ if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
+ {
+ // If this code sequence is used in a non-executable section,
+ // we will not optimize the R_X86_64_DTPOFF32/64 relocation,
+ // on the assumption that it's being used by itself in a debug
+ // section. Therefore, in the unlikely event that the code
+ // sequence appears in a non-executable section, we simply
+ // leave it unoptimized.
+ optimized_type = tls::TLSOPT_NONE;
+ }
if (optimized_type == tls::TLSOPT_TO_LE)
{
gold_assert(tls_segment != NULL);
case elfcpp::R_X86_64_GOTPC32_TLSDESC: // Global-dynamic (from ~oliva url)
case elfcpp::R_X86_64_TLSDESC_CALL:
- this->saw_tls_block_reloc_ = true;
+ if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
+ {
+ // See above comment for R_X86_64_TLSGD.
+ optimized_type = tls::TLSOPT_NONE;
+ }
if (optimized_type == tls::TLSOPT_TO_LE)
{
gold_assert(tls_segment != NULL);
break;
case elfcpp::R_X86_64_TLSLD: // Local-dynamic
- this->saw_tls_block_reloc_ = true;
+ if (!is_executable && optimized_type == tls::TLSOPT_TO_LE)
+ {
+ // See above comment for R_X86_64_TLSGD.
+ optimized_type = tls::TLSOPT_NONE;
+ }
if (optimized_type == tls::TLSOPT_TO_LE)
{
gold_assert(tls_segment != NULL);
break;
case elfcpp::R_X86_64_DTPOFF32:
- if (optimized_type == tls::TLSOPT_TO_LE)
- {
- // This relocation type is used in debugging information.
- // In that case we need to not optimize the value. If we
- // haven't seen a TLSLD reloc, then we assume we should not
- // optimize this reloc.
- if (this->saw_tls_block_reloc_)
- {
- gold_assert(tls_segment != NULL);
- value -= tls_segment->memsz();
- }
- }
+ // This relocation type is used in debugging information.
+ // In that case we need to not optimize the value. If the
+ // section is not executable, then we assume we should not
+ // optimize this reloc. See comments above for R_X86_64_TLSGD,
+ // R_X86_64_GOTPC32_TLSDESC, R_X86_64_TLSDESC_CALL, and
+ // R_X86_64_TLSLD.
+ if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
+ {
+ gold_assert(tls_segment != NULL);
+ value -= tls_segment->memsz();
+ }
Relocate_functions<64, false>::rela32(view, value, addend);
break;
case elfcpp::R_X86_64_DTPOFF64:
- if (optimized_type == tls::TLSOPT_TO_LE)
- {
- // See R_X86_64_DTPOFF32, just above, for why we test this.
- if (this->saw_tls_block_reloc_)
- {
- gold_assert(tls_segment != NULL);
- value -= tls_segment->memsz();
- }
- }
+ // See R_X86_64_DTPOFF32, just above, for why we check for is_executable.
+ if (optimized_type == tls::TLSOPT_TO_LE && is_executable)
+ {
+ gold_assert(tls_segment != NULL);
+ value -= tls_segment->memsz();
+ }
Relocate_functions<64, false>::rela64(view, value, addend);
break;
case elfcpp::R_X86_64_GLOB_DAT:
case elfcpp::R_X86_64_JUMP_SLOT:
case elfcpp::R_X86_64_RELATIVE:
+ case elfcpp::R_X86_64_IRELATIVE:
// These are outstanding tls relocs, which are unexpected when linking
case elfcpp::R_X86_64_TPOFF64:
case elfcpp::R_X86_64_DTPMOD64:
projects / binutils-gdb.git / blobdiff