return static_cast<STV>(other >> 2);
}
+inline unsigned char
+elf_st_other(STV vis, unsigned char nonvis)
+{
+ return ((nonvis << 2)
+ + (static_cast<unsigned char>(vis) & 3));
+}
+
} // End namespace elfcpp.
// Include internal details after defining the types.
const internal::Sym_data<size>* p_;
};
+// Writer class for an ELF symbol table entry.
+
+template<int size, bool big_endian>
+class Sym_write
+{
+ public:
+ Sym_write(unsigned char* p)
+ : p_(reinterpret_cast<internal::Sym_data<size>*>(p))
+ { }
+
+ void
+ put_st_name(Elf_Word v)
+ { this->p_->st_name = internal::convert_word<big_endian>(v); }
+
+ void
+ put_st_value(typename Elf_types<size>::Elf_Addr v)
+ { this->p_->st_value = internal::convert_addr<size, big_endian>(v); }
+
+ void
+ put_st_size(typename Elf_types<size>::Elf_WXword v)
+ { this->p_->st_size = internal::convert_wxword<size, big_endian>(v); }
+
+ void
+ put_st_info(unsigned char v)
+ { this->p_->st_info = v; }
+
+ void
+ put_st_info(STB bind, STT type)
+ { this->p_->st_info = elf_st_info(bind, type); }
+
+ void
+ put_st_other(unsigned char v)
+ { this->p_->st_other = v; }
+
+ void
+ put_st_other(STV vis, unsigned char nonvis)
+ { this->p_->st_other = elf_st_other(vis, nonvis); }
+
+ void
+ put_st_shndx(Elf_Half v)
+ { this->p_->st_shndx = internal::convert_half<big_endian>(v); }
+
+ Sym<size, big_endian>
+ sym()
+ { return Sym<size, big_endian>(reinterpret_cast<unsigned char*>(this->p_)); }
+
+ private:
+ internal::Sym_data<size>* p_;
+};
+
} // End namespace elfcpp.
#endif // !defined(ELFPCP_H)
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2006-08-18 15:26-0700\n"
+"POT-Creation-Date: 2006-09-07 14:17-0700\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
msgid "%s: -%c: %s\n"
msgstr ""
-#: resolve.cc:103
+#: resolve.cc:135
#, c-format
msgid "%s: %s: invalid STB_LOCAL symbol %s in external symbols\n"
msgstr ""
-#: resolve.cc:109
+#: resolve.cc:141
#, c-format
msgid "%s: %s: unsupported symbol binding %d for symbol %s\n"
msgstr ""
-#: symtab.cc:262
+#: symtab.cc:271
#, c-format
msgid "%s: %s: mixing 32-bit and 64-bit ELF objects\n"
msgstr ""
-#: symtab.cc:275
+#: symtab.cc:284
#, c-format
msgid "%s: %s: bad symbol name offset %u at %lu\n"
msgstr ""
namespace gold
{
+// Symbol methods used in this file.
+
+// Override the fields in Symbol.
+
+template<int size, bool big_endian>
+void
+Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
+ Object* object)
+{
+ this->object_ = object;
+ this->shnum_ = sym.get_st_shndx(); // FIXME: Handle SHN_XINDEX.
+ this->type_ = sym.get_st_type();
+ this->binding_ = sym.get_st_bind();
+ this->visibility_ = sym.get_st_visibility();
+ this->other_ = sym.get_st_nonvis();
+}
+
+// Override the fields in Sized_symbol.
+
+template<int size>
+template<bool big_endian>
+void
+Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym,
+ Object* object)
+{
+ this->override_base(sym, object);
+ this->value_ = sym.get_st_value();
+ this->size_ = sym.get_st_size();
+}
+
// Resolve a symbol. This is called the second and subsequent times
// we see a symbol. TO is the pre-existing symbol. SYM is the new
// symbol, seen in OBJECT.
template<int size, bool big_endian>
void
-Symbol_table::resolve(Symbol* to,
+Symbol_table::resolve(Sized_symbol<size>* to,
const elfcpp::Sym<size, big_endian>& sym,
Object* object)
{
break;
default:
+ if (to->type() == elfcpp::STT_COMMON)
+ tobits |= (2 << 2);
break;
}
}
if (object->is_dynamic())
- frombits |= (1 << 1);
+ {
+ frombits |= (1 << 1);
+
+ // Record that we've seen this symbol in a dynamic object.
+ to->set_in_dyn();
+ }
switch (sym.get_st_shndx())
{
break;
default:
+ if (sym.get_st_type() == elfcpp::STT_COMMON)
+ frombits |= (2 << 2);
break;
}
+ // FIXME: Warn if either but not both of TO and SYM are STT_TLS.
+
// We use a giant switch table for symbol resolution. This code is
// unwieldy, but: 1) it is efficient; 2) we definitely handle all
// cases; 3) it is easy to change the handling of a particular case.
return;
case WEAK_DEF * 16 + DEF:
- // In the original SVR4 linker, a weak definition followed by a
- // regular definition was treated as a multiple definition
- // error. In the Solaris linker and the GNU linker, a weak
- // definition followed by a regular definition causes the
- // regular definition to be ignored. We are currently
- // compatible with the GNU linker. In the future we should add
- // a target specific option to change this. FIXME.
+ // We've seen a weak definition, and now we see a strong
+ // definition. In the original SVR4 linker, this was treated as
+ // a multiple definition error. In the Solaris linker and the
+ // GNU linker, a weak definition followed by a regular
+ // definition causes the weak definition to be overridden. We
+ // are currently compatible with the GNU linker. In the future
+ // we should add a target specific option to change this.
+ // FIXME.
+ to->override(sym, object);
return;
case DYN_DEF * 16 + DEF:
case DYN_WEAK_DEF * 16 + DEF:
+ // We've seen a definition in a dynamic object, and now we see a
+ // definition in a regular object. The definition in the
+ // regular object overrides the definition in the dynamic
+ // object.
+ to->override(sym, object);
+ return;
+
case UNDEF * 16 + DEF:
case WEAK_UNDEF * 16 + DEF:
case DYN_UNDEF * 16 + DEF:
case DYN_WEAK_UNDEF * 16 + DEF:
+ // We've seen an undefined reference, and now we see a
+ // definition. We use the definition.
+ to->override(sym, object);
+ return;
+
case COMMON * 16 + DEF:
case WEAK_COMMON * 16 + DEF:
case DYN_COMMON * 16 + DEF:
case DYN_WEAK_COMMON * 16 + DEF:
+ // We've seen a common symbol and now we see a definition. The
+ // definition overrides. FIXME: We should optionally issue a
+ // warning.
+ to->override(sym, object);
+ return;
case DEF * 16 + WEAK_DEF:
case WEAK_DEF * 16 + WEAK_DEF:
+ // We've seen a definition and now we see a weak definition. We
+ // ignore the new weak definition.
+ return;
+
case DYN_DEF * 16 + WEAK_DEF:
case DYN_WEAK_DEF * 16 + WEAK_DEF:
+ // We've seen a dynamic definition and now we see a regular weak
+ // definition. The regular weak definition overrides.
+ to->override(sym, object);
+ return;
+
case UNDEF * 16 + WEAK_DEF:
case WEAK_UNDEF * 16 + WEAK_DEF:
case DYN_UNDEF * 16 + WEAK_DEF:
case DYN_WEAK_UNDEF * 16 + WEAK_DEF:
+ // A weak definition of a currently undefined symbol.
+ to->override(sym, object);
+ return;
+
case COMMON * 16 + WEAK_DEF:
case WEAK_COMMON * 16 + WEAK_DEF:
+ // A weak definition does not override a common definition.
+ return;
+
case DYN_COMMON * 16 + WEAK_DEF:
case DYN_WEAK_COMMON * 16 + WEAK_DEF:
+ // A weak definition does override a definition in a dynamic
+ // object. FIXME: We should optionally issue a warning.
+ to->override(sym, object);
+ return;
case DEF * 16 + DYN_DEF:
case WEAK_DEF * 16 + DYN_DEF:
case DYN_DEF * 16 + DYN_DEF:
case DYN_WEAK_DEF * 16 + DYN_DEF:
+ // Ignore a dynamic definition if we already have a definition.
+ return;
+
case UNDEF * 16 + DYN_DEF:
case WEAK_UNDEF * 16 + DYN_DEF:
case DYN_UNDEF * 16 + DYN_DEF:
case DYN_WEAK_UNDEF * 16 + DYN_DEF:
+ // Use a dynamic definition if we have a reference.
+ to->override(sym, object);
+ return;
+
case COMMON * 16 + DYN_DEF:
case WEAK_COMMON * 16 + DYN_DEF:
case DYN_COMMON * 16 + DYN_DEF:
case DYN_WEAK_COMMON * 16 + DYN_DEF:
+ // Ignore a dynamic definition if we already have a common
+ // definition.
+ return;
case DEF * 16 + DYN_WEAK_DEF:
case WEAK_DEF * 16 + DYN_WEAK_DEF:
case DYN_DEF * 16 + DYN_WEAK_DEF:
case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF:
+ // Ignore a weak dynamic definition if we already have a
+ // definition.
+ return;
+
case UNDEF * 16 + DYN_WEAK_DEF:
case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
case DYN_UNDEF * 16 + DYN_WEAK_DEF:
case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
+ // Use a weak dynamic definition if we have a reference.
+ to->override(sym, object);
+ return;
+
case COMMON * 16 + DYN_WEAK_DEF:
case WEAK_COMMON * 16 + DYN_WEAK_DEF:
case DYN_COMMON * 16 + DYN_WEAK_DEF:
case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF:
+ // Ignore a weak dynamic definition if we already have a common
+ // definition.
+ return;
case DEF * 16 + UNDEF:
case WEAK_DEF * 16 + UNDEF:
case WEAK_COMMON * 16 + UNDEF:
case DYN_COMMON * 16 + UNDEF:
case DYN_WEAK_COMMON * 16 + UNDEF:
+ // A new undefined reference tells us nothing.
+ return;
case DEF * 16 + WEAK_UNDEF:
case WEAK_DEF * 16 + WEAK_UNDEF:
case WEAK_COMMON * 16 + WEAK_UNDEF:
case DYN_COMMON * 16 + WEAK_UNDEF:
case DYN_WEAK_COMMON * 16 + WEAK_UNDEF:
+ // A new weak undefined reference tells us nothing.
+ return;
case DEF * 16 + DYN_UNDEF:
case WEAK_DEF * 16 + DYN_UNDEF:
case WEAK_COMMON * 16 + DYN_UNDEF:
case DYN_COMMON * 16 + DYN_UNDEF:
case DYN_WEAK_COMMON * 16 + DYN_UNDEF:
+ // A new dynamic undefined reference tells us nothing.
+ return;
case DEF * 16 + DYN_WEAK_UNDEF:
case WEAK_DEF * 16 + DYN_WEAK_UNDEF:
case WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
case DYN_COMMON * 16 + DYN_WEAK_UNDEF:
case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF:
+ // A new weak dynamic undefined reference tells us nothing.
+ return;
case DEF * 16 + COMMON:
+ // A common symbol does not override a definition.
+ return;
+
case WEAK_DEF * 16 + COMMON:
case DYN_DEF * 16 + COMMON:
case DYN_WEAK_DEF * 16 + COMMON:
+ // A common symbol does override a weak definition or a dynamic
+ // definition.
+ to->override(sym, object);
+ return;
+
case UNDEF * 16 + COMMON:
case WEAK_UNDEF * 16 + COMMON:
case DYN_UNDEF * 16 + COMMON:
case DYN_WEAK_UNDEF * 16 + COMMON:
+ // A common symbol is a definition for a reference.
+ to->override(sym, object);
+ return;
+
case COMMON * 16 + COMMON:
case WEAK_COMMON * 16 + COMMON:
case DYN_COMMON * 16 + COMMON:
case WEAK_COMMON * 16 + DYN_WEAK_COMMON:
case DYN_COMMON * 16 + DYN_WEAK_COMMON:
case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON:
-
+ abort();
break;
+
+ default:
+ abort();
}
}
template
void
Symbol_table::resolve<32, true>(
- Symbol* to,
+ Sized_symbol<32>* to,
const elfcpp::Sym<32, true>& sym,
Object* object);
template
void
Symbol_table::resolve<32, false>(
- Symbol* to,
+ Sized_symbol<32>* to,
const elfcpp::Sym<32, false>& sym,
Object* object);
template
void
Symbol_table::resolve<64, true>(
- Symbol* to,
+ Sized_symbol<64>* to,
const elfcpp::Sym<64, true>& sym,
Object* object);
template
void
Symbol_table::resolve<64, false>(
- Symbol* to,
+ Sized_symbol<64>* to,
const elfcpp::Sym<64, false>& sym,
Object* object);
// Class Symbol.
-Symbol::~Symbol()
-{
-}
-
// Initialize the fields in the base class Symbol.
template<int size, bool big_endian>
this->binding_ = sym.get_st_bind();
this->visibility_ = sym.get_st_visibility();
this->other_ = sym.get_st_nonvis();
- this->special_ = false;
- this->def_ = false;
- this->forwarder_ = false;
+ this->is_special_ = false;
+ this->is_def_ = false;
+ this->is_forwarder_ = false;
+ this->in_dyn_ = object->is_dynamic();
}
// Initialize the fields in Sized_symbol.
// Resolve a Symbol with another Symbol. This is only used in the
// unusual case where there are references to both an unversioned
// symbol and a symbol with a version, and we then discover that that
-// version is the default version.
+// version is the default version. Because this is unusual, we do
+// this the slow way, by converting back to an ELF symbol.
+template<int size, bool big_endian>
void
-Symbol_table::resolve(Symbol*, const Symbol*)
+Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from)
{
+ unsigned char buf[elfcpp::Elf_sizes<size>::sym_size];
+ elfcpp::Sym_write<size, big_endian> esym(buf);
+ // We don't bother to set the st_name field.
+ esym.put_st_value(from->value());
+ esym.put_st_size(from->symsize());
+ esym.put_st_info(from->binding(), from->type());
+ esym.put_st_other(from->visibility(), from->other());
+ esym.put_st_shndx(from->shnum());
+ Symbol_table::resolve(to, esym.sym(), from->object());
}
// Add one symbol from OBJECT to the symbol table. NAME is symbol
// ins.first->second: the value (Symbol*).
// ins.second: true if new entry was inserted, false if not.
- Symbol* ret;
+ Sized_symbol<size>* ret;
if (!ins.second)
{
// We already have an entry for NAME/VERSION.
- ret = ins.first->second;
+ ret = this->get_sized_symbol<size>(ins.first->second);
assert(ret != NULL);
Symbol_table::resolve(ret, sym, object);
{
// This is the unfortunate case where we already have
// entries for both NAME/VERSION and NAME/NULL.
- Symbol_table::resolve(ret, insdef.first->second);
+ const Sized_symbol<size>* sym2 =
+ this->get_sized_symbol<size>(insdef.first->second);
+ Symbol_table::resolve<size, big_endian>(ret, sym2);
this->make_forwarder(insdef.first->second, ret);
insdef.first->second = ret;
}
{
// We already have an entry for NAME/NULL. Make
// NAME/VERSION point to it.
- ret = insdef.first->second;
+ ret = this->get_sized_symbol<size>(insdef.first->second);
Symbol_table::resolve(ret, sym, object);
ins.first->second = ret;
}
else
{
- Sized_symbol<size>* rs;
Sized_target<size, big_endian>* target = object->sized_target();
- if (target->has_make_symbol())
+ if (!target->has_make_symbol())
+ ret = new Sized_symbol<size>();
+ else
{
- rs = target->make_symbol();
- if (rs == NULL)
+ ret = target->make_symbol();
+ if (ret == NULL)
{
// This means that we don't want a symbol table
// entry after all.
return NULL;
}
}
- else
- rs = new Sized_symbol<size>();
- rs->init(name, version, object, sym);
- ret = rs;
+ ret->init(name, version, object, sym);
+
ins.first->second = ret;
if (def)
{
class Symbol
{
public:
- virtual ~Symbol();
-
// Return the symbol name.
const char*
name() const
version() const
{ return this->version_; }
- // Return whether this symbol is a forwarder. This will never be
- // true of a symbol found in the hash table, but may be true of
- // symbol pointers attached to object files.
- bool
- is_forwarder() const
- { return this->forwarder_; }
-
- // Mark this symbol as a forwarder.
- void
- set_forwarder()
- { this->forwarder_ = true; }
-
// Return the object with which this symbol is associated.
Object*
object() const
binding() const
{ return this->binding_; }
+ // Return the symbol type.
+ elfcpp::STT
+ type() const
+ { return this->type_; }
+
+ // Return the symbol visibility.
+ elfcpp::STV
+ visibility() const
+ { return this->visibility_; }
+
+ // Return the non-visibility part of the st_other field.
+ unsigned char
+ other() const
+ { return this->other_; }
+
// Return the section index.
unsigned int
shnum() const
{ return this->shnum_; }
+ // Return whether this symbol is a forwarder. This will never be
+ // true of a symbol found in the hash table, but may be true of
+ // symbol pointers attached to object files.
+ bool
+ is_forwarder() const
+ { return this->is_forwarder_; }
+
+ // Mark this symbol as a forwarder.
+ void
+ set_forwarder()
+ { this->is_forwarder_ = true; }
+
+ // Return whether this symbol was seen in a dynamic object.
+ bool
+ in_dyn() const
+ { return this->in_dyn_; }
+
+ // Mark this symbol as seen in a dynamic object.
+ void
+ set_in_dyn()
+ { this->in_dyn_ = true; }
+
protected:
// Instances of this class should always be created at a specific
// size.
init_base(const char *name, const char* version, Object* object,
const elfcpp::Sym<size, big_endian>&);
+ // Override existing symbol.
+ template<int size, bool big_endian>
+ void
+ override_base(const elfcpp::Sym<size, big_endian>&, Object* object);
+
private:
Symbol(const Symbol&);
Symbol& operator=(const Symbol&);
unsigned int other_ : 6;
// True if this symbol always requires special target-specific
// handling.
- bool special_ : 1;
+ bool is_special_ : 1;
// True if this is the default version of the symbol.
- bool def_ : 1;
+ bool is_def_ : 1;
// True if this symbol really forwards to another symbol. This is
// used when we discover after the fact that two different entries
// in the hash table really refer to the same symbol. This will
// for a symbol found in the list of symbols attached to an Object.
// It forwards to the symbol found in the forwarders_ map of
// Symbol_table.
- bool forwarder_ : 1;
+ bool is_forwarder_ : 1;
+ // True if we've seen this symbol in a dynamic object.
+ bool in_dyn_ : 1;
};
// The parts of a symbol which are size specific. Using a template
class Sized_symbol : public Symbol
{
public:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Value_type;
+ typedef typename elfcpp::Elf_types<size>::Elf_WXword Size_type;
+
Sized_symbol()
{ }
init(const char *name, const char* version, Object* object,
const elfcpp::Sym<size, big_endian>&);
+ // Override existing symbol.
+ template<bool big_endian>
+ void
+ override(const elfcpp::Sym<size, big_endian>&, Object* object);
+
+ // Return the symbol's value.
+ Value_type
+ value() const
+ { return this->value_; }
+
+ // Return the symbol's size (we can't call this 'size' because that
+ // is a template parameter).
+ Size_type
+ symsize() const
+ { return this->size_; }
+
private:
Sized_symbol(const Sized_symbol&);
Sized_symbol& operator=(const Sized_symbol&);
// Symbol value.
- typename elfcpp::Elf_types<size>::Elf_Addr value_;
+ Value_type value_;
// Symbol size.
- typename elfcpp::Elf_types<size>::Elf_WXword size_;
+ Size_type size_;
};
// The main linker symbol table.
public:
Symbol_table();
- virtual ~Symbol_table();
+ ~Symbol_table();
// Add COUNT external symbols from OBJECT to the symbol table. SYMS
// is the symbols, SYM_NAMES is their names, SYM_NAME_SIZE is the
get_size() const
{ return this->size_; }
+ // Return the sized version of a symbol in this table.
+ template<int size>
+ Sized_symbol<size>*
+ get_sized_symbol(Symbol*);
+
+ template<int size>
+ const Sized_symbol<size>*
+ get_sized_symbol(const Symbol*);
+
private:
Symbol_table(const Symbol_table&);
Symbol_table& operator=(const Symbol_table&);
// Resolve symbols.
template<int size, bool big_endian>
static void
- resolve(Symbol* to, const elfcpp::Sym<size, big_endian>& sym, Object*);
+ resolve(Sized_symbol<size>* to,
+ const elfcpp::Sym<size, big_endian>& sym,
+ Object*);
+ template<int size, bool big_endian>
static void
- resolve(Symbol* to, const Symbol* from);
+ resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from);
typedef std::pair<const char*, const char*> Symbol_table_key;
Unordered_map<Symbol*, Symbol*> forwarders_;
};
+// We inline get_sized_symbol for efficiency.
+
+template<int size>
+Sized_symbol<size>*
+Symbol_table::get_sized_symbol(Symbol* sym)
+{
+ assert(size == this->get_size());
+ return static_cast<Sized_symbol<size>*>(sym);
+}
+
+template<int size>
+const Sized_symbol<size>*
+Symbol_table::get_sized_symbol(const Symbol* sym)
+{
+ assert(size == this->get_size());
+ return static_cast<const Sized_symbol<size>*>(sym);
+}
+
} // End namespace gold.
#endif // !defined(GOLD_SYMTAB_H)
projects / deliverable / binutils-gdb.git / commitdiff
