// symtab.h -- the gold symbol table -*- C++ -*-
-// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
class Icf;
// The base class of an entry in the symbol table. The symbol table
-// can have a lot of entries, so we don't want this class to big.
+// can have a lot of entries, so we don't want this class too big.
// Size dependent fields can be found in the template class
// Sized_symbol. Targets may support their own derived classes.
version() const
{ return this->version_; }
+ void
+ clear_version()
+ { this->version_ = NULL; }
+
// Return whether this version is the default for this symbol name
// (eg, "foo@@V2" is a default version; "foo@V1" is not). Only
// meaningful for versioned symbols.
set_is_default()
{ this->is_def_ = true; }
+ // Return the symbol's name as name@version (or name@@version).
+ std::string
+ versioned_name() const;
+
// Return the symbol source.
Source
source() const
bool
is_externally_visible() const
{
- return (this->visibility_ == elfcpp::STV_DEFAULT
- || this->visibility_ == elfcpp::STV_PROTECTED);
+ return ((this->visibility_ == elfcpp::STV_DEFAULT
+ || this->visibility_ == elfcpp::STV_PROTECTED)
+ && !this->is_forced_local_);
}
// Return true if this symbol can be preempted by a definition in
// A TLS-related reference.
TLS_REF = 4,
// A reference that can always be treated as a function call.
- FUNCTION_CALL = 8
+ FUNCTION_CALL = 8,
+ // When set, says that dynamic relocations are needed even if a
+ // symbol has a plt entry.
+ FUNC_DESC_ABI = 16,
};
// Given a direct absolute or pc-relative static relocation against
// A reference to any PLT entry in a non-position-independent executable
// does not need a dynamic relocation.
- if (!parameters->options().output_is_position_independent()
+ if (!(flags & FUNC_DESC_ABI)
+ && !parameters->options().output_is_position_independent()
&& this->has_plt_offset())
return false;
is_predefined() const
{ return this->is_predefined_; }
+ // Return true if this is a C++ vtable symbol.
+ bool
+ is_cxx_vtable() const
+ { return is_prefix_of("_ZTV", this->name_); }
+
protected:
// Instances of this class should always be created at a specific
// size.
// index, not one of the special codes from SHN_LORESERVE to
// SHN_HIRESERVE (bit 29).
bool is_ordinary_shndx_ : 1;
- // True if we've seen this symbol in a real ELF object (bit 30).
+ // True if we've seen this symbol in a "real" ELF object (bit 30).
+ // If the symbol has been seen in a relocatable, non-IR, object file,
+ // it's known to be referenced from outside the IR. A reference from
+ // a dynamic object doesn't count as a "real" ELF, and we'll simply
+ // mark the symbol as "visible" from outside the IR. The compiler
+ // can use this distinction to guide its handling of COMDAT symbols.
bool in_real_elf_ : 1;
// True if this symbol is defined in a section which was discarded
// (bit 31).
bool only_if_ref;
};
+// Specify an object/section/offset location. Used by ODR code.
+
+struct Symbol_location
+{
+ // Object where the symbol is defined.
+ Object* object;
+ // Section-in-object where the symbol is defined.
+ unsigned int shndx;
+ // For relocatable objects, offset-in-section where the symbol is defined.
+ // For dynamic objects, address where the symbol is defined.
+ off_t offset;
+ bool operator==(const Symbol_location& that) const
+ {
+ return (this->object == that.object
+ && this->shndx == that.shndx
+ && this->offset == that.offset);
+ }
+};
+
// This class manages warnings. Warnings are a GNU extension. When
// we see a section named .gnu.warning.SYM in an object file, and if
// we wind using the definition of SYM from that object file, then we
void
gc_mark_undef_symbols(Layout*);
- // During garbage collection, this ensures externally visible symbols
- // are not treated as garbage while building shared objects.
+ // This tells garbage collection that this symbol is referenced.
void
- gc_mark_symbol_for_shlib(Symbol* sym);
+ gc_mark_symbol(Symbol* sym);
// During garbage collection, this keeps sections that correspond to
// symbols seen in dynamic objects.
// the locations the symbols is (weakly) defined (and certain other
// conditions are met). This map will be used later to detect
// possible One Definition Rule (ODR) violations.
- struct Symbol_location
- {
- Object* object; // Object where the symbol is defined.
- unsigned int shndx; // Section-in-object where the symbol is defined.
- off_t offset; // Offset-in-section where the symbol is defined.
- bool operator==(const Symbol_location& that) const
- {
- return (this->object == that.object
- && this->shndx == that.shndx
- && this->offset == that.offset);
- }
- };
-
struct Symbol_location_hash
{
size_t operator()(const Symbol_location& loc) const
// Whether we should override a symbol, based on flags in
// resolve.cc.
static bool
- should_override(const Symbol*, unsigned int, Defined, Object*, bool*, bool*);
+ should_override(const Symbol*, unsigned int, elfcpp::STT, Defined,
+ Object*, bool*, bool*);
// Report a problem in symbol resolution.
static void
// Whether we should override a symbol with a special symbol which
// is automatically defined by the linker.
static bool
- should_override_with_special(const Symbol*, Defined);
+ should_override_with_special(const Symbol*, elfcpp::STT, Defined);
// Override a symbol with a special symbol.
template<int size>