// sparc.cc -- sparc target support for gold.
-// Copyright 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
+// Copyright (C) 2008-2018 Free Software Foundation, Inc.
// Written by David S. Miller <davem@davemloft.net>.
// This file is part of gold.
Target_sparc()
: Sized_target<size, big_endian>(&sparc_info),
got_(NULL), plt_(NULL), rela_dyn_(NULL), rela_ifunc_(NULL),
- copy_relocs_(elfcpp::R_SPARC_COPY), dynbss_(NULL),
+ copy_relocs_(elfcpp::R_SPARC_COPY),
got_mod_index_offset_(-1U), tls_get_addr_sym_(NULL),
elf_machine_(sparc_info.machine_code), elf_flags_(0),
- elf_flags_set_(false)
+ elf_flags_set_(false), register_syms_()
{
}
+ // Make a new symbol table entry.
+ Sized_symbol<size>*
+ make_symbol(const char*, elfcpp::STT, Object*, unsigned int, uint64_t);
+
// Process the relocations to determine unreferenced sections for
// garbage collection.
void
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<size, big_endian>* 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<size, big_endian>*,
Output_section* output_section,
typename elfcpp::Elf_types<size>::Elf_Off
offset_in_output_section,
- const Relocatable_relocs*,
unsigned char* view,
typename elfcpp::Elf_types<size>::Elf_Addr view_address,
section_size_type view_size,
// Return whether SYM is defined by the ABI.
bool
do_is_defined_by_abi(const Symbol* sym) const
- {
- // XXX Really need to support this better...
- if (sym->type() == elfcpp::STT_SPARC_REGISTER)
- return 1;
-
- return strcmp(sym->name(), "___tls_get_addr") == 0;
- }
+ { return strcmp(sym->name(), "___tls_get_addr") == 0; }
// Return the PLT address to use for a global symbol.
uint64_t
const elfcpp::Ehdr<size, big_endian>& ehdr);
void
- do_adjust_elf_header(unsigned char* view, int len) const;
+ do_adjust_elf_header(unsigned char* view, int len);
private:
// Do a relocation. Return false if the caller should not issue
// any warnings about this relocation.
inline bool
- relocate(const Relocate_info<size, big_endian>*, Target_sparc*,
- Output_section*, size_t relnum,
- const elfcpp::Rela<size, big_endian>&,
- unsigned int r_type, const Sized_symbol<size>*,
- const Symbol_value<size>*,
- unsigned char*,
- typename elfcpp::Elf_types<size>::Elf_Addr,
+ relocate(const Relocate_info<size, big_endian>*, unsigned int,
+ Target_sparc*, Output_section*, size_t, const unsigned char*,
+ const Sized_symbol<size>*, const Symbol_value<size>*,
+ unsigned char*, typename elfcpp::Elf_types<size>::Elf_Addr,
section_size_type);
private:
unsigned char *reloc_adjust_addr_;
};
- // A class which returns the size required for a relocation type,
- // used while scanning relocs during a relocatable link.
- class Relocatable_size_for_reloc
- {
- public:
- unsigned int
- get_size_for_reloc(unsigned int, Relobj*);
- };
-
// Get the GOT section, creating it if necessary.
Output_data_got<size, big_endian>*
got_section(Symbol_table*, Layout*);
unsigned int shndx, Output_section* output_section,
Symbol* sym, const elfcpp::Rela<size, big_endian>& reloc)
{
+ unsigned int r_type = elfcpp::elf_r_type<size>(reloc.get_r_info());
this->copy_relocs_.copy_reloc(symtab, layout,
symtab->get_sized_symbol<size>(sym),
object, shndx, output_section,
- reloc, this->rela_dyn_section(layout));
+ r_type, reloc.get_r_offset(),
+ reloc.get_r_addend(),
+ this->rela_dyn_section(layout));
}
// Information about this specific target which we pass to the
GOT_TYPE_TLS_PAIR = 2, // GOT entry for TLS module/offset pair
};
+ struct Register_symbol
+ {
+ Register_symbol()
+ : name(NULL), shndx(0), obj(NULL)
+ { }
+ const char* name;
+ unsigned int shndx;
+ Object* obj;
+ };
+
// The GOT section.
Output_data_got<size, big_endian>* got_;
// The PLT section.
Reloc_section* rela_ifunc_;
// Relocs saved to avoid a COPY reloc.
Copy_relocs<elfcpp::SHT_RELA, size, big_endian> copy_relocs_;
- // Space for variables copied with a COPY reloc.
- Output_data_space* dynbss_;
// Offset of the GOT entry for the TLS module index;
unsigned int got_mod_index_offset_;
// Cached pointer to __tls_get_addr symbol
elfcpp::Elf_Word elf_flags_;
// Whether elf_flags_ has been set for the first time yet
bool elf_flags_set_;
+ // STT_SPARC_REGISTER symbols (%g2, %g3, %g6, %g7).
+ Register_symbol register_syms_[4];
};
template<>
0, // small_common_section_flags
0, // large_common_section_flags
NULL, // attributes_section
- NULL // attributes_vendor
+ NULL, // attributes_vendor
+ "_start", // entry_symbol_name
+ 32, // hash_entry_size
+ elfcpp::SHT_PROGBITS, // unwind_section_type
};
template<>
64, // size
true, // is_big_endian
elfcpp::EM_SPARCV9, // machine_code
- false, // has_make_symbol
+ true, // has_make_symbol
false, // has_resolve
false, // has_code_fill
true, // is_default_stack_executable
0, // small_common_section_flags
0, // large_common_section_flags
NULL, // attributes_section
- NULL // attributes_vendor
+ NULL, // attributes_vendor
+ "_start", // entry_symbol_name
+ 32, // hash_entry_size
+ elfcpp::SHT_PROGBITS, // unwind_section_type
};
// We have to take care here, even when operating in little-endian
// R_SPARC_GOTDATA_OP_HIX22: @gdopoff(Symbol + Addend) >> 10
static inline void
gdop_hix22(unsigned char* view,
- typename elfcpp::Elf_types<size>::Elf_Addr value,
- typename elfcpp::Elf_types<size>::Elf_Addr addend)
+ typename elfcpp::Elf_types<size>::Elf_Addr value)
{
typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
Valtype* wv = reinterpret_cast<Valtype*>(view);
Valtype val = elfcpp::Swap<32, true>::readval(wv);
- int32_t reloc = static_cast<int32_t>(value + addend);
+ int32_t reloc = static_cast<int32_t>(value);
val &= ~0x3fffff;
// R_SPARC_GOTDATA_OP_LOX10: (@gdopoff(Symbol + Addend) & 0x3ff) | 0x1c00
static inline void
gdop_lox10(unsigned char* view,
- typename elfcpp::Elf_types<size>::Elf_Addr value,
- typename elfcpp::Elf_types<size>::Elf_Addr addend)
+ typename elfcpp::Elf_types<size>::Elf_Addr value)
{
typedef typename elfcpp::Swap<32, true>::Valtype Valtype;
Valtype* wv = reinterpret_cast<Valtype*>(view);
Valtype val = elfcpp::Swap<32, true>::readval(wv);
- int32_t reloc = static_cast<int32_t>(value + addend);
+ int32_t reloc = static_cast<int32_t>(value);
if (reloc < 0)
reloc = (reloc & 0x3ff) | 0x1c00;
case elfcpp::R_SPARC_RELATIVE:
case elfcpp::R_SPARC_IRELATIVE:
case elfcpp::R_SPARC_COPY:
+ case elfcpp::R_SPARC_32:
case elfcpp::R_SPARC_64:
case elfcpp::R_SPARC_GLOB_DAT:
case elfcpp::R_SPARC_JMP_SLOT:
// apply the link-time value, so we flag the location with
// an R_SPARC_RELATIVE relocation so the dynamic loader can
// relocate it easily.
- if (parameters->options().output_is_position_independent())
+ if (parameters->options().output_is_position_independent()
+ && ((size == 64 && r_type == elfcpp::R_SPARC_64)
+ || (size == 32 && r_type == elfcpp::R_SPARC_32)))
{
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
unsigned int r_sym = elfcpp::elf_r_sym<size>(reloc.get_r_info());
output_section, data_shndx,
reloc.get_r_offset(),
reloc.get_r_addend(), is_ifunc);
+ break;
}
- break;
+ // Fall through.
case elfcpp::R_SPARC_HIX22:
case elfcpp::R_SPARC_LOX10:
// Make a dynamic relocation if necessary.
if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
{
- if (gsym->may_need_copy_reloc())
+ if (parameters->options().output_is_executable()
+ && gsym->may_need_copy_reloc())
{
target->copy_reloc(symtab, layout, object,
data_shndx, output_section, gsym,
break;
}
- if (gsym->may_need_copy_reloc())
+ if (!parameters->options().output_is_position_independent()
+ && gsym->may_need_copy_reloc())
{
target->copy_reloc(symtab, layout, object,
data_shndx, output_section, gsym, reloc);
reloc.get_r_offset(),
reloc.get_r_addend());
}
- else if ((r_type == elfcpp::R_SPARC_32
- || r_type == elfcpp::R_SPARC_64)
+ else if (((size == 64 && r_type == elfcpp::R_SPARC_64)
+ || (size == 32 && r_type == elfcpp::R_SPARC_32))
&& gsym->can_use_relative_reloc(false))
{
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
// and code transform the GOT load into an addition.
break;
}
+ // Fall through.
case elfcpp::R_SPARC_GOT10:
case elfcpp::R_SPARC_GOT13:
case elfcpp::R_SPARC_GOT22:
}
}
+// Make a new symbol table entry.
+// STT_SPARC_REGISTER symbols require special handling,
+// so we intercept these symbols and keep track of them separately.
+// We will resolve register symbols here and output them at symbol
+// finalization time.
+
+template<int size, bool big_endian>
+Sized_symbol<size>*
+Target_sparc<size, big_endian>::make_symbol(const char* name,
+ elfcpp::STT type,
+ Object* object,
+ unsigned int shndx,
+ uint64_t value)
+{
+ // REGISTER symbols are used only on SPARC-64.
+ if (size == 64 && type == elfcpp::STT_SPARC_REGISTER)
+ {
+ // Ignore REGISTER symbols in dynamic objects.
+ if (object->is_dynamic())
+ return NULL;
+ // Only registers 2, 3, 6, and 7 can be declared global.
+ int reg = value;
+ switch (reg)
+ {
+ case 2: case 3:
+ reg -= 2;
+ break;
+ case 6: case 7:
+ reg -= 4;
+ break;
+ default:
+ gold_error(_("%s: only registers %%g[2367] can be declared "
+ "using STT_REGISTER"),
+ object->name().c_str());
+ return NULL;
+ }
+ Register_symbol& rsym = this->register_syms_[reg];
+ if (rsym.name == NULL)
+ {
+ rsym.name = name;
+ rsym.shndx = shndx;
+ rsym.obj = object;
+ }
+ else
+ {
+ if (strcmp(rsym.name, name) != 0)
+ {
+ gold_error(_("%s: register %%g%d declared as '%s'; "
+ "previously declared as '%s' in %s"),
+ object->name().c_str(),
+ static_cast<int>(value),
+ *name ? name : "#scratch",
+ *rsym.name ? rsym.name : "#scratch",
+ rsym.obj->name().c_str());
+ return NULL;
+ }
+ }
+ return NULL;
+ }
+ return new Sized_symbol<size>();
+}
+
// Process relocations for gc.
template<int size, bool big_endian>
{
typedef Target_sparc<size, big_endian> Sparc;
typedef typename Target_sparc<size, big_endian>::Scan Scan;
+ typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
+ Classify_reloc;
- gold::gc_process_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan,
- typename Target_sparc::Relocatable_size_for_reloc>(
+ gold::gc_process_relocs<size, big_endian, Sparc, Scan, Classify_reloc>(
symtab,
layout,
this,
const unsigned char* plocal_symbols)
{
typedef Target_sparc<size, big_endian> Sparc;
- typedef typename Target_sparc<size, big_endian>::Scan Scan;
+ typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
+ Classify_reloc;
if (sh_type == elfcpp::SHT_REL)
{
return;
}
- gold::scan_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>(
+ gold::scan_relocs<size, big_endian, Sparc, Scan, Classify_reloc>(
symtab,
layout,
this,
symtab->define_symbols(layout, 2, syms,
layout->script_options()->saw_sections_clause());
}
+
+ for (int reg = 0; reg < 4; ++reg)
+ {
+ Register_symbol& rsym = this->register_syms_[reg];
+ if (rsym.name != NULL)
+ {
+ int value = reg < 3 ? reg + 2 : reg + 4;
+ Sized_symbol<size>* sym = new Sized_symbol<size>();
+ if (rsym.shndx == elfcpp::SHN_UNDEF)
+ sym->init_undefined(rsym.name, NULL, value,
+ elfcpp::STT_SPARC_REGISTER, elfcpp::STB_GLOBAL,
+ elfcpp::STV_DEFAULT, 0);
+ else
+ sym->init_constant(rsym.name, NULL, value, 0,
+ elfcpp::STT_SPARC_REGISTER, elfcpp::STB_GLOBAL,
+ elfcpp::STV_DEFAULT, 0, false);
+ symtab->add_target_global_symbol(sym);
+ layout->add_target_specific_dynamic_tag(elfcpp::DT_SPARC_REGISTER,
+ value);
+ }
+ }
}
// Perform a relocation.
inline bool
Target_sparc<size, big_endian>::Relocate::relocate(
const Relocate_info<size, big_endian>* relinfo,
+ unsigned int,
Target_sparc* target,
Output_section*,
size_t relnum,
- const elfcpp::Rela<size, big_endian>& rela,
- unsigned int r_type,
+ const unsigned char* preloc,
const Sized_symbol<size>* gsym,
const Symbol_value<size>* psymval,
unsigned char* view,
typename elfcpp::Elf_types<size>::Elf_Addr address,
section_size_type view_size)
{
+ const elfcpp::Rela<size, big_endian> rela(preloc);
+ unsigned int r_type = elfcpp::elf_r_type<size>(rela.get_r_info());
bool orig_is_ifunc = psymval->is_ifunc_symbol();
r_type &= 0xff;
&& !gsym->is_preemptible()
&& !orig_is_ifunc))
{
- got_offset = psymval->value(object, 0) - target->got_address();
+ got_offset = psymval->value(object, addend) - target->got_address();
gdop_valid = true;
break;
}
+ // Fall through.
case elfcpp::R_SPARC_GOT10:
case elfcpp::R_SPARC_GOT13:
case elfcpp::R_SPARC_GOT22:
Reloc::lo10(view, object, psymval, addend);
break;
+ case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
+ if (gdop_valid)
+ {
+ Reloc::gdop_lox10(view, got_offset);
+ break;
+ }
+ // Fall through.
case elfcpp::R_SPARC_GOT10:
Reloc::lo10(view, got_offset, addend);
break;
}
break;
- case elfcpp::R_SPARC_GOTDATA_OP_LOX10:
- if (gdop_valid)
- {
- Reloc::gdop_lox10(view, got_offset, addend);
- break;
- }
- /* Fall through. */
case elfcpp::R_SPARC_GOT13:
Reloc::rela32_13(view, got_offset, addend);
break;
case elfcpp::R_SPARC_GOTDATA_OP_HIX22:
if (gdop_valid)
{
- Reloc::gdop_hix22(view, got_offset, addend);
+ Reloc::gdop_hix22(view, got_offset);
break;
}
- /* Fall through. */
+ // Fall through.
case elfcpp::R_SPARC_GOT22:
Reloc::hi22(view, got_offset, addend);
break;
const bool is_final =
(gsym == NULL
- ? !parameters->options().output_is_position_independent()
+ ? !parameters->options().shared()
: gsym->final_value_is_known());
const tls::Tls_optimization optimized_type
= optimize_tls_reloc(is_final, r_type);
if (op3 != 0x3d)
{
// First check RS1
- reg = (delay_insn >> 14) & 0x15;
+ reg = (delay_insn >> 14) & 0x1f;
if (reg == 15)
return;
{
typedef Target_sparc<size, big_endian> Sparc;
typedef typename Target_sparc<size, big_endian>::Relocate Sparc_relocate;
+ typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
+ Classify_reloc;
gold_assert(sh_type == elfcpp::SHT_RELA);
- gold::relocate_section<size, big_endian, Sparc, elfcpp::SHT_RELA,
- Sparc_relocate, gold::Default_comdat_behavior>(
+ gold::relocate_section<size, big_endian, Sparc, Sparc_relocate,
+ gold::Default_comdat_behavior, Classify_reloc>(
relinfo,
this,
prelocs,
reloc_symbol_changes);
}
-// Return the size of a relocation while scanning during a relocatable
-// link.
-
-template<int size, bool big_endian>
-unsigned int
-Target_sparc<size, big_endian>::Relocatable_size_for_reloc::get_size_for_reloc(
- unsigned int,
- Relobj*)
-{
- // We are always SHT_RELA, so we should never get here.
- gold_unreachable();
- return 0;
-}
-
// Scan the relocs during a relocatable link.
template<int size, bool big_endian>
const unsigned char* plocal_symbols,
Relocatable_relocs* rr)
{
- gold_assert(sh_type == elfcpp::SHT_RELA);
+ typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
+ Classify_reloc;
+ typedef gold::Default_scan_relocatable_relocs<Classify_reloc>
+ Scan_relocatable_relocs;
- typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_RELA,
- Relocatable_size_for_reloc> Scan_relocatable_relocs;
+ gold_assert(sh_type == elfcpp::SHT_RELA);
- gold::scan_relocatable_relocs<size, big_endian, elfcpp::SHT_RELA,
- Scan_relocatable_relocs>(
+ gold::scan_relocatable_relocs<size, big_endian, Scan_relocatable_relocs>(
symtab,
layout,
object,
rr);
}
+// Scan the relocs for --emit-relocs.
+
+template<int size, bool big_endian>
+void
+Target_sparc<size, big_endian>::emit_relocs_scan(
+ Symbol_table* symtab,
+ Layout* layout,
+ Sized_relobj_file<size, big_endian>* 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)
+{
+ typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
+ Classify_reloc;
+ typedef gold::Default_emit_relocs_strategy<Classify_reloc>
+ Emit_relocs_strategy;
+
+ gold_assert(sh_type == elfcpp::SHT_RELA);
+
+ gold::scan_relocatable_relocs<size, big_endian, Emit_relocs_strategy>(
+ symtab,
+ layout,
+ object,
+ data_shndx,
+ prelocs,
+ reloc_count,
+ output_section,
+ needs_special_offset_handling,
+ local_symbol_count,
+ plocal_syms,
+ rr);
+}
+
// Emit relocations for a section.
template<int size, bool big_endian>
size_t reloc_count,
Output_section* output_section,
typename elfcpp::Elf_types<size>::Elf_Off offset_in_output_section,
- const Relocatable_relocs* rr,
unsigned char* view,
typename elfcpp::Elf_types<size>::Elf_Addr view_address,
section_size_type view_size,
unsigned char* reloc_view,
section_size_type reloc_view_size)
{
+ typedef gold::Default_classify_reloc<elfcpp::SHT_RELA, size, big_endian>
+ Classify_reloc;
+
gold_assert(sh_type == elfcpp::SHT_RELA);
- gold::relocate_relocs<size, big_endian, elfcpp::SHT_RELA>(
+ gold::relocate_relocs<size, big_endian, Classify_reloc>(
relinfo,
prelocs,
reloc_count,
output_section,
offset_in_output_section,
- rr,
view,
view_address,
view_size,
void
Target_sparc<size, big_endian>::do_adjust_elf_header(
unsigned char* view,
- int len) const
+ int len)
{
elfcpp::Ehdr_write<size, big_endian> oehdr(view);