// resolve.cc -- symbol resolution for gold
-// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
// VERSION. Update the VERSION_ field accordingly.
inline void
-Symbol::override_version(const char* aversion)
+Symbol::override_version(const char* version)
{
- if (aversion == NULL)
+ if (version == NULL)
{
// This is the case where this symbol is NAME/VERSION, and the
// version was not marked as hidden. That makes it the default
// override NAME/VERSION as well. They are already the same
// Symbol structure. Setting the VERSION_ field to NULL ensures
// that it will be output with the correct, empty, version.
- this->version_ = aversion;
+ this->version_ = version;
}
else
{
// overriding NAME. If VERSION_ONE and VERSION_TWO are
// different, then this can only happen when VERSION_ONE is NULL
// and VERSION_TWO is not hidden.
- gold_assert(this->version_ == aversion || this->version_ == NULL);
- this->version_ = aversion;
+ gold_assert(this->version_ == version || this->version_ == NULL);
+ this->version_ = version;
}
}
// is VISIBILITY. Updated the VISIBILITY_ field accordingly.
inline void
-Symbol::override_visibility(elfcpp::STV avisibility)
+Symbol::override_visibility(elfcpp::STV visibility)
{
// The rule for combining visibility is that we always choose the
// most constrained visibility. In order of increasing constraint,
// visibility goes PROTECTED, HIDDEN, INTERNAL. This is the reverse
// of the numeric values, so the effect is that we always want the
// smallest non-zero value.
- if (avisibility != elfcpp::STV_DEFAULT)
+ if (visibility != elfcpp::STV_DEFAULT)
{
if (this->visibility_ == elfcpp::STV_DEFAULT)
- this->visibility_ = avisibility;
- else if (this->visibility_ > avisibility)
- this->visibility_ = avisibility;
+ this->visibility_ = visibility;
+ else if (this->visibility_ > visibility)
+ this->visibility_ = visibility;
}
}
void
Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
unsigned int st_shndx, bool is_ordinary,
- Object* aobject, const char* aversion)
+ Object* object, const char* version)
{
gold_assert(this->source_ == FROM_OBJECT);
- this->u_.from_object.object = aobject;
- this->override_version(aversion);
+ this->u_.from_object.object = object;
+ this->override_version(version);
this->u_.from_object.shndx = st_shndx;
this->is_ordinary_shndx_ = is_ordinary;
this->type_ = sym.get_st_type();
this->binding_ = sym.get_st_bind();
this->override_visibility(sym.get_st_visibility());
this->nonvis_ = sym.get_st_nonvis();
- if (aobject->is_dynamic())
+ if (object->is_dynamic())
this->in_dyn_ = true;
else
this->in_reg_ = true;
void
Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym,
unsigned st_shndx, bool is_ordinary,
- Object* aobject, const char* aversion)
+ Object* object, const char* version)
{
- this->override_base(sym, st_shndx, is_ordinary, aobject, aversion);
+ this->override_base(sym, st_shndx, is_ordinary, object, version);
this->value_ = sym.get_st_value();
this->symsize_ = sym.get_st_size();
}
Symbol_table::override(Sized_symbol<size>* tosym,
const elfcpp::Sym<size, big_endian>& fromsym,
unsigned int st_shndx, bool is_ordinary,
- Object* aobject, const char* aversion)
+ Object* object, const char* version)
{
- tosym->override(fromsym, st_shndx, is_ordinary, aobject, aversion);
+ tosym->override(fromsym, st_shndx, is_ordinary, object, version);
if (tosym->has_alias())
{
Symbol* sym = this->weak_aliases_[tosym];
Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym);
do
{
- ssym->override(fromsym, st_shndx, is_ordinary, aobject, aversion);
+ ssym->override(fromsym, st_shndx, is_ordinary, object, version);
sym = this->weak_aliases_[ssym];
gold_assert(sym != NULL);
ssym = this->get_sized_symbol<size>(sym);
bool adjust_common_sizes;
typename Sized_symbol<size>::Size_type tosize = to->symsize();
- if (Symbol_table::should_override(to, frombits, object,
+ if (Symbol_table::should_override(to, frombits, OBJECT, object,
&adjust_common_sizes))
{
this->override(to, sym, st_shndx, is_ordinary, object, version);
Symbol_table::report_resolve_problem(false,
_("common of '%s' overriding "
"smaller common"),
- to, object);
+ to, OBJECT, object);
else if (tosize < sym.get_st_size())
Symbol_table::report_resolve_problem(false,
_("common of '%s' overidden by "
"larger common"),
- to, object);
+ to, OBJECT, object);
else
Symbol_table::report_resolve_problem(false,
_("multiple common of '%s'"),
- to, object);
+ to, OBJECT, object);
}
// A new weak undefined reference, merging with an old weak
bool
Symbol_table::should_override(const Symbol* to, unsigned int frombits,
- Object* object, bool* adjust_common_sizes)
+ Defined defined, Object* object,
+ bool* adjust_common_sizes)
{
*adjust_common_sizes = false;
// --just-symbols, then don't warn. This is for compatibility
// with the GNU linker. FIXME: This is a hack.
if ((to->source() == Symbol::FROM_OBJECT && to->object()->just_symbols())
- || object->just_symbols())
+ || (object != NULL && object->just_symbols()))
return false;
- Symbol_table::report_resolve_problem(true,
- _("multiple definition of '%s'"),
- to, object);
+ if (!parameters->options().muldefs())
+ Symbol_table::report_resolve_problem(true,
+ _("multiple definition of '%s'"),
+ to, defined, object);
return false;
case WEAK_DEF * 16 + DEF:
Symbol_table::report_resolve_problem(false,
_("definition of '%s' overriding "
"common"),
- to, object);
+ to, defined, object);
return true;
case DEF * 16 + WEAK_DEF:
Symbol_table::report_resolve_problem(false,
_("definition of '%s' overriding "
"dynamic common definition"),
- to, object);
+ to, defined, object);
return true;
case DEF * 16 + DYN_DEF:
Symbol_table::report_resolve_problem(false,
_("common '%s' overridden by "
"previous definition"),
- to, object);
+ to, defined, object);
return false;
case WEAK_DEF * 16 + COMMON:
// Issue an error or warning due to symbol resolution. IS_ERROR
// indicates an error rather than a warning. MSG is the error
// message; it is expected to have a %s for the symbol name. TO is
-// the existing symbol. OBJECT is where the new symbol was found.
+// the existing symbol. DEFINED/OBJECT is where the new symbol was
+// found.
// FIXME: We should have better location information here. When the
// symbol is defined, we should be able to pull the location from the
void
Symbol_table::report_resolve_problem(bool is_error, const char* msg,
- const Symbol* to, Object* object)
+ const Symbol* to, Defined defined,
+ Object* object)
{
std::string demangled(to->demangled_name());
size_t len = strlen(msg) + demangled.length() + 10;
snprintf(buf, len, msg, demangled.c_str());
const char* objname;
- if (object != NULL)
- objname = object->name().c_str();
- else
- objname = _("command line");
+ switch (defined)
+ {
+ case OBJECT:
+ objname = object->name().c_str();
+ break;
+ case COPY:
+ objname = _("COPY reloc");
+ break;
+ case DEFSYM:
+ case UNDEFINED:
+ objname = _("command line");
+ break;
+ case SCRIPT:
+ objname = _("linker script");
+ break;
+ case PREDEFINED:
+ objname = _("linker defined");
+ break;
+ default:
+ gold_unreachable();
+ }
if (is_error)
gold_error("%s: %s", objname, buf);
// defining special symbols.
bool
-Symbol_table::should_override_with_special(const Symbol* to)
+Symbol_table::should_override_with_special(const Symbol* to, Defined defined)
{
bool adjust_common_sizes;
unsigned int frombits = global_flag | regular_flag | def_flag;
- bool ret = Symbol_table::should_override(to, frombits, NULL,
+ bool ret = Symbol_table::should_override(to, frombits, defined, NULL,
&adjust_common_sizes);
gold_assert(!adjust_common_sizes);
return ret;
// We shouldn't see these flags. If we do, we need to handle them
// somehow.
- gold_assert(!from->is_target_special_ || this->is_target_special_);
gold_assert(!from->is_forwarder_);
- gold_assert(!from->has_plt_offset_);
+ gold_assert(!from->has_plt_offset());
gold_assert(!from->has_warning_);
gold_assert(!from->is_copied_from_dynobj_);
gold_assert(!from->is_forced_local_);