X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Fresolve.cc;h=1d874863d628588cace76341d8a6bbf8874a19bd;hb=c55fe0967e9ec38c1e9d9d3ffc4db30a49323302;hp=8252f5b98667de170baf75ef19773b10c45d4e1d;hpb=274e99f9ae3f56ab0364b3d0947b91deeb3528e1;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/resolve.cc b/gold/resolve.cc index 8252f5b986..1d874863d6 100644 --- a/gold/resolve.cc +++ b/gold/resolve.cc @@ -17,14 +17,21 @@ namespace gold template void Symbol::override_base(const elfcpp::Sym& sym, - Object* object) + Object* object, const char* version) { - this->object_ = object; - this->shnum_ = sym.get_st_shndx(); // FIXME: Handle SHN_XINDEX. + 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->other_ = sym.get_st_nonvis(); + this->nonvis_ = sym.get_st_nonvis(); } // Override the fields in Sized_symbol. @@ -33,35 +40,30 @@ template template void Sized_symbol::override(const elfcpp::Sym& sym, - Object* object) + Object* object, const char* version) { - this->override_base(sym, object); + this->override_base(sym, object, version); this->value_ = sym.get_st_value(); - this->size_ = sym.get_st_size(); + 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. +// symbol, seen in OBJECT. VERSION of the version of SYM. template void Symbol_table::resolve(Sized_symbol* to, const elfcpp::Sym& sym, - Object* object) + Object* object, const char* version) { if (object->target()->has_resolve()) { Sized_target* sized_target; -#ifdef HAVE_MEMBER_TEMPLATE_SPECIFICATIONS - sized_target = object->sized_target(); -#else - Target* target = object->target(); - assert(target->get_size() == size); - assert(target->is_big_endian() ? big_endian : !big_endian); - sized_target = static_cast*>(target); -#endif - sized_target->resolve(to, sym, object); + 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; } @@ -101,18 +103,19 @@ Symbol_table::resolve(Sized_symbol* to, case elfcpp::STB_LOCAL: // We should only see externally visible symbols in the symbol // table. - abort(); + gold_unreachable(); default: // Any target which wants to handle STB_LOOS, etc., needs to // define a resolve method. - abort(); + gold_unreachable(); } - if (to->object() != NULL && to->object()->is_dynamic()) + if (to->source() == Symbol::FROM_OBJECT + && to->object()->is_dynamic()) tobits |= (1 << 1); - switch (to->shnum()) + switch (to->shndx()) { case elfcpp::SHN_UNDEF: tobits |= (1 << 2); @@ -153,7 +156,12 @@ Symbol_table::resolve(Sized_symbol* to, gold_exit(false); } - if (object->is_dynamic()) + if (!object->is_dynamic()) + { + // Record that we've seen this symbol in a regular object. + to->set_in_reg(); + } + else { frombits |= (1 << 1); @@ -177,6 +185,15 @@ Symbol_table::resolve(Sized_symbol* to, 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 @@ -205,7 +222,7 @@ Symbol_table::resolve(Sized_symbol* to, // 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); + to->override(sym, object, version); return; case DYN_DEF * 16 + DEF: @@ -214,7 +231,7 @@ Symbol_table::resolve(Sized_symbol* to, // definition in a regular object. The definition in the // regular object overrides the definition in the dynamic // object. - to->override(sym, object); + to->override(sym, object, version); return; case UNDEF * 16 + DEF: @@ -223,7 +240,7 @@ Symbol_table::resolve(Sized_symbol* to, 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); + to->override(sym, object, version); return; case COMMON * 16 + DEF: @@ -231,9 +248,9 @@ Symbol_table::resolve(Sized_symbol* to, 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 + // definition overrides. FIXME: We should optionally issue, version a // warning. - to->override(sym, object); + to->override(sym, object, version); return; case DEF * 16 + WEAK_DEF: @@ -246,7 +263,7 @@ Symbol_table::resolve(Sized_symbol* to, 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); + to->override(sym, object, version); return; case UNDEF * 16 + WEAK_DEF: @@ -254,7 +271,7 @@ Symbol_table::resolve(Sized_symbol* to, 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); + to->override(sym, object, version); return; case COMMON * 16 + WEAK_DEF: @@ -266,7 +283,7 @@ Symbol_table::resolve(Sized_symbol* to, 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); + to->override(sym, object, version); return; case DEF * 16 + DYN_DEF: @@ -281,7 +298,7 @@ Symbol_table::resolve(Sized_symbol* to, 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); + to->override(sym, object, version); return; case COMMON * 16 + DYN_DEF: @@ -305,7 +322,7 @@ Symbol_table::resolve(Sized_symbol* to, 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); + to->override(sym, object, version); return; case COMMON * 16 + DYN_WEAK_DEF: @@ -321,9 +338,16 @@ Symbol_table::resolve(Sized_symbol* to, 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: @@ -385,7 +409,7 @@ Symbol_table::resolve(Sized_symbol* to, case DYN_WEAK_DEF * 16 + COMMON: // A common symbol does override a weak definition or a dynamic // definition. - to->override(sym, object); + to->override(sym, object, version); return; case UNDEF * 16 + COMMON: @@ -393,57 +417,107 @@ Symbol_table::resolve(Sized_symbol* to, case DYN_UNDEF * 16 + COMMON: case DYN_WEAK_UNDEF * 16 + COMMON: // A common symbol is a definition for a reference. - to->override(sym, object); + 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_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: - abort(); - break; + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; default: - abort(); + gold_unreachable(); } } @@ -456,27 +530,31 @@ void Symbol_table::resolve<32, true>( Sized_symbol<32>* to, const elfcpp::Sym<32, true>& sym, - Object* object); + Object* object, + const char* version); template void Symbol_table::resolve<32, false>( Sized_symbol<32>* to, const elfcpp::Sym<32, false>& sym, - Object* object); + Object* object, + const char* version); template void Symbol_table::resolve<64, true>( Sized_symbol<64>* to, const elfcpp::Sym<64, true>& sym, - Object* object); + Object* object, + const char* version); template void Symbol_table::resolve<64, false>( Sized_symbol<64>* to, const elfcpp::Sym<64, false>& sym, - Object* object); + Object* object, + const char* version); } // End namespace gold.