// 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.