diff options
Diffstat (limited to 'gold/resolve.cc')
| -rw-r--r-- | gold/resolve.cc | 560 |
1 files changed, 560 insertions, 0 deletions
diff --git a/gold/resolve.cc b/gold/resolve.cc new file mode 100644 index 000000000000..1d874863d628 --- /dev/null +++ b/gold/resolve.cc @@ -0,0 +1,560 @@ +// resolve.cc -- symbol resolution for gold + +#include "gold.h" + +#include "elfcpp.h" +#include "target.h" +#include "object.h" +#include "symtab.h" + +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, const char* version) +{ + gold_assert(this->source_ == FROM_OBJECT); + this->u_.from_object.object = object; + if (version != NULL && this->version() != version) + { + gold_assert(this->version() == NULL); + this->version_ = version; + } + // FIXME: Handle SHN_XINDEX. + this->u_.from_object.shndx = sym.get_st_shndx(); + this->type_ = sym.get_st_type(); + this->binding_ = sym.get_st_bind(); + this->visibility_ = sym.get_st_visibility(); + this->nonvis_ = 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, const char* version) +{ + this->override_base(sym, object, version); + this->value_ = sym.get_st_value(); + this->symsize_ = 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. VERSION of the version of SYM. + +template<int size, bool big_endian> +void +Symbol_table::resolve(Sized_symbol<size>* to, + const elfcpp::Sym<size, big_endian>& sym, + Object* object, const char* version) +{ + if (object->target()->has_resolve()) + { + Sized_target<size, big_endian>* sized_target; + sized_target = object->sized_target + SELECT_SIZE_ENDIAN_NAME(size, big_endian) ( + SELECT_SIZE_ENDIAN_ONLY(size, big_endian)); + sized_target->resolve(to, sym, object, version); + return; + } + + // Build a little code for each symbol. + // Bit 0: 0 for global, 1 for weak. + // Bit 1: 0 for regular object, 1 for shared object + // Bits 2-3: 0 for normal, 1 for undefined, 2 for common + // This gives us values from 0 to 11: + + enum + { + DEF = 0, + WEAK_DEF = 1, + DYN_DEF = 2, + DYN_WEAK_DEF = 3, + UNDEF = 4, + WEAK_UNDEF = 5, + DYN_UNDEF = 6, + DYN_WEAK_UNDEF = 7, + COMMON = 8, + WEAK_COMMON = 9, + DYN_COMMON = 10, + DYN_WEAK_COMMON = 11 + }; + + int tobits; + switch (to->binding()) + { + case elfcpp::STB_GLOBAL: + tobits = 0; + break; + + case elfcpp::STB_WEAK: + tobits = 1; + break; + + case elfcpp::STB_LOCAL: + // We should only see externally visible symbols in the symbol + // table. + gold_unreachable(); + + default: + // Any target which wants to handle STB_LOOS, etc., needs to + // define a resolve method. + gold_unreachable(); + } + + if (to->source() == Symbol::FROM_OBJECT + && to->object()->is_dynamic()) + tobits |= (1 << 1); + + switch (to->shndx()) + { + case elfcpp::SHN_UNDEF: + tobits |= (1 << 2); + break; + + case elfcpp::SHN_COMMON: + tobits |= (2 << 2); + break; + + default: + if (to->type() == elfcpp::STT_COMMON) + tobits |= (2 << 2); + break; + } + + int frombits; + switch (sym.get_st_bind()) + { + case elfcpp::STB_GLOBAL: + frombits = 0; + break; + + case elfcpp::STB_WEAK: + frombits = 1; + break; + + case elfcpp::STB_LOCAL: + fprintf(stderr, + _("%s: %s: invalid STB_LOCAL symbol %s in external symbols\n"), + program_name, object->name().c_str(), to->name()); + gold_exit(false); + + default: + fprintf(stderr, + _("%s: %s: unsupported symbol binding %d for symbol %s\n"), + program_name, object->name().c_str(), + static_cast<int>(sym.get_st_bind()), to->name()); + gold_exit(false); + } + + if (!object->is_dynamic()) + { + // Record that we've seen this symbol in a regular object. + to->set_in_reg(); + } + else + { + frombits |= (1 << 1); + + // Record that we've seen this symbol in a dynamic object. + to->set_in_dyn(); + } + + switch (sym.get_st_shndx()) + { + case elfcpp::SHN_UNDEF: + frombits |= (1 << 2); + break; + + case elfcpp::SHN_COMMON: + frombits |= (2 << 2); + break; + + default: + if (sym.get_st_type() == elfcpp::STT_COMMON) + frombits |= (2 << 2); + break; + } + + if ((tobits & (1 << 1)) != (frombits & (1 << 1))) + { + // This symbol is seen in both a dynamic object and a regular + // object. That means that we need the symbol to go into the + // dynamic symbol table, so that the dynamic linker can use the + // regular symbol to override or define the dynamic symbol. + to->set_needs_dynsym_entry(); + } + + // 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. + // The alternative would be a series of conditionals, but it is easy + // to get the ordering wrong. This could also be done as a table, + // but that is no easier to understand than this large switch + // statement. + + switch (tobits * 16 + frombits) + { + case DEF * 16 + DEF: + // Two definitions of the same symbol. + fprintf(stderr, "%s: %s: multiple definition of %s\n", + program_name, object->name().c_str(), to->name()); + // FIXME: Report locations. Record that we have seen an error. + return; + + case WEAK_DEF * 16 + DEF: + // 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, version); + 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, version); + 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, version); + 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, version a + // warning. + to->override(sym, object, version); + 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, version); + 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, version); + 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, version); + 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, version); + 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, version); + 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 DYN_DEF * 16 + UNDEF: + case DYN_WEAK_DEF * 16 + UNDEF: + case UNDEF * 16 + UNDEF: + // A new undefined reference tells us nothing. + return; + + case WEAK_UNDEF * 16 + UNDEF: + case DYN_UNDEF * 16 + UNDEF: + case DYN_WEAK_UNDEF * 16 + UNDEF: + // A strong undef overrides a dynamic or weak undef. + to->override(sym, object, version); + return; + + case COMMON * 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 DYN_DEF * 16 + WEAK_UNDEF: + case DYN_WEAK_DEF * 16 + WEAK_UNDEF: + case UNDEF * 16 + WEAK_UNDEF: + case WEAK_UNDEF * 16 + WEAK_UNDEF: + case DYN_UNDEF * 16 + WEAK_UNDEF: + case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF: + case COMMON * 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 DYN_DEF * 16 + DYN_UNDEF: + case DYN_WEAK_DEF * 16 + DYN_UNDEF: + case UNDEF * 16 + DYN_UNDEF: + case WEAK_UNDEF * 16 + DYN_UNDEF: + case DYN_UNDEF * 16 + DYN_UNDEF: + case DYN_WEAK_UNDEF * 16 + DYN_UNDEF: + case COMMON * 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 DYN_DEF * 16 + DYN_WEAK_UNDEF: + case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF: + case UNDEF * 16 + DYN_WEAK_UNDEF: + case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF: + case DYN_UNDEF * 16 + DYN_WEAK_UNDEF: + case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF: + case COMMON * 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, version); + 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, version); + return; + + case COMMON * 16 + COMMON: + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; + + case WEAK_COMMON * 16 + COMMON: + // I'm not sure just what a weak common symbol means, but + // presumably it can be overridden by a regular common symbol. + to->override(sym, object, version); + return; + + case DYN_COMMON * 16 + COMMON: + case DYN_WEAK_COMMON * 16 + COMMON: + { + // Use the real common symbol, but adjust the size if necessary. + typename Sized_symbol<size>::Size_type symsize = to->symsize(); + to->override(sym, object, version); + if (to->symsize() < symsize) + to->set_symsize(symsize); + } + return; + + case DEF * 16 + WEAK_COMMON: + case WEAK_DEF * 16 + WEAK_COMMON: + case DYN_DEF * 16 + WEAK_COMMON: + case DYN_WEAK_DEF * 16 + WEAK_COMMON: + // Whatever a weak common symbol is, it won't override a + // definition. + return; + + case UNDEF * 16 + WEAK_COMMON: + case WEAK_UNDEF * 16 + WEAK_COMMON: + case DYN_UNDEF * 16 + WEAK_COMMON: + case DYN_WEAK_UNDEF * 16 + WEAK_COMMON: + // A weak common symbol is better than an undefined symbol. + to->override(sym, object, version); + return; + + case COMMON * 16 + WEAK_COMMON: + case WEAK_COMMON * 16 + WEAK_COMMON: + case DYN_COMMON * 16 + WEAK_COMMON: + case DYN_WEAK_COMMON * 16 + WEAK_COMMON: + // Ignore a weak common symbol in the presence of a real common + // symbol. + return; + + case DEF * 16 + DYN_COMMON: + case WEAK_DEF * 16 + DYN_COMMON: + case DYN_DEF * 16 + DYN_COMMON: + case DYN_WEAK_DEF * 16 + DYN_COMMON: + // Ignore a dynamic common symbol in the presence of a + // definition. + return; + + case UNDEF * 16 + DYN_COMMON: + case WEAK_UNDEF * 16 + DYN_COMMON: + case DYN_UNDEF * 16 + DYN_COMMON: + case DYN_WEAK_UNDEF * 16 + DYN_COMMON: + // A dynamic common symbol is a definition of sorts. + to->override(sym, object, version); + return; + + case COMMON * 16 + DYN_COMMON: + case WEAK_COMMON * 16 + DYN_COMMON: + case DYN_COMMON * 16 + DYN_COMMON: + case DYN_WEAK_COMMON * 16 + DYN_COMMON: + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; + + case DEF * 16 + DYN_WEAK_COMMON: + case WEAK_DEF * 16 + DYN_WEAK_COMMON: + case DYN_DEF * 16 + DYN_WEAK_COMMON: + case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON: + // A common symbol is ignored in the face of a definition. + return; + + case UNDEF * 16 + DYN_WEAK_COMMON: + case WEAK_UNDEF * 16 + DYN_WEAK_COMMON: + case DYN_UNDEF * 16 + DYN_WEAK_COMMON: + case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON: + // I guess a weak common symbol is better than a definition. + to->override(sym, object, version); + return; + + case COMMON * 16 + DYN_WEAK_COMMON: + case WEAK_COMMON * 16 + DYN_WEAK_COMMON: + case DYN_COMMON * 16 + DYN_WEAK_COMMON: + case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON: + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; + + default: + gold_unreachable(); + } +} + +// Instantiate the templates we need. We could use the configure +// script to restrict this to only the ones needed for implemented +// targets. + +template +void +Symbol_table::resolve<32, true>( + Sized_symbol<32>* to, + const elfcpp::Sym<32, true>& sym, + Object* object, + const char* version); + +template +void +Symbol_table::resolve<32, false>( + Sized_symbol<32>* to, + const elfcpp::Sym<32, false>& sym, + Object* object, + const char* version); + +template +void +Symbol_table::resolve<64, true>( + Sized_symbol<64>* to, + const elfcpp::Sym<64, true>& sym, + Object* object, + const char* version); + +template +void +Symbol_table::resolve<64, false>( + Sized_symbol<64>* to, + const elfcpp::Sym<64, false>& sym, + Object* object, + const char* version); + +} // End namespace gold. |