1// resolve.cc -- symbol resolution for gold 2 3// Copyright (C) 2006-2017 Free Software Foundation, Inc. 4// Written by Ian Lance Taylor <iant@google.com>. 5 6// This file is part of gold. 7 8// This program is free software; you can redistribute it and/or modify 9// it under the terms of the GNU General Public License as published by 10// the Free Software Foundation; either version 3 of the License, or 11// (at your option) any later version. 12 13// This program is distributed in the hope that it will be useful, 14// but WITHOUT ANY WARRANTY; without even the implied warranty of 15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16// GNU General Public License for more details. 17 18// You should have received a copy of the GNU General Public License 19// along with this program; if not, write to the Free Software 20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21// MA 02110-1301, USA. 22 23#include "gold.h" 24 25#include "elfcpp.h" 26#include "target.h" 27#include "object.h" 28#include "symtab.h" 29#include "plugin.h" 30 31namespace gold 32{ 33 34// Symbol methods used in this file. 35 36// This symbol is being overridden by another symbol whose version is 37// VERSION. Update the VERSION_ field accordingly. 38 39inline void 40Symbol::override_version(const char* version) 41{ 42 if (version == NULL) 43 { 44 // This is the case where this symbol is NAME/VERSION, and the 45 // version was not marked as hidden. That makes it the default 46 // version, so we create NAME/NULL. Later we see another symbol 47 // NAME/NULL, and that symbol is overriding this one. In this 48 // case, since NAME/VERSION is the default, we make NAME/NULL 49 // override NAME/VERSION as well. They are already the same 50 // Symbol structure. Setting the VERSION_ field to NULL ensures 51 // that it will be output with the correct, empty, version. 52 this->version_ = version; 53 } 54 else 55 { 56 // This is the case where this symbol is NAME/VERSION_ONE, and 57 // now we see NAME/VERSION_TWO, and NAME/VERSION_TWO is 58 // overriding NAME. If VERSION_ONE and VERSION_TWO are 59 // different, then this can only happen when VERSION_ONE is NULL 60 // and VERSION_TWO is not hidden. 61 gold_assert(this->version_ == version || this->version_ == NULL); 62 this->version_ = version; 63 } 64} 65 66// This symbol is being overidden by another symbol whose visibility 67// is VISIBILITY. Updated the VISIBILITY_ field accordingly. 68 69inline void 70Symbol::override_visibility(elfcpp::STV visibility) 71{ 72 // The rule for combining visibility is that we always choose the 73 // most constrained visibility. In order of increasing constraint, 74 // visibility goes PROTECTED, HIDDEN, INTERNAL. This is the reverse 75 // of the numeric values, so the effect is that we always want the 76 // smallest non-zero value. 77 if (visibility != elfcpp::STV_DEFAULT) 78 { 79 if (this->visibility_ == elfcpp::STV_DEFAULT) 80 this->visibility_ = visibility; 81 else if (this->visibility_ > visibility) 82 this->visibility_ = visibility; 83 } 84} 85 86// Override the fields in Symbol. 87 88template<int size, bool big_endian> 89void 90Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym, 91 unsigned int st_shndx, bool is_ordinary, 92 Object* object, const char* version) 93{ 94 gold_assert(this->source_ == FROM_OBJECT); 95 this->u_.from_object.object = object; 96 this->override_version(version); 97 this->u_.from_object.shndx = st_shndx; 98 this->is_ordinary_shndx_ = is_ordinary; 99 // Don't override st_type from plugin placeholder symbols. 100 if (object->pluginobj() == NULL) 101 this->type_ = sym.get_st_type(); 102 this->binding_ = sym.get_st_bind(); 103 this->override_visibility(sym.get_st_visibility()); 104 this->nonvis_ = sym.get_st_nonvis(); 105 if (object->is_dynamic()) 106 this->in_dyn_ = true; 107 else 108 this->in_reg_ = true; 109} 110 111// Override the fields in Sized_symbol. 112 113template<int size> 114template<bool big_endian> 115void 116Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym, 117 unsigned st_shndx, bool is_ordinary, 118 Object* object, const char* version) 119{ 120 this->override_base(sym, st_shndx, is_ordinary, object, version); 121 this->value_ = sym.get_st_value(); 122 this->symsize_ = sym.get_st_size(); 123} 124 125// Override TOSYM with symbol FROMSYM, defined in OBJECT, with version 126// VERSION. This handles all aliases of TOSYM. 127 128template<int size, bool big_endian> 129void 130Symbol_table::override(Sized_symbol<size>* tosym, 131 const elfcpp::Sym<size, big_endian>& fromsym, 132 unsigned int st_shndx, bool is_ordinary, 133 Object* object, const char* version) 134{ 135 tosym->override(fromsym, st_shndx, is_ordinary, object, version); 136 if (tosym->has_alias()) 137 { 138 Symbol* sym = this->weak_aliases_[tosym]; 139 gold_assert(sym != NULL); 140 Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym); 141 do 142 { 143 ssym->override(fromsym, st_shndx, is_ordinary, object, version); 144 sym = this->weak_aliases_[ssym]; 145 gold_assert(sym != NULL); 146 ssym = this->get_sized_symbol<size>(sym); 147 } 148 while (ssym != tosym); 149 } 150} 151 152// The resolve functions build a little code for each symbol. 153// Bit 0: 0 for global, 1 for weak. 154// Bit 1: 0 for regular object, 1 for shared object 155// Bits 2-3: 0 for normal, 1 for undefined, 2 for common 156// This gives us values from 0 to 11. 157 158static const int global_or_weak_shift = 0; 159static const unsigned int global_flag = 0 << global_or_weak_shift; 160static const unsigned int weak_flag = 1 << global_or_weak_shift; 161 162static const int regular_or_dynamic_shift = 1; 163static const unsigned int regular_flag = 0 << regular_or_dynamic_shift; 164static const unsigned int dynamic_flag = 1 << regular_or_dynamic_shift; 165 166static const int def_undef_or_common_shift = 2; 167static const unsigned int def_flag = 0 << def_undef_or_common_shift; 168static const unsigned int undef_flag = 1 << def_undef_or_common_shift; 169static const unsigned int common_flag = 2 << def_undef_or_common_shift; 170 171// This convenience function combines all the flags based on facts 172// about the symbol. 173 174static unsigned int 175symbol_to_bits(elfcpp::STB binding, bool is_dynamic, 176 unsigned int shndx, bool is_ordinary) 177{ 178 unsigned int bits; 179 180 switch (binding) 181 { 182 case elfcpp::STB_GLOBAL: 183 case elfcpp::STB_GNU_UNIQUE: 184 bits = global_flag; 185 break; 186 187 case elfcpp::STB_WEAK: 188 bits = weak_flag; 189 break; 190 191 case elfcpp::STB_LOCAL: 192 // We should only see externally visible symbols in the symbol 193 // table. 194 gold_error(_("invalid STB_LOCAL symbol in external symbols")); 195 bits = global_flag; 196 break; 197 198 default: 199 // Any target which wants to handle STB_LOOS, etc., needs to 200 // define a resolve method. 201 gold_error(_("unsupported symbol binding %d"), static_cast<int>(binding)); 202 bits = global_flag; 203 } 204 205 if (is_dynamic) 206 bits |= dynamic_flag; 207 else 208 bits |= regular_flag; 209 210 switch (shndx) 211 { 212 case elfcpp::SHN_UNDEF: 213 bits |= undef_flag; 214 break; 215 216 case elfcpp::SHN_COMMON: 217 if (!is_ordinary) 218 bits |= common_flag; 219 break; 220 221 default: 222 if (!is_ordinary && Symbol::is_common_shndx(shndx)) 223 bits |= common_flag; 224 else 225 bits |= def_flag; 226 break; 227 } 228 229 return bits; 230} 231 232// Resolve a symbol. This is called the second and subsequent times 233// we see a symbol. TO is the pre-existing symbol. ST_SHNDX is the 234// section index for SYM, possibly adjusted for many sections. 235// IS_ORDINARY is whether ST_SHNDX is a normal section index rather 236// than a special code. ORIG_ST_SHNDX is the original section index, 237// before any munging because of discarded sections, except that all 238// non-ordinary section indexes are mapped to SHN_UNDEF. VERSION is 239// the version of SYM. 240 241template<int size, bool big_endian> 242void 243Symbol_table::resolve(Sized_symbol<size>* to, 244 const elfcpp::Sym<size, big_endian>& sym, 245 unsigned int st_shndx, bool is_ordinary, 246 unsigned int orig_st_shndx, 247 Object* object, const char* version, 248 bool is_default_version) 249{ 250 // It's possible for a symbol to be defined in an object file 251 // using .symver to give it a version, and for there to also be 252 // a linker script giving that symbol the same version. We 253 // don't want to give a multiple-definition error for this 254 // harmless redefinition. 255 bool to_is_ordinary; 256 if (to->source() == Symbol::FROM_OBJECT 257 && to->object() == object 258 && is_ordinary 259 && to->is_defined() 260 && to->shndx(&to_is_ordinary) == st_shndx 261 && to_is_ordinary 262 && to->value() == sym.get_st_value()) 263 return; 264 265 if (parameters->target().has_resolve()) 266 { 267 Sized_target<size, big_endian>* sized_target; 268 sized_target = parameters->sized_target<size, big_endian>(); 269 sized_target->resolve(to, sym, object, version); 270 return; 271 } 272 273 if (!object->is_dynamic()) 274 { 275 if (sym.get_st_type() == elfcpp::STT_COMMON 276 && (is_ordinary || !Symbol::is_common_shndx(st_shndx))) 277 { 278 gold_warning(_("STT_COMMON symbol '%s' in %s " 279 "is not in a common section"), 280 to->demangled_name().c_str(), 281 to->object()->name().c_str()); 282 return; 283 } 284 // Record that we've seen this symbol in a regular object. 285 to->set_in_reg(); 286 } 287 else if (st_shndx == elfcpp::SHN_UNDEF 288 && (to->visibility() == elfcpp::STV_HIDDEN 289 || to->visibility() == elfcpp::STV_INTERNAL)) 290 { 291 // The symbol is hidden, so a reference from a shared object 292 // cannot bind to it. We tried issuing a warning in this case, 293 // but that produces false positives when the symbol is 294 // actually resolved in a different shared object (PR 15574). 295 return; 296 } 297 else 298 { 299 // Record that we've seen this symbol in a dynamic object. 300 to->set_in_dyn(); 301 } 302 303 // Record if we've seen this symbol in a real ELF object (i.e., the 304 // symbol is referenced from outside the world known to the plugin). 305 if (object->pluginobj() == NULL && !object->is_dynamic()) 306 to->set_in_real_elf(); 307 308 // If we're processing replacement files, allow new symbols to override 309 // the placeholders from the plugin objects. 310 // Treat common symbols specially since it is possible that an ELF 311 // file increased the size of the alignment. 312 if (to->source() == Symbol::FROM_OBJECT) 313 { 314 Pluginobj* obj = to->object()->pluginobj(); 315 if (obj != NULL 316 && parameters->options().plugins()->in_replacement_phase()) 317 { 318 bool adjust_common = false; 319 typename Sized_symbol<size>::Size_type tosize = 0; 320 typename Sized_symbol<size>::Value_type tovalue = 0; 321 if (to->is_common() 322 && !is_ordinary && Symbol::is_common_shndx(st_shndx)) 323 { 324 adjust_common = true; 325 tosize = to->symsize(); 326 tovalue = to->value(); 327 } 328 this->override(to, sym, st_shndx, is_ordinary, object, version); 329 if (adjust_common) 330 { 331 if (tosize > to->symsize()) 332 to->set_symsize(tosize); 333 if (tovalue > to->value()) 334 to->set_value(tovalue); 335 } 336 return; 337 } 338 } 339 340 // A new weak undefined reference, merging with an old weak 341 // reference, could be a One Definition Rule (ODR) violation -- 342 // especially if the types or sizes of the references differ. We'll 343 // store such pairs and look them up later to make sure they 344 // actually refer to the same lines of code. We also check 345 // combinations of weak and strong, which might occur if one case is 346 // inline and the other is not. (Note: not all ODR violations can 347 // be found this way, and not everything this finds is an ODR 348 // violation. But it's helpful to warn about.) 349 if (parameters->options().detect_odr_violations() 350 && (sym.get_st_bind() == elfcpp::STB_WEAK 351 || to->binding() == elfcpp::STB_WEAK) 352 && orig_st_shndx != elfcpp::SHN_UNDEF 353 && to->shndx(&to_is_ordinary) != elfcpp::SHN_UNDEF 354 && to_is_ordinary 355 && sym.get_st_size() != 0 // Ignore weird 0-sized symbols. 356 && to->symsize() != 0 357 && (sym.get_st_type() != to->type() 358 || sym.get_st_size() != to->symsize()) 359 // C does not have a concept of ODR, so we only need to do this 360 // on C++ symbols. These have (mangled) names starting with _Z. 361 && to->name()[0] == '_' && to->name()[1] == 'Z') 362 { 363 Symbol_location fromloc 364 = { object, orig_st_shndx, static_cast<off_t>(sym.get_st_value()) }; 365 Symbol_location toloc = { to->object(), to->shndx(&to_is_ordinary), 366 static_cast<off_t>(to->value()) }; 367 this->candidate_odr_violations_[to->name()].insert(fromloc); 368 this->candidate_odr_violations_[to->name()].insert(toloc); 369 } 370 371 // Plugins don't provide a symbol type, so adopt the existing type 372 // if the FROM symbol is from a plugin. 373 elfcpp::STT fromtype = (object->pluginobj() != NULL 374 ? to->type() 375 : sym.get_st_type()); 376 unsigned int frombits = symbol_to_bits(sym.get_st_bind(), 377 object->is_dynamic(), 378 st_shndx, is_ordinary); 379 380 bool adjust_common_sizes; 381 bool adjust_dyndef; 382 typename Sized_symbol<size>::Size_type tosize = to->symsize(); 383 if (Symbol_table::should_override(to, frombits, fromtype, OBJECT, 384 object, &adjust_common_sizes, 385 &adjust_dyndef, is_default_version)) 386 { 387 elfcpp::STB tobinding = to->binding(); 388 typename Sized_symbol<size>::Value_type tovalue = to->value(); 389 this->override(to, sym, st_shndx, is_ordinary, object, version); 390 if (adjust_common_sizes) 391 { 392 if (tosize > to->symsize()) 393 to->set_symsize(tosize); 394 if (tovalue > to->value()) 395 to->set_value(tovalue); 396 } 397 if (adjust_dyndef) 398 { 399 // We are overriding an UNDEF or WEAK UNDEF with a DYN DEF. 400 // Remember which kind of UNDEF it was for future reference. 401 to->set_undef_binding(tobinding); 402 } 403 } 404 else 405 { 406 if (adjust_common_sizes) 407 { 408 if (sym.get_st_size() > tosize) 409 to->set_symsize(sym.get_st_size()); 410 if (sym.get_st_value() > to->value()) 411 to->set_value(sym.get_st_value()); 412 } 413 if (adjust_dyndef) 414 { 415 // We are keeping a DYN DEF after seeing an UNDEF or WEAK UNDEF. 416 // Remember which kind of UNDEF it was. 417 to->set_undef_binding(sym.get_st_bind()); 418 } 419 // The ELF ABI says that even for a reference to a symbol we 420 // merge the visibility. 421 to->override_visibility(sym.get_st_visibility()); 422 } 423 424 if (adjust_common_sizes && parameters->options().warn_common()) 425 { 426 if (tosize > sym.get_st_size()) 427 Symbol_table::report_resolve_problem(false, 428 _("common of '%s' overriding " 429 "smaller common"), 430 to, OBJECT, object); 431 else if (tosize < sym.get_st_size()) 432 Symbol_table::report_resolve_problem(false, 433 _("common of '%s' overidden by " 434 "larger common"), 435 to, OBJECT, object); 436 else 437 Symbol_table::report_resolve_problem(false, 438 _("multiple common of '%s'"), 439 to, OBJECT, object); 440 } 441} 442 443// Handle the core of symbol resolution. This is called with the 444// existing symbol, TO, and a bitflag describing the new symbol. This 445// returns true if we should override the existing symbol with the new 446// one, and returns false otherwise. It sets *ADJUST_COMMON_SIZES to 447// true if we should set the symbol size to the maximum of the TO and 448// FROM sizes. It handles error conditions. 449 450bool 451Symbol_table::should_override(const Symbol* to, unsigned int frombits, 452 elfcpp::STT fromtype, Defined defined, 453 Object* object, bool* adjust_common_sizes, 454 bool* adjust_dyndef, bool is_default_version) 455{ 456 *adjust_common_sizes = false; 457 *adjust_dyndef = false; 458 459 unsigned int tobits; 460 if (to->source() == Symbol::IS_UNDEFINED) 461 tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_UNDEF, true); 462 else if (to->source() != Symbol::FROM_OBJECT) 463 tobits = symbol_to_bits(to->binding(), false, elfcpp::SHN_ABS, false); 464 else 465 { 466 bool is_ordinary; 467 unsigned int shndx = to->shndx(&is_ordinary); 468 tobits = symbol_to_bits(to->binding(), 469 to->object()->is_dynamic(), 470 shndx, 471 is_ordinary); 472 } 473 474 if ((to->type() == elfcpp::STT_TLS) ^ (fromtype == elfcpp::STT_TLS) 475 && !to->is_placeholder()) 476 Symbol_table::report_resolve_problem(true, 477 _("symbol '%s' used as both __thread " 478 "and non-__thread"), 479 to, defined, object); 480 481 // We use a giant switch table for symbol resolution. This code is 482 // unwieldy, but: 1) it is efficient; 2) we definitely handle all 483 // cases; 3) it is easy to change the handling of a particular case. 484 // The alternative would be a series of conditionals, but it is easy 485 // to get the ordering wrong. This could also be done as a table, 486 // but that is no easier to understand than this large switch 487 // statement. 488 489 // These are the values generated by the bit codes. 490 enum 491 { 492 DEF = global_flag | regular_flag | def_flag, 493 WEAK_DEF = weak_flag | regular_flag | def_flag, 494 DYN_DEF = global_flag | dynamic_flag | def_flag, 495 DYN_WEAK_DEF = weak_flag | dynamic_flag | def_flag, 496 UNDEF = global_flag | regular_flag | undef_flag, 497 WEAK_UNDEF = weak_flag | regular_flag | undef_flag, 498 DYN_UNDEF = global_flag | dynamic_flag | undef_flag, 499 DYN_WEAK_UNDEF = weak_flag | dynamic_flag | undef_flag, 500 COMMON = global_flag | regular_flag | common_flag, 501 WEAK_COMMON = weak_flag | regular_flag | common_flag, 502 DYN_COMMON = global_flag | dynamic_flag | common_flag, 503 DYN_WEAK_COMMON = weak_flag | dynamic_flag | common_flag 504 }; 505 506 switch (tobits * 16 + frombits) 507 { 508 case DEF * 16 + DEF: 509 // Two definitions of the same symbol. 510 511 // If either symbol is defined by an object included using 512 // --just-symbols, then don't warn. This is for compatibility 513 // with the GNU linker. FIXME: This is a hack. 514 if ((to->source() == Symbol::FROM_OBJECT && to->object()->just_symbols()) 515 || (object != NULL && object->just_symbols())) 516 return false; 517 518 if (!parameters->options().muldefs()) 519 Symbol_table::report_resolve_problem(true, 520 _("multiple definition of '%s'"), 521 to, defined, object); 522 return false; 523 524 case WEAK_DEF * 16 + DEF: 525 // We've seen a weak definition, and now we see a strong 526 // definition. In the original SVR4 linker, this was treated as 527 // a multiple definition error. In the Solaris linker and the 528 // GNU linker, a weak definition followed by a regular 529 // definition causes the weak definition to be overridden. We 530 // are currently compatible with the GNU linker. In the future 531 // we should add a target specific option to change this. 532 // FIXME. 533 return true; 534 535 case DYN_DEF * 16 + DEF: 536 case DYN_WEAK_DEF * 16 + DEF: 537 // We've seen a definition in a dynamic object, and now we see a 538 // definition in a regular object. The definition in the 539 // regular object overrides the definition in the dynamic 540 // object. 541 return true; 542 543 case UNDEF * 16 + DEF: 544 case WEAK_UNDEF * 16 + DEF: 545 case DYN_UNDEF * 16 + DEF: 546 case DYN_WEAK_UNDEF * 16 + DEF: 547 // We've seen an undefined reference, and now we see a 548 // definition. We use the definition. 549 return true; 550 551 case COMMON * 16 + DEF: 552 case WEAK_COMMON * 16 + DEF: 553 case DYN_COMMON * 16 + DEF: 554 case DYN_WEAK_COMMON * 16 + DEF: 555 // We've seen a common symbol and now we see a definition. The 556 // definition overrides. 557 if (parameters->options().warn_common()) 558 Symbol_table::report_resolve_problem(false, 559 _("definition of '%s' overriding " 560 "common"), 561 to, defined, object); 562 return true; 563 564 case DEF * 16 + WEAK_DEF: 565 case WEAK_DEF * 16 + WEAK_DEF: 566 // We've seen a definition and now we see a weak definition. We 567 // ignore the new weak definition. 568 return false; 569 570 case DYN_DEF * 16 + WEAK_DEF: 571 case DYN_WEAK_DEF * 16 + WEAK_DEF: 572 // We've seen a dynamic definition and now we see a regular weak 573 // definition. The regular weak definition overrides. 574 return true; 575 576 case UNDEF * 16 + WEAK_DEF: 577 case WEAK_UNDEF * 16 + WEAK_DEF: 578 case DYN_UNDEF * 16 + WEAK_DEF: 579 case DYN_WEAK_UNDEF * 16 + WEAK_DEF: 580 // A weak definition of a currently undefined symbol. 581 return true; 582 583 case COMMON * 16 + WEAK_DEF: 584 case WEAK_COMMON * 16 + WEAK_DEF: 585 // A weak definition does not override a common definition. 586 return false; 587 588 case DYN_COMMON * 16 + WEAK_DEF: 589 case DYN_WEAK_COMMON * 16 + WEAK_DEF: 590 // A weak definition does override a definition in a dynamic 591 // object. 592 if (parameters->options().warn_common()) 593 Symbol_table::report_resolve_problem(false, 594 _("definition of '%s' overriding " 595 "dynamic common definition"), 596 to, defined, object); 597 return true; 598 599 case DEF * 16 + DYN_DEF: 600 case WEAK_DEF * 16 + DYN_DEF: 601 // Ignore a dynamic definition if we already have a definition. 602 return false; 603 604 case DYN_DEF * 16 + DYN_DEF: 605 case DYN_WEAK_DEF * 16 + DYN_DEF: 606 // Ignore a dynamic definition if we already have a definition, 607 // unless the existing definition is an unversioned definition 608 // in the same dynamic object, and the new definition is a 609 // default version. 610 if (to->object() == object 611 && to->version() == NULL 612 && is_default_version) 613 return true; 614 return false; 615 616 case UNDEF * 16 + DYN_DEF: 617 case DYN_UNDEF * 16 + DYN_DEF: 618 case DYN_WEAK_UNDEF * 16 + DYN_DEF: 619 // Use a dynamic definition if we have a reference. 620 return true; 621 622 case WEAK_UNDEF * 16 + DYN_DEF: 623 // When overriding a weak undef by a dynamic definition, 624 // we need to remember that the original undef was weak. 625 *adjust_dyndef = true; 626 return true; 627 628 case COMMON * 16 + DYN_DEF: 629 case WEAK_COMMON * 16 + DYN_DEF: 630 case DYN_COMMON * 16 + DYN_DEF: 631 case DYN_WEAK_COMMON * 16 + DYN_DEF: 632 // Ignore a dynamic definition if we already have a common 633 // definition. 634 return false; 635 636 case DEF * 16 + DYN_WEAK_DEF: 637 case WEAK_DEF * 16 + DYN_WEAK_DEF: 638 case DYN_DEF * 16 + DYN_WEAK_DEF: 639 case DYN_WEAK_DEF * 16 + DYN_WEAK_DEF: 640 // Ignore a weak dynamic definition if we already have a 641 // definition. 642 return false; 643 644 case UNDEF * 16 + DYN_WEAK_DEF: 645 // When overriding an undef by a dynamic weak definition, 646 // we need to remember that the original undef was not weak. 647 *adjust_dyndef = true; 648 return true; 649 650 case DYN_UNDEF * 16 + DYN_WEAK_DEF: 651 case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF: 652 // Use a weak dynamic definition if we have a reference. 653 return true; 654 655 case WEAK_UNDEF * 16 + DYN_WEAK_DEF: 656 // When overriding a weak undef by a dynamic definition, 657 // we need to remember that the original undef was weak. 658 *adjust_dyndef = true; 659 return true; 660 661 case COMMON * 16 + DYN_WEAK_DEF: 662 case WEAK_COMMON * 16 + DYN_WEAK_DEF: 663 case DYN_COMMON * 16 + DYN_WEAK_DEF: 664 case DYN_WEAK_COMMON * 16 + DYN_WEAK_DEF: 665 // Ignore a weak dynamic definition if we already have a common 666 // definition. 667 return false; 668 669 case DEF * 16 + UNDEF: 670 case WEAK_DEF * 16 + UNDEF: 671 case UNDEF * 16 + UNDEF: 672 // A new undefined reference tells us nothing. 673 return false; 674 675 case DYN_DEF * 16 + UNDEF: 676 case DYN_WEAK_DEF * 16 + UNDEF: 677 // For a dynamic def, we need to remember which kind of undef we see. 678 *adjust_dyndef = true; 679 return false; 680 681 case WEAK_UNDEF * 16 + UNDEF: 682 case DYN_UNDEF * 16 + UNDEF: 683 case DYN_WEAK_UNDEF * 16 + UNDEF: 684 // A strong undef overrides a dynamic or weak undef. 685 return true; 686 687 case COMMON * 16 + UNDEF: 688 case WEAK_COMMON * 16 + UNDEF: 689 case DYN_COMMON * 16 + UNDEF: 690 case DYN_WEAK_COMMON * 16 + UNDEF: 691 // A new undefined reference tells us nothing. 692 return false; 693 694 case DEF * 16 + WEAK_UNDEF: 695 case WEAK_DEF * 16 + WEAK_UNDEF: 696 case UNDEF * 16 + WEAK_UNDEF: 697 case WEAK_UNDEF * 16 + WEAK_UNDEF: 698 case DYN_UNDEF * 16 + WEAK_UNDEF: 699 case COMMON * 16 + WEAK_UNDEF: 700 case WEAK_COMMON * 16 + WEAK_UNDEF: 701 case DYN_COMMON * 16 + WEAK_UNDEF: 702 case DYN_WEAK_COMMON * 16 + WEAK_UNDEF: 703 // A new weak undefined reference tells us nothing unless the 704 // exisiting symbol is a dynamic weak reference. 705 return false; 706 707 case DYN_WEAK_UNDEF * 16 + WEAK_UNDEF: 708 // A new weak reference overrides an existing dynamic weak reference. 709 // This is necessary because a dynamic weak reference remembers 710 // the old binding, which may not be weak. If we keeps the existing 711 // dynamic weak reference, the weakness may be dropped in the output. 712 return true; 713 714 case DYN_DEF * 16 + WEAK_UNDEF: 715 case DYN_WEAK_DEF * 16 + WEAK_UNDEF: 716 // For a dynamic def, we need to remember which kind of undef we see. 717 *adjust_dyndef = true; 718 return false; 719 720 case DEF * 16 + DYN_UNDEF: 721 case WEAK_DEF * 16 + DYN_UNDEF: 722 case DYN_DEF * 16 + DYN_UNDEF: 723 case DYN_WEAK_DEF * 16 + DYN_UNDEF: 724 case UNDEF * 16 + DYN_UNDEF: 725 case WEAK_UNDEF * 16 + DYN_UNDEF: 726 case DYN_UNDEF * 16 + DYN_UNDEF: 727 case DYN_WEAK_UNDEF * 16 + DYN_UNDEF: 728 case COMMON * 16 + DYN_UNDEF: 729 case WEAK_COMMON * 16 + DYN_UNDEF: 730 case DYN_COMMON * 16 + DYN_UNDEF: 731 case DYN_WEAK_COMMON * 16 + DYN_UNDEF: 732 // A new dynamic undefined reference tells us nothing. 733 return false; 734 735 case DEF * 16 + DYN_WEAK_UNDEF: 736 case WEAK_DEF * 16 + DYN_WEAK_UNDEF: 737 case DYN_DEF * 16 + DYN_WEAK_UNDEF: 738 case DYN_WEAK_DEF * 16 + DYN_WEAK_UNDEF: 739 case UNDEF * 16 + DYN_WEAK_UNDEF: 740 case WEAK_UNDEF * 16 + DYN_WEAK_UNDEF: 741 case DYN_UNDEF * 16 + DYN_WEAK_UNDEF: 742 case DYN_WEAK_UNDEF * 16 + DYN_WEAK_UNDEF: 743 case COMMON * 16 + DYN_WEAK_UNDEF: 744 case WEAK_COMMON * 16 + DYN_WEAK_UNDEF: 745 case DYN_COMMON * 16 + DYN_WEAK_UNDEF: 746 case DYN_WEAK_COMMON * 16 + DYN_WEAK_UNDEF: 747 // A new weak dynamic undefined reference tells us nothing. 748 return false; 749 750 case DEF * 16 + COMMON: 751 // A common symbol does not override a definition. 752 if (parameters->options().warn_common()) 753 Symbol_table::report_resolve_problem(false, 754 _("common '%s' overridden by " 755 "previous definition"), 756 to, defined, object); 757 return false; 758 759 case WEAK_DEF * 16 + COMMON: 760 case DYN_DEF * 16 + COMMON: 761 case DYN_WEAK_DEF * 16 + COMMON: 762 // A common symbol does override a weak definition or a dynamic 763 // definition. 764 return true; 765 766 case UNDEF * 16 + COMMON: 767 case WEAK_UNDEF * 16 + COMMON: 768 case DYN_UNDEF * 16 + COMMON: 769 case DYN_WEAK_UNDEF * 16 + COMMON: 770 // A common symbol is a definition for a reference. 771 return true; 772 773 case COMMON * 16 + COMMON: 774 // Set the size to the maximum. 775 *adjust_common_sizes = true; 776 return false; 777 778 case WEAK_COMMON * 16 + COMMON: 779 // I'm not sure just what a weak common symbol means, but 780 // presumably it can be overridden by a regular common symbol. 781 return true; 782 783 case DYN_COMMON * 16 + COMMON: 784 case DYN_WEAK_COMMON * 16 + COMMON: 785 // Use the real common symbol, but adjust the size if necessary. 786 *adjust_common_sizes = true; 787 return true; 788 789 case DEF * 16 + WEAK_COMMON: 790 case WEAK_DEF * 16 + WEAK_COMMON: 791 case DYN_DEF * 16 + WEAK_COMMON: 792 case DYN_WEAK_DEF * 16 + WEAK_COMMON: 793 // Whatever a weak common symbol is, it won't override a 794 // definition. 795 return false; 796 797 case UNDEF * 16 + WEAK_COMMON: 798 case WEAK_UNDEF * 16 + WEAK_COMMON: 799 case DYN_UNDEF * 16 + WEAK_COMMON: 800 case DYN_WEAK_UNDEF * 16 + WEAK_COMMON: 801 // A weak common symbol is better than an undefined symbol. 802 return true; 803 804 case COMMON * 16 + WEAK_COMMON: 805 case WEAK_COMMON * 16 + WEAK_COMMON: 806 case DYN_COMMON * 16 + WEAK_COMMON: 807 case DYN_WEAK_COMMON * 16 + WEAK_COMMON: 808 // Ignore a weak common symbol in the presence of a real common 809 // symbol. 810 return false; 811 812 case DEF * 16 + DYN_COMMON: 813 case WEAK_DEF * 16 + DYN_COMMON: 814 case DYN_DEF * 16 + DYN_COMMON: 815 case DYN_WEAK_DEF * 16 + DYN_COMMON: 816 // Ignore a dynamic common symbol in the presence of a 817 // definition. 818 return false; 819 820 case UNDEF * 16 + DYN_COMMON: 821 case WEAK_UNDEF * 16 + DYN_COMMON: 822 case DYN_UNDEF * 16 + DYN_COMMON: 823 case DYN_WEAK_UNDEF * 16 + DYN_COMMON: 824 // A dynamic common symbol is a definition of sorts. 825 return true; 826 827 case COMMON * 16 + DYN_COMMON: 828 case WEAK_COMMON * 16 + DYN_COMMON: 829 case DYN_COMMON * 16 + DYN_COMMON: 830 case DYN_WEAK_COMMON * 16 + DYN_COMMON: 831 // Set the size to the maximum. 832 *adjust_common_sizes = true; 833 return false; 834 835 case DEF * 16 + DYN_WEAK_COMMON: 836 case WEAK_DEF * 16 + DYN_WEAK_COMMON: 837 case DYN_DEF * 16 + DYN_WEAK_COMMON: 838 case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON: 839 // A common symbol is ignored in the face of a definition. 840 return false; 841 842 case UNDEF * 16 + DYN_WEAK_COMMON: 843 case WEAK_UNDEF * 16 + DYN_WEAK_COMMON: 844 case DYN_UNDEF * 16 + DYN_WEAK_COMMON: 845 case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON: 846 // I guess a weak common symbol is better than a definition. 847 return true; 848 849 case COMMON * 16 + DYN_WEAK_COMMON: 850 case WEAK_COMMON * 16 + DYN_WEAK_COMMON: 851 case DYN_COMMON * 16 + DYN_WEAK_COMMON: 852 case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON: 853 // Set the size to the maximum. 854 *adjust_common_sizes = true; 855 return false; 856 857 default: 858 gold_unreachable(); 859 } 860} 861 862// Issue an error or warning due to symbol resolution. IS_ERROR 863// indicates an error rather than a warning. MSG is the error 864// message; it is expected to have a %s for the symbol name. TO is 865// the existing symbol. DEFINED/OBJECT is where the new symbol was 866// found. 867 868// FIXME: We should have better location information here. When the 869// symbol is defined, we should be able to pull the location from the 870// debug info if there is any. 871 872void 873Symbol_table::report_resolve_problem(bool is_error, const char* msg, 874 const Symbol* to, Defined defined, 875 Object* object) 876{ 877 std::string demangled(to->demangled_name()); 878 size_t len = strlen(msg) + demangled.length() + 10; 879 char* buf = new char[len]; 880 snprintf(buf, len, msg, demangled.c_str()); 881 882 const char* objname; 883 switch (defined) 884 { 885 case OBJECT: 886 objname = object->name().c_str(); 887 break; 888 case COPY: 889 objname = _("COPY reloc"); 890 break; 891 case DEFSYM: 892 case UNDEFINED: 893 objname = _("command line"); 894 break; 895 case SCRIPT: 896 objname = _("linker script"); 897 break; 898 case PREDEFINED: 899 case INCREMENTAL_BASE: 900 objname = _("linker defined"); 901 break; 902 default: 903 gold_unreachable(); 904 } 905 906 if (is_error) 907 gold_error("%s: %s", objname, buf); 908 else 909 gold_warning("%s: %s", objname, buf); 910 911 delete[] buf; 912 913 if (to->source() == Symbol::FROM_OBJECT) 914 objname = to->object()->name().c_str(); 915 else 916 objname = _("command line"); 917 gold_info("%s: %s: previous definition here", program_name, objname); 918} 919 920// A special case of should_override which is only called for a strong 921// defined symbol from a regular object file. This is used when 922// defining special symbols. 923 924bool 925Symbol_table::should_override_with_special(const Symbol* to, 926 elfcpp::STT fromtype, 927 Defined defined) 928{ 929 bool adjust_common_sizes; 930 bool adjust_dyn_def; 931 unsigned int frombits = global_flag | regular_flag | def_flag; 932 bool ret = Symbol_table::should_override(to, frombits, fromtype, defined, 933 NULL, &adjust_common_sizes, 934 &adjust_dyn_def, false); 935 gold_assert(!adjust_common_sizes && !adjust_dyn_def); 936 return ret; 937} 938 939// Override symbol base with a special symbol. 940 941void 942Symbol::override_base_with_special(const Symbol* from) 943{ 944 bool same_name = this->name_ == from->name_; 945 gold_assert(same_name || this->has_alias()); 946 947 // If we are overriding an undef, remember the original binding. 948 if (this->is_undefined()) 949 this->set_undef_binding(this->binding_); 950 951 this->source_ = from->source_; 952 switch (from->source_) 953 { 954 case FROM_OBJECT: 955 this->u_.from_object = from->u_.from_object; 956 break; 957 case IN_OUTPUT_DATA: 958 this->u_.in_output_data = from->u_.in_output_data; 959 break; 960 case IN_OUTPUT_SEGMENT: 961 this->u_.in_output_segment = from->u_.in_output_segment; 962 break; 963 case IS_CONSTANT: 964 case IS_UNDEFINED: 965 break; 966 default: 967 gold_unreachable(); 968 break; 969 } 970 971 if (same_name) 972 { 973 // When overriding a versioned symbol with a special symbol, we 974 // may be changing the version. This will happen if we see a 975 // special symbol such as "_end" defined in a shared object with 976 // one version (from a version script), but we want to define it 977 // here with a different version (from a different version 978 // script). 979 this->version_ = from->version_; 980 } 981 this->type_ = from->type_; 982 this->binding_ = from->binding_; 983 this->override_visibility(from->visibility_); 984 this->nonvis_ = from->nonvis_; 985 986 // Special symbols are always considered to be regular symbols. 987 this->in_reg_ = true; 988 989 if (from->needs_dynsym_entry_) 990 this->needs_dynsym_entry_ = true; 991 if (from->needs_dynsym_value_) 992 this->needs_dynsym_value_ = true; 993 994 this->is_predefined_ = from->is_predefined_; 995 996 // We shouldn't see these flags. If we do, we need to handle them 997 // somehow. 998 gold_assert(!from->is_forwarder_); 999 gold_assert(!from->has_plt_offset()); 1000 gold_assert(!from->has_warning_); 1001 gold_assert(!from->is_copied_from_dynobj_); 1002 gold_assert(!from->is_forced_local_); 1003} 1004 1005// Override a symbol with a special symbol. 1006 1007template<int size> 1008void 1009Sized_symbol<size>::override_with_special(const Sized_symbol<size>* from) 1010{ 1011 this->override_base_with_special(from); 1012 this->value_ = from->value_; 1013 this->symsize_ = from->symsize_; 1014} 1015 1016// Override TOSYM with the special symbol FROMSYM. This handles all 1017// aliases of TOSYM. 1018 1019template<int size> 1020void 1021Symbol_table::override_with_special(Sized_symbol<size>* tosym, 1022 const Sized_symbol<size>* fromsym) 1023{ 1024 tosym->override_with_special(fromsym); 1025 if (tosym->has_alias()) 1026 { 1027 Symbol* sym = this->weak_aliases_[tosym]; 1028 gold_assert(sym != NULL); 1029 Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym); 1030 do 1031 { 1032 ssym->override_with_special(fromsym); 1033 sym = this->weak_aliases_[ssym]; 1034 gold_assert(sym != NULL); 1035 ssym = this->get_sized_symbol<size>(sym); 1036 } 1037 while (ssym != tosym); 1038 } 1039 if (tosym->binding() == elfcpp::STB_LOCAL 1040 || ((tosym->visibility() == elfcpp::STV_HIDDEN 1041 || tosym->visibility() == elfcpp::STV_INTERNAL) 1042 && (tosym->binding() == elfcpp::STB_GLOBAL 1043 || tosym->binding() == elfcpp::STB_GNU_UNIQUE 1044 || tosym->binding() == elfcpp::STB_WEAK) 1045 && !parameters->options().relocatable())) 1046 this->force_local(tosym); 1047} 1048 1049// Instantiate the templates we need. We could use the configure 1050// script to restrict this to only the ones needed for implemented 1051// targets. 1052 1053// We have to instantiate both big and little endian versions because 1054// these are used by other templates that depends on size only. 1055 1056#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 1057template 1058void 1059Symbol_table::resolve<32, false>( 1060 Sized_symbol<32>* to, 1061 const elfcpp::Sym<32, false>& sym, 1062 unsigned int st_shndx, 1063 bool is_ordinary, 1064 unsigned int orig_st_shndx, 1065 Object* object, 1066 const char* version, 1067 bool is_default_version); 1068 1069template 1070void 1071Symbol_table::resolve<32, true>( 1072 Sized_symbol<32>* to, 1073 const elfcpp::Sym<32, true>& sym, 1074 unsigned int st_shndx, 1075 bool is_ordinary, 1076 unsigned int orig_st_shndx, 1077 Object* object, 1078 const char* version, 1079 bool is_default_version); 1080#endif 1081 1082#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 1083template 1084void 1085Symbol_table::resolve<64, false>( 1086 Sized_symbol<64>* to, 1087 const elfcpp::Sym<64, false>& sym, 1088 unsigned int st_shndx, 1089 bool is_ordinary, 1090 unsigned int orig_st_shndx, 1091 Object* object, 1092 const char* version, 1093 bool is_default_version); 1094 1095template 1096void 1097Symbol_table::resolve<64, true>( 1098 Sized_symbol<64>* to, 1099 const elfcpp::Sym<64, true>& sym, 1100 unsigned int st_shndx, 1101 bool is_ordinary, 1102 unsigned int orig_st_shndx, 1103 Object* object, 1104 const char* version, 1105 bool is_default_version); 1106#endif 1107 1108#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) 1109template 1110void 1111Symbol_table::override_with_special<32>(Sized_symbol<32>*, 1112 const Sized_symbol<32>*); 1113#endif 1114 1115#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) 1116template 1117void 1118Symbol_table::override_with_special<64>(Sized_symbol<64>*, 1119 const Sized_symbol<64>*); 1120#endif 1121 1122} // End namespace gold. 1123