{

public:

Output_data_got_plt_i386(Layout* layout)

: Output_section_data_build(4),

layout_(layout)

{ }

protected:

// Write out the PLT data.

void

do_write(Output_file*);

// Write to a map file.

void

do_print_to_mapfile(Mapfile* mapfile) const

{ mapfile->print_output_data(this, "** GOT PLT"); }

private:

// A pointer to the Layout class, so that we can find the .dynamic

// section when we write out the GOT PLT section.

Layout* layout_;

{

public:

typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;

Output_data_plt_i386(Layout*, uint64_t addralign,

Output_data_got_plt_i386*, Output_data_space*);

// Add an entry to the PLT.

void

add_entry(Symbol_table*, Layout*, Symbol* gsym);

// Add an entry to the PLT for a local STT_GNU_IFUNC symbol.

unsigned int

add_local_ifunc_entry(Symbol_table*, Layout*,

Sized_relobj_file<32, false>* relobj,

unsigned int local_sym_index);

// Return the .rel.plt section data.

Reloc_section*

rel_plt() const

{ return this->rel_; }

// Return where the TLS_DESC relocations should go.

Reloc_section*

rel_tls_desc(Layout*);

// Return where the IRELATIVE relocations should go.

Reloc_section*

rel_irelative(Symbol_table*, Layout*);

// Return whether we created a section for IRELATIVE relocations.

bool

has_irelative_section() const

{ return this->irelative_rel_ != NULL; }

// Return the number of PLT entries.

unsigned int

entry_count() const

{ return this->count_ + this->irelative_count_; }

// Return the offset of the first non-reserved PLT entry.

unsigned int

first_plt_entry_offset()

{ return this->get_plt_entry_size(); }

// Return the size of a PLT entry.

unsigned int

get_plt_entry_size() const

{ return this->do_get_plt_entry_size(); }

// Return the PLT address to use for a global symbol.

uint64_t

address_for_global(const Symbol*);

// Return the PLT address to use for a local symbol.

uint64_t

address_for_local(const Relobj*, unsigned int symndx);

// Add .eh_frame information for the PLT.

void

add_eh_frame(Layout* layout)

{ this->do_add_eh_frame(layout); }

protected:

// Fill the first PLT entry, given the pointer to the PLT section data

// and the runtime address of the GOT.

void

fill_first_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr got_address)

{ this->do_fill_first_plt_entry(pov, got_address); }

// Fill a normal PLT entry, given the pointer to the entry's data in the

// section, the runtime address of the GOT, the offset into the GOT of

// the corresponding slot, the offset into the relocation section of the

// corresponding reloc, and the offset of this entry within the whole

// PLT. Return the offset from this PLT entry's runtime address that

// should be used to compute the initial value of the GOT slot.

unsigned int

fill_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr got_address,

unsigned int got_offset,

unsigned int plt_offset,

unsigned int plt_rel_offset)

{

return this->do_fill_plt_entry(pov, got_address, got_offset,

plt_offset, plt_rel_offset);

}

virtual unsigned int

do_get_plt_entry_size() const = 0;

virtual void

do_fill_first_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr got_address) = 0;

virtual unsigned int

do_fill_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr got_address,

unsigned int got_offset,

unsigned int plt_offset,

unsigned int plt_rel_offset) = 0;

virtual void

do_add_eh_frame(Layout*) = 0;

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")); }

// The .eh_frame unwind information for the PLT.

// The CIE is common across variants of the PLT format.

static const int plt_eh_frame_cie_size = 16;

static const unsigned char plt_eh_frame_cie[plt_eh_frame_cie_size];

private:

// Set the final size.

void

set_final_data_size()

{

this->set_data_size((this->count_ + this->irelative_count_ + 1)

* this->get_plt_entry_size());

}

// Write out the PLT data.

void

do_write(Output_file*);

// We keep a list of global STT_GNU_IFUNC symbols, each with its

// offset in the GOT.

struct Global_ifunc

{

Symbol* sym;

unsigned int got_offset;

};

// We keep a list of local STT_GNU_IFUNC symbols, each with its

// offset in the GOT.

struct Local_ifunc

{

Sized_relobj_file<32, false>* object;

unsigned int local_sym_index;

unsigned int got_offset;

};

// The reloc section.

Reloc_section* rel_;

// The TLS_DESC relocations, if necessary. These must follow the

// regular PLT relocs.

Reloc_section* tls_desc_rel_;

// The IRELATIVE relocations, if necessary. These must follow the

// regular relocatoins and the TLS_DESC relocations.

Reloc_section* irelative_rel_;

// The .got.plt section.

Output_data_got_plt_i386* 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_386_IRELATIVE relocs. These follow

// the regular PLT entries.

unsigned int irelative_count_;

// Global STT_GNU_IFUNC symbols.

std::vector<Global_ifunc> global_ifuncs_;

// Local STT_GNU_IFUNC symbols.

std::vector<Local_ifunc> local_ifuncs_;

{

public:

Output_data_plt_i386_standard(Layout* layout,

Output_data_got_plt_i386* got_plt,

Output_data_space* got_irelative)

: Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative)

{ }

protected:

virtual unsigned int

do_get_plt_entry_size() const

{ return plt_entry_size; }

virtual void

do_add_eh_frame(Layout* layout)

{

layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size,

plt_eh_frame_fde, plt_eh_frame_fde_size);

}

// The size of an entry in the PLT.

static const int plt_entry_size = 16;

// The .eh_frame unwind information for the PLT.

static const int plt_eh_frame_fde_size = 32;

static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];

{

Output_data_plt_i386_exec(Layout* layout,

Output_data_got_plt_i386* got_plt,

Output_data_space* got_irelative)

: Output_data_plt_i386_standard(layout, got_plt, got_irelative)

{ }

protected:

virtual void

do_fill_first_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr got_address);

virtual unsigned int

do_fill_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr got_address,

unsigned int got_offset,

unsigned int plt_offset,

unsigned int plt_rel_offset);

private:

// The first entry in the PLT for an executable.

static const unsigned char first_plt_entry[plt_entry_size];

// Other entries in the PLT for an executable.

static const unsigned char plt_entry[plt_entry_size];

{

public:

Output_data_plt_i386_dyn(Layout* layout,

Output_data_got_plt_i386* got_plt,

Output_data_space* got_irelative)

: Output_data_plt_i386_standard(layout, got_plt, got_irelative)

{ }

protected:

virtual void

do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr);

virtual unsigned int

do_fill_plt_entry(unsigned char* pov,

elfcpp::Elf_types<32>::Elf_Addr,

unsigned int got_offset,

unsigned int plt_offset,

unsigned int plt_rel_offset);

private:

// The first entry in the PLT for a shared object.

static const unsigned char first_plt_entry[plt_entry_size];

// Other entries in the PLT for a shared object.

static const unsigned char plt_entry[plt_entry_size];

{

public:

typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;

Target_i386(const Target::Target_info* info = &i386_info)

: Sized_target<32, false>(info),

got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL),

got_tlsdesc_(NULL), global_offset_table_(NULL), rel_dyn_(NULL),

rel_irelative_(NULL), copy_relocs_(elfcpp::R_386_COPY),

got_mod_index_offset_(-1U), tls_base_symbol_defined_(false)

{ }

// Process the relocations to determine unreferenced sections for

// garbage collection.

void

gc_process_relocs(Symbol_table* symtab,

Layout* layout,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

unsigned int sh_type,

const unsigned char* prelocs,

size_t reloc_count,

Output_section* output_section,

bool needs_special_offset_handling,

size_t local_symbol_count,

const unsigned char* plocal_symbols);

// Scan the relocations to look for symbol adjustments.

void

scan_relocs(Symbol_table* symtab,

Layout* layout,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

unsigned int sh_type,

const unsigned char* prelocs,

size_t reloc_count,

Output_section* output_section,

bool needs_special_offset_handling,

size_t local_symbol_count,

const unsigned char* plocal_symbols);

// Finalize the sections.

void

do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);

// Return the value to use for a dynamic which requires special

// treatment.

uint64_t

do_dynsym_value(const Symbol*) const;

// Relocate a section.

void

relocate_section(const Relocate_info<32, false>*,

unsigned int sh_type,

const unsigned char* prelocs,

size_t reloc_count,

Output_section* output_section,

bool needs_special_offset_handling,

unsigned char* view,

elfcpp::Elf_types<32>::Elf_Addr view_address,

section_size_type view_size,

const Reloc_symbol_changes*);

// Scan the relocs during a relocatable link.

void

scan_relocatable_relocs(Symbol_table* symtab,

Layout* layout,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

unsigned int sh_type,

const unsigned char* prelocs,

size_t reloc_count,

Output_section* output_section,

bool needs_special_offset_handling,

size_t local_symbol_count,

const unsigned char* plocal_symbols,

Relocatable_relocs*);

// Scan the relocs for --emit-relocs.

void

emit_relocs_scan(Symbol_table* symtab,

Layout* layout,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

unsigned int sh_type,

const unsigned char* prelocs,

size_t reloc_count,

Output_section* output_section,

bool needs_special_offset_handling,

size_t local_symbol_count,

const unsigned char* plocal_syms,

Relocatable_relocs* rr);

// Emit relocations for a section.

void

relocate_relocs(const Relocate_info<32, false>*,

unsigned int sh_type,

const unsigned char* prelocs,

size_t reloc_count,

Output_section* output_section,

elfcpp::Elf_types<32>::Elf_Off offset_in_output_section,

unsigned char* view,

elfcpp::Elf_types<32>::Elf_Addr view_address,

section_size_type view_size,

unsigned char* reloc_view,

section_size_type reloc_view_size);

// Return a string used to fill a code section with nops.

std::string

do_code_fill(section_size_type length) const;

// Return whether SYM is defined by the ABI.

bool

do_is_defined_by_abi(const Symbol* sym) const

{ return strcmp(sym->name(), "___tls_get_addr") == 0; }

// Return whether a symbol name implies a local label. The UnixWare

// 2.1 cc generates temporary symbols that start with .X, so we

// recognize them here. FIXME: do other SVR4 compilers also use .X?.

// If so, we should move the .X recognition into

// Target::do_is_local_label_name.

bool

do_is_local_label_name(const char* name) const

{

if (name[0] == '.' && name[1] == 'X')

return true;

return Target::do_is_local_label_name(name);

}

// Return the PLT address to use for a global symbol.

uint64_t

do_plt_address_for_global(const Symbol* gsym) const

{ return this->plt_section()->address_for_global(gsym); }

uint64_t

do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const

{ return this->plt_section()->address_for_local(relobj, symndx); }

// We can tell whether we take the address of a function.

inline bool

do_can_check_for_function_pointers() const

{ return true; }

// Return the base for a DW_EH_PE_datarel encoding.

uint64_t

do_ehframe_datarel_base() const;

// Return whether SYM is call to a non-split function.

bool

do_is_call_to_non_split(const Symbol* sym, const unsigned char*,

const unsigned char*, section_size_type) const;

// Adjust -fsplit-stack code which calls non-split-stack code.

void

do_calls_non_split(Relobj* object, unsigned int shndx,

section_offset_type fnoffset, section_size_type fnsize,

const unsigned char* prelocs, size_t reloc_count,

unsigned char* view, section_size_type view_size,

std::string* from, std::string* to) const;

// Return the size of the GOT section.

section_size_type

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() / 4;

}

// 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;

protected:

// Instantiate the plt_ member.

// This chooses the right PLT flavor for an executable or a shared object.

Output_data_plt_i386*

make_data_plt(Layout* layout,

Output_data_got_plt_i386* got_plt,

Output_data_space* got_irelative,

bool dyn)

{ return this->do_make_data_plt(layout, got_plt, got_irelative, dyn); }

virtual Output_data_plt_i386*

do_make_data_plt(Layout* layout,

Output_data_got_plt_i386* got_plt,

Output_data_space* got_irelative,

bool dyn)

{

if (dyn)

return new Output_data_plt_i386_dyn(layout, got_plt, got_irelative);

else

return new Output_data_plt_i386_exec(layout, got_plt, got_irelative);

}

private:

// The class which scans relocations.

struct Scan

{

static inline int

get_reference_flags(unsigned int r_type);

inline void

local(Symbol_table* symtab, Layout* layout, Target_i386* target,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

Output_section* output_section,

const elfcpp::Rel<32, false>& reloc, unsigned int r_type,

const elfcpp::Sym<32, false>& lsym,

bool is_discarded);

inline void

global(Symbol_table* symtab, Layout* layout, Target_i386* target,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

Output_section* output_section,

const elfcpp::Rel<32, false>& reloc, unsigned int r_type,

Symbol* gsym);

inline bool

local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,

Target_i386* target,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

Output_section* output_section,

const elfcpp::Rel<32, false>& reloc,

unsigned int r_type,

const elfcpp::Sym<32, false>& lsym);

inline bool

global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,

Target_i386* target,

Sized_relobj_file<32, false>* object,

unsigned int data_shndx,

Output_section* output_section,

const elfcpp::Rel<32, false>& reloc,

unsigned int r_type,

Symbol* gsym);

inline bool

possible_function_pointer_reloc(unsigned int r_type);

bool

reloc_needs_plt_for_ifunc(Sized_relobj_file<32, false>*,

unsigned int r_type);

static void

unsupported_reloc_local(Sized_relobj_file<32, false>*, unsigned int r_type);

static void

unsupported_reloc_global(Sized_relobj_file<32, false>*, unsigned int r_type,

Symbol*);

};

// The class which implements relocation.

class Relocate

{

public:

Relocate()

: skip_call_tls_get_addr_(false),

local_dynamic_type_(LOCAL_DYNAMIC_NONE)

{ }

~Relocate()

{

if (this->skip_call_tls_get_addr_)

{

// FIXME: This needs to specify the location somehow.

gold_error(_("missing expected TLS relocation"));

}

}

// Return whether the static relocation needs to be applied.

inline bool

should_apply_static_reloc(const Sized_symbol<32>* gsym,

unsigned int r_type,

bool is_32bit,

Output_section* output_section);

// Do a relocation. Return false if the caller should not issue

// any warnings about this relocation.

inline bool

relocate(const Relocate_info<32, false>*, unsigned int,

Target_i386*, Output_section*, size_t, const unsigned char*,

const Sized_symbol<32>*, const Symbol_value<32>*,

unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,

section_size_type);

private:

// Do a TLS relocation.

inline void

relocate_tls(const Relocate_info<32, false>*, Target_i386* target,

size_t relnum, const elfcpp::Rel<32, false>&,

unsigned int r_type, const Sized_symbol<32>*,

const Symbol_value<32>*,

unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,

section_size_type);

// Do a TLS General-Dynamic to Initial-Exec transition.

inline void

tls_gd_to_ie(const Relocate_info<32, false>*, size_t relnum,

const elfcpp::Rel<32, false>&, unsigned int r_type,

elfcpp::Elf_types<32>::Elf_Addr value,

unsigned char* view,

section_size_type view_size);

// Do a TLS General-Dynamic to Local-Exec transition.

inline void

tls_gd_to_le(const Relocate_info<32, false>*, size_t relnum,

Output_segment* tls_segment,

const elfcpp::Rel<32, false>&, unsigned int r_type,

elfcpp::Elf_types<32>::Elf_Addr value,

unsigned char* view,

section_size_type view_size);

// Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Initial-Exec

// transition.

inline void

tls_desc_gd_to_ie(const Relocate_info<32, false>*, size_t relnum,

const elfcpp::Rel<32, false>&, unsigned int r_type,

elfcpp::Elf_types<32>::Elf_Addr value,

unsigned char* view,

section_size_type view_size);

// Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Local-Exec

// transition.

inline void

tls_desc_gd_to_le(const Relocate_info<32, false>*, size_t relnum,

Output_segment* tls_segment,

const elfcpp::Rel<32, false>&, unsigned int r_type,

elfcpp::Elf_types<32>::Elf_Addr value,

unsigned char* view,

section_size_type view_size);

// Do a TLS Local-Dynamic to Local-Exec transition.

inline void

tls_ld_to_le(const Relocate_info<32, false>*, size_t relnum,

Output_segment* tls_segment,

const elfcpp::Rel<32, false>&, unsigned int r_type,

elfcpp::Elf_types<32>::Elf_Addr value,

unsigned char* view,

section_size_type view_size);

// Do a TLS Initial-Exec to Local-Exec transition.

static inline void

tls_ie_to_le(const Relocate_info<32, false>*, size_t relnum,

Output_segment* tls_segment,

const elfcpp::Rel<32, false>&, unsigned int r_type,

elfcpp::Elf_types<32>::Elf_Addr value,

unsigned char* view,

section_size_type view_size);

// We need to keep track of which type of local dynamic relocation

// we have seen, so that we can optimize R_386_TLS_LDO_32 correctly.

enum Local_dynamic_type

{

LOCAL_DYNAMIC_NONE,

LOCAL_DYNAMIC_SUN,

LOCAL_DYNAMIC_GNU

};

// 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_;

// The type of local dynamic relocation we have seen in the section

// being relocated, if any.

Local_dynamic_type local_dynamic_type_;

};

// A class for inquiring about properties of a relocation,

// used while scanning relocs during a relocatable link and

// garbage collection.

class Classify_reloc :

public gold::Default_classify_reloc<elfcpp::SHT_REL, 32, false>

{

public:

typedef Reloc_types<elfcpp::SHT_REL, 32, false>::Reloc Reltype;

// Return the explicit addend of the relocation (return 0 for SHT_REL).

static elfcpp::Elf_types<32>::Elf_Swxword

get_r_addend(const Reltype*)

{ return 0; }

// Return the size of the addend of the relocation (only used for SHT_REL).

static unsigned int

get_size_for_reloc(unsigned int, Relobj*);

};

// Adjust TLS relocation type based on the options and whether this

// is a local symbol.

static tls::Tls_optimization

optimize_tls_reloc(bool is_final, int r_type);

// Check if relocation against this symbol is a candidate for

// conversion from

// mov foo@GOT(%reg), %reg

// to

// lea foo@GOTOFF(%reg), %reg.

static bool

can_convert_mov_to_lea(const Symbol* gsym)

{

gold_assert(gsym != NULL);

return (gsym->type() != elfcpp::STT_GNU_IFUNC

&& !gsym->is_undefined ()

&& !gsym->is_from_dynobj()

&& !gsym->is_preemptible()

&& (!parameters->options().shared()

|| (gsym->visibility() != elfcpp::STV_DEFAULT

&& gsym->visibility() != elfcpp::STV_PROTECTED)

|| parameters->options().Bsymbolic())

&& strcmp(gsym->name(), "_DYNAMIC") != 0);

}

// Get the GOT section, creating it if necessary.

Output_data_got<32, false>*

got_section(Symbol_table*, Layout*);

// Get the GOT PLT section.

Output_data_got_plt_i386*

got_plt_section() const

{

gold_assert(this->got_plt_ != NULL);

return this->got_plt_;

}

// Get the GOT section for TLSDESC entries.

Output_data_got<32, false>*

got_tlsdesc_section() const

{

gold_assert(this->got_tlsdesc_ != NULL);

return this->got_tlsdesc_;

}

// 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, 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*);

// Create a GOT entry for the TLS module index.

unsigned int

got_mod_index_entry(Symbol_table* symtab, Layout* layout,

Sized_relobj_file<32, false>* object);

// Get the PLT section.

Output_data_plt_i386*

plt_section() const

{

gold_assert(this->plt_ != NULL);

return this->plt_;

}

// Get the dynamic reloc section, creating it if necessary.

Reloc_section*

rel_dyn_section(Layout*);

// Get the section to use for TLS_DESC relocations.

Reloc_section*

rel_tls_desc_section(Layout*) const;

// Get the section to use for IRELATIVE relocations.

Reloc_section*

rel_irelative_section(Layout*);

// Add a potential copy relocation.

void

copy_reloc(Symbol_table* symtab, Layout* layout,

Sized_relobj_file<32, false>* object,

unsigned int shndx, Output_section* output_section,

Symbol* sym, const elfcpp::Rel<32, false>& reloc)

{

unsigned int r_type = elfcpp::elf_r_type<32>(reloc.get_r_info());

this->copy_relocs_.copy_reloc(symtab, layout,

symtab->get_sized_symbol<32>(sym),

object, shndx, output_section,

r_type, reloc.get_r_offset(), 0,

this->rel_dyn_section(layout));

}

// Information about this specific target which we pass to the

// general Target structure.

static const Target::Target_info i386_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

GOT_TYPE_TLS_NOFFSET = 1, // GOT entry for negative TLS offset

GOT_TYPE_TLS_OFFSET = 2, // GOT entry for positive TLS offset

GOT_TYPE_TLS_PAIR = 3, // GOT entry for TLS module/offset pair

GOT_TYPE_TLS_DESC = 4 // GOT entry for TLS_DESC pair

};

// The GOT section.

Output_data_got<32, false>* got_;

// The PLT section.

Output_data_plt_i386* plt_;

// The GOT PLT section.

Output_data_got_plt_i386* got_plt_;

// The GOT section for IRELATIVE relocations.

Output_data_space* got_irelative_;

// The GOT section for TLSDESC relocations.

Output_data_got<32, false>* got_tlsdesc_;

// The _GLOBAL_OFFSET_TABLE_ symbol.

Symbol* global_offset_table_;

// 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, false> copy_relocs_;

// Offset of the GOT entry for the TLS module index.

unsigned int got_mod_index_offset_;

// True if the _TLS_MODULE_BASE_ symbol has been defined.

bool tls_base_symbol_defined_;