+2016-03-03 Cary Coutant <ccoutant@gmail.com>
+
+ PR gold/19019
+ * layout.h (Layout::add_target_specific_dynamic_tag): New function.
+ * layout.cc (Layout::add_target_specific_dynamic_tag): New function.
+ * mips.cc (Target_mips::make_symbol): Adjust function signature.
+ * sparc.cc (Target_sparc::Target_sparc): Initialize register_syms_.
+ (Target_sparc::do_is_defined_by_abi): Remove test for
+ STT_SPARC_REGISTER.
+ (Target_sparc::Register_symbol): New struct type.
+ (Target_sparc::register_syms_): New data member.
+ (Target_sparc<64, true>::sparc_info): Set has_make_symbol to true.
+ (Target_sparc::make_symbol): New function.
+ (Target_sparc::do_finalize_sections): Add register symbols and new
+ dynamic table entries.
+ * symtab.h (Sized_symbol::init_undefined): Add value parameter.
+ (Symbol_table::add_target_global_symbol): New function.
+ (Symbol_table::target_symbols_): New data member.
+ * symtab.cc (Sized_symbol::init_undefined): Add value parameter.
+ (Symbol_table::Symbol_table): Initialize target_symbols_.
+ (Symbol_table::add_from_object): Pass additional parameters to
+ Target::make_symbol.
+ (Symbol_table::define_special_symbol): Likewise.
+ (Symbol_table::add_undefined_symbol_from_command_line): Pass 0 for
+ undefined symbol value.
+ (Symbol_table::set_dynsym_indexes): Process target-specific symbols.
+ (Symbol_table::sized_finalize): Likewise.
+ (Symbol_table::sized_write_globals): Likewise.
+ * target.h (Sized_target::make_symbol): Add name, st_type, object,
+ st_shndx, and value parameters.
+
2015-03-03 Rafael Ávila de Espíndola <rafael.espindola@gmail.com>
* plugin.cc (do_should_include_member): Ignore LDPK_UNDEF and
}
}
+void
+Layout::add_target_specific_dynamic_tag(elfcpp::DT tag, unsigned int val)
+{
+ Output_data_dynamic* odyn = this->dynamic_data_;
+ if (odyn == NULL)
+ return;
+ odyn->add_constant(tag, val);
+}
+
// Finish the .dynamic section and PT_DYNAMIC segment.
void
const Output_data_reloc_generic* dyn_rel,
bool add_debug, bool dynrel_includes_plt);
+ // Add a target-specific dynamic tag with constant value.
+ void
+ add_target_specific_dynamic_tag(elfcpp::DT tag, unsigned int val);
+
// Compute and write out the build ID if needed.
void
write_build_id(Output_file*, unsigned char*, size_t) const;
// Make a new symbol table entry for the Mips target.
Sized_symbol<size>*
- make_symbol() const
+ make_symbol(const char*, elfcpp::STT, Object*, unsigned int, uint64_t)
{ return new Mips_symbol<size>(); }
// Process the relocations to determine unreferenced sections for
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
// 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
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.
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<>
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
}
}
+// 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>
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.
template<int size>
void
Sized_symbol<size>::init_undefined(const char* name, const char* version,
- elfcpp::STT type, elfcpp::STB binding,
- elfcpp::STV visibility, unsigned char nonvis)
+ Value_type value, elfcpp::STT type,
+ elfcpp::STB binding, elfcpp::STV visibility,
+ unsigned char nonvis)
{
this->init_base_undefined(name, version, type, binding, visibility, nonvis);
- this->value_ = 0;
+ this->value_ = value;
this->symsize_ = 0;
}
: saw_undefined_(0), offset_(0), table_(count), namepool_(),
forwarders_(), commons_(), tls_commons_(), small_commons_(),
large_commons_(), forced_locals_(), warnings_(),
- version_script_(version_script), gc_(NULL), icf_(NULL)
+ version_script_(version_script), gc_(NULL), icf_(NULL),
+ target_symbols_()
{
namepool_.reserve(count);
}
ret = new Sized_symbol<size>();
else
{
- ret = target->make_symbol();
+ ret = target->make_symbol(name, sym.get_st_type(), object,
+ st_shndx, sym.get_st_value());
if (ret == NULL)
{
// This means that we don't want a symbol table
{
Sized_target<size, big_endian>* sized_target =
parameters->sized_target<size, big_endian>();
- sym = sized_target->make_symbol();
+ sym = sized_target->make_symbol(*pname, elfcpp::STT_NOTYPE,
+ NULL, elfcpp::SHN_UNDEF, 0);
if (sym == NULL)
return NULL;
}
gold_assert(oldsym == NULL);
- sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
+ sym->init_undefined(name, version, 0, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
elfcpp::STV_DEFAULT, 0);
++this->saw_undefined_;
}
// symbols.
index = versions->finalize(this, index, syms);
+ // Process target-specific symbols.
+ for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin();
+ p != this->target_symbols_.end();
+ ++p)
+ {
+ (*p)->set_dynsym_index(index);
+ ++index;
+ syms->push_back(*p);
+ dynpool->add((*p)->name(), false, NULL);
+ }
+
return index;
}
this->add_to_final_symtab<size>(sym, pool, &index, &off);
}
+ // Now do target-specific symbols.
+ for (std::vector<Symbol*>::iterator p = this->target_symbols_.begin();
+ p != this->target_symbols_.end();
+ ++p)
+ {
+ this->add_to_final_symtab<size>(*p, pool, &index, &off);
+ }
+
this->output_count_ = index - orig_index;
return off;
}
}
+ // Write the target-specific symbols.
+ for (std::vector<Symbol*>::const_iterator p = this->target_symbols_.begin();
+ p != this->target_symbols_.end();
+ ++p)
+ {
+ Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(*p);
+
+ unsigned int sym_index = sym->symtab_index();
+ unsigned int dynsym_index;
+ if (dynamic_view == NULL)
+ dynsym_index = -1U;
+ else
+ dynsym_index = sym->dynsym_index();
+
+ unsigned int shndx;
+ switch (sym->source())
+ {
+ case Symbol::IS_CONSTANT:
+ shndx = elfcpp::SHN_ABS;
+ break;
+ case Symbol::IS_UNDEFINED:
+ shndx = elfcpp::SHN_UNDEF;
+ break;
+ default:
+ gold_unreachable();
+ }
+
+ if (sym_index != -1U)
+ {
+ sym_index -= first_global_index;
+ gold_assert(sym_index < output_count);
+ unsigned char* ps = psyms + (sym_index * sym_size);
+ this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx,
+ sym->binding(), sympool,
+ ps);
+ }
+
+ if (dynsym_index != -1U)
+ {
+ dynsym_index -= first_dynamic_global_index;
+ gold_assert(dynsym_index < dynamic_count);
+ unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
+ this->sized_write_symbol<size, big_endian>(sym, sym->value(), shndx,
+ sym->binding(), dynpool,
+ pd);
+ }
+ }
+
of->write_output_view(this->offset_, oview_size, psyms);
if (dynamic_view != NULL)
of->write_output_view(this->dynamic_offset_, dynamic_size, dynamic_view);
// Initialize fields for an undefined symbol.
void
- init_undefined(const char* name, const char* version, elfcpp::STT,
- elfcpp::STB, elfcpp::STV, unsigned char nonvis);
+ init_undefined(const char* name, const char* version, Value_type value,
+ elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis);
// Override existing symbol.
template<bool big_endian>
define_symbols(const Layout*, int count, const Define_symbol_in_segment*,
bool only_if_ref);
+ // Add a target-specific global symbol.
+ // (Used by SPARC backend to add STT_SPARC_REGISTER symbols.)
+ void
+ add_target_global_symbol(Symbol* sym)
+ { this->target_symbols_.push_back(sym); }
+
// Define SYM using a COPY reloc. POSD is the Output_data where the
// symbol should be defined--typically a .dyn.bss section. VALUE is
// the offset within POSD.
const Version_script_info& version_script_;
Garbage_collection* gc_;
Icf* icf_;
+ // Target-specific symbols, if any.
+ std::vector<Symbol*> target_symbols_;
};
// We inline get_sized_symbol for efficiency.
// symbol table. This will only be called if has_make_symbol()
// returns true.
virtual Sized_symbol<size>*
- make_symbol() const
+ make_symbol(const char*, elfcpp::STT, Object*, unsigned int, uint64_t)
{ gold_unreachable(); }
// Resolve a symbol for the target. This should be overridden by a
projects / binutils-gdb.git / commitdiff