contrib/llvm-project/lld/ELF/Symbols.cpp

   1 //===- Symbols.cpp --------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Symbols.h"
  10 #include "InputFiles.h"
  11 #include "InputSection.h"
  12 #include "OutputSections.h"
  13 #include "SyntheticSections.h"
  14 #include "Target.h"
  15 #include "Writer.h"
  16 #include "lld/Common/ErrorHandler.h"
  17 #include "lld/Common/Strings.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/Support/FileSystem.h"
  20 #include "llvm/Support/Path.h"
  21 #include <cstring>
  22
  23 using namespace llvm;
  24 using namespace llvm::object;
  25 using namespace llvm::ELF;
  26 using namespace lld;
  27 using namespace lld::elf;
  28
  29 // Returns a symbol for an error message.
  30 static std::string demangle(StringRef symName) {
  31   if (elf::config->demangle)
  32     return demangleItanium(symName);
  33   return std::string(symName);
  34 }
  35
  36 std::string lld::toString(const elf::Symbol &sym) {
  37   StringRef name = sym.getName();
  38   std::string ret = demangle(name);
  39
  40   const char *suffix = sym.getVersionSuffix();
  41   if (*suffix == '@')
  42     ret += suffix;
  43   return ret;
  44 }
  45
  46 std::string lld::toELFString(const Archive::Symbol &b) {
  47   return demangle(b.getName());
  48 }
  49
  50 Defined *ElfSym::bss;
  51 Defined *ElfSym::etext1;
  52 Defined *ElfSym::etext2;
  53 Defined *ElfSym::edata1;
  54 Defined *ElfSym::edata2;
  55 Defined *ElfSym::end1;
  56 Defined *ElfSym::end2;
  57 Defined *ElfSym::globalOffsetTable;
  58 Defined *ElfSym::mipsGp;
  59 Defined *ElfSym::mipsGpDisp;
  60 Defined *ElfSym::mipsLocalGp;
  61 Defined *ElfSym::relaIpltStart;
  62 Defined *ElfSym::relaIpltEnd;
  63 Defined *ElfSym::riscvGlobalPointer;
  64 Defined *ElfSym::tlsModuleBase;
  65 DenseMap<const Symbol *, std::pair<const InputFile *, const InputFile *>>
  66     elf::backwardReferences;
  67
  68 static uint64_t getSymVA(const Symbol &sym, int64_t &addend) {
  69   switch (sym.kind()) {
  70   case Symbol::DefinedKind: {
  71     auto &d = cast<Defined>(sym);
  72     SectionBase *isec = d.section;
  73
  74     // This is an absolute symbol.
  75     if (!isec)
  76       return d.value;
  77
  78     assert(isec != &InputSection::discarded);
  79     isec = isec->repl;
  80
  81     uint64_t offset = d.value;
  82
  83     // An object in an SHF_MERGE section might be referenced via a
  84     // section symbol (as a hack for reducing the number of local
  85     // symbols).
  86     // Depending on the addend, the reference via a section symbol
  87     // refers to a different object in the merge section.
  88     // Since the objects in the merge section are not necessarily
  89     // contiguous in the output, the addend can thus affect the final
  90     // VA in a non-linear way.
  91     // To make this work, we incorporate the addend into the section
  92     // offset (and zero out the addend for later processing) so that
  93     // we find the right object in the section.
  94     if (d.isSection()) {
  95       offset += addend;
  96       addend = 0;
  97     }
  98
  99     // In the typical case, this is actually very simple and boils
 100     // down to adding together 3 numbers:
 101     // 1. The address of the output section.
 102     // 2. The offset of the input section within the output section.
 103     // 3. The offset within the input section (this addition happens
 104     //    inside InputSection::getOffset).
 105     //
 106     // If you understand the data structures involved with this next
 107     // line (and how they get built), then you have a pretty good
 108     // understanding of the linker.
 109     uint64_t va = isec->getVA(offset);
 110
 111     // MIPS relocatable files can mix regular and microMIPS code.
 112     // Linker needs to distinguish such code. To do so microMIPS
 113     // symbols has the `STO_MIPS_MICROMIPS` flag in the `st_other`
 114     // field. Unfortunately, the `MIPS::relocate()` method has
 115     // a symbol value only. To pass type of the symbol (regular/microMIPS)
 116     // to that routine as well as other places where we write
 117     // a symbol value as-is (.dynamic section, `Elf_Ehdr::e_entry`
 118     // field etc) do the same trick as compiler uses to mark microMIPS
 119     // for CPU - set the less-significant bit.
 120     if (config->emachine == EM_MIPS && isMicroMips() &&
 121         ((sym.stOther & STO_MIPS_MICROMIPS) || sym.needsPltAddr))
 122       va |= 1;
 123
 124     if (d.isTls() && !config->relocatable) {
 125       // Use the address of the TLS segment's first section rather than the
 126       // segment's address, because segment addresses aren't initialized until
 127       // after sections are finalized. (e.g. Measuring the size of .rela.dyn
 128       // for Android relocation packing requires knowing TLS symbol addresses
 129       // during section finalization.)
 130       if (!Out::tlsPhdr || !Out::tlsPhdr->firstSec)
 131         fatal(toString(d.file) +
 132               " has an STT_TLS symbol but doesn't have an SHF_TLS section");
 133       return va - Out::tlsPhdr->firstSec->addr;
 134     }
 135     return va;
 136   }
 137   case Symbol::SharedKind:
 138   case Symbol::UndefinedKind:
 139     return 0;
 140   case Symbol::LazyArchiveKind:
 141   case Symbol::LazyObjectKind:
 142     assert(sym.isUsedInRegularObj && "lazy symbol reached writer");
 143     return 0;
 144   case Symbol::CommonKind:
 145     llvm_unreachable("common symbol reached writer");
 146   case Symbol::PlaceholderKind:
 147     llvm_unreachable("placeholder symbol reached writer");
 148   }
 149   llvm_unreachable("invalid symbol kind");
 150 }
 151
 152 uint64_t Symbol::getVA(int64_t addend) const {
 153   uint64_t outVA = getSymVA(*this, addend);
 154   return outVA + addend;
 155 }
 156
 157 uint64_t Symbol::getGotVA() const {
 158   if (gotInIgot)
 159     return in.igotPlt->getVA() + getGotPltOffset();
 160   return in.got->getVA() + getGotOffset();
 161 }
 162
 163 uint64_t Symbol::getGotOffset() const { return gotIndex * config->wordsize; }
 164
 165 uint64_t Symbol::getGotPltVA() const {
 166   if (isInIplt)
 167     return in.igotPlt->getVA() + getGotPltOffset();
 168   return in.gotPlt->getVA() + getGotPltOffset();
 169 }
 170
 171 uint64_t Symbol::getGotPltOffset() const {
 172   if (isInIplt)
 173     return pltIndex * config->wordsize;
 174   return (pltIndex + target->gotPltHeaderEntriesNum) * config->wordsize;
 175 }
 176
 177 uint64_t Symbol::getPltVA() const {
 178   uint64_t outVA = isInIplt
 179                        ? in.iplt->getVA() + pltIndex * target->ipltEntrySize
 180                        : in.plt->getVA() + in.plt->headerSize +
 181                              pltIndex * target->pltEntrySize;
 182
 183   // While linking microMIPS code PLT code are always microMIPS
 184   // code. Set the less-significant bit to track that fact.
 185   // See detailed comment in the `getSymVA` function.
 186   if (config->emachine == EM_MIPS && isMicroMips())
 187     outVA |= 1;
 188   return outVA;
 189 }
 190
 191 uint64_t Symbol::getSize() const {
 192   if (const auto *dr = dyn_cast<Defined>(this))
 193     return dr->size;
 194   return cast<SharedSymbol>(this)->size;
 195 }
 196
 197 OutputSection *Symbol::getOutputSection() const {
 198   if (auto *s = dyn_cast<Defined>(this)) {
 199     if (auto *sec = s->section)
 200       return sec->repl->getOutputSection();
 201     return nullptr;
 202   }
 203   return nullptr;
 204 }
 205
 206 // If a symbol name contains '@', the characters after that is
 207 // a symbol version name. This function parses that.
 208 void Symbol::parseSymbolVersion() {
 209   StringRef s = getName();
 210   size_t pos = s.find('@');
 211   if (pos == 0 || pos == StringRef::npos)
 212     return;
 213   StringRef verstr = s.substr(pos + 1);
 214   if (verstr.empty())
 215     return;
 216
 217   // Truncate the symbol name so that it doesn't include the version string.
 218   nameSize = pos;
 219
 220   // If this is not in this DSO, it is not a definition.
 221   if (!isDefined())
 222     return;
 223
 224   // '@@' in a symbol name means the default version.
 225   // It is usually the most recent one.
 226   bool isDefault = (verstr[0] == '@');
 227   if (isDefault)
 228     verstr = verstr.substr(1);
 229
 230   for (const VersionDefinition &ver : namedVersionDefs()) {
 231     if (ver.name != verstr)
 232       continue;
 233
 234     if (isDefault)
 235       versionId = ver.id;
 236     else
 237       versionId = ver.id | VERSYM_HIDDEN;
 238     return;
 239   }
 240
 241   // It is an error if the specified version is not defined.
 242   // Usually version script is not provided when linking executable,
 243   // but we may still want to override a versioned symbol from DSO,
 244   // so we do not report error in this case. We also do not error
 245   // if the symbol has a local version as it won't be in the dynamic
 246   // symbol table.
 247   if (config->shared && versionId != VER_NDX_LOCAL)
 248     error(toString(file) + ": symbol " + s + " has undefined version " +
 249           verstr);
 250 }
 251
 252 void Symbol::fetch() const {
 253   if (auto *sym = dyn_cast<LazyArchive>(this)) {
 254     cast<ArchiveFile>(sym->file)->fetch(sym->sym);
 255     return;
 256   }
 257
 258   if (auto *sym = dyn_cast<LazyObject>(this)) {
 259     dyn_cast<LazyObjFile>(sym->file)->fetch();
 260     return;
 261   }
 262
 263   llvm_unreachable("Symbol::fetch() is called on a non-lazy symbol");
 264 }
 265
 266 MemoryBufferRef LazyArchive::getMemberBuffer() {
 267   Archive::Child c =
 268       CHECK(sym.getMember(),
 269             "could not get the member for symbol " + toELFString(sym));
 270
 271   return CHECK(c.getMemoryBufferRef(),
 272                "could not get the buffer for the member defining symbol " +
 273                    toELFString(sym));
 274 }
 275
 276 uint8_t Symbol::computeBinding() const {
 277   if (config->relocatable)
 278     return binding;
 279   if ((visibility != STV_DEFAULT && visibility != STV_PROTECTED) ||
 280       (versionId == VER_NDX_LOCAL && isDefined()))
 281     return STB_LOCAL;
 282   if (!config->gnuUnique && binding == STB_GNU_UNIQUE)
 283     return STB_GLOBAL;
 284   return binding;
 285 }
 286
 287 bool Symbol::includeInDynsym() const {
 288   if (!config->hasDynSymTab)
 289     return false;
 290   if (computeBinding() == STB_LOCAL)
 291     return false;
 292   if (!isDefined() && !isCommon())
 293     // This should unconditionally return true, unfortunately glibc -static-pie
 294     // expects undefined weak symbols not to exist in .dynsym, e.g.
 295     // __pthread_mutex_lock reference in _dl_add_to_namespace_list,
 296     // __pthread_initialize_minimal reference in csu/libc-start.c.
 297     return !(config->noDynamicLinker && isUndefWeak());
 298
 299   return exportDynamic || inDynamicList;
 300 }
 301
 302 // Print out a log message for --trace-symbol.
 303 void elf::printTraceSymbol(const Symbol *sym) {
 304   std::string s;
 305   if (sym->isUndefined())
 306     s = ": reference to ";
 307   else if (sym->isLazy())
 308     s = ": lazy definition of ";
 309   else if (sym->isShared())
 310     s = ": shared definition of ";
 311   else if (sym->isCommon())
 312     s = ": common definition of ";
 313   else
 314     s = ": definition of ";
 315
 316   message(toString(sym->file) + s + sym->getName());
 317 }
 318
 319 void elf::maybeWarnUnorderableSymbol(const Symbol *sym) {
 320   if (!config->warnSymbolOrdering)
 321     return;
 322
 323   // If UnresolvedPolicy::Ignore is used, no "undefined symbol" error/warning
 324   // is emitted. It makes sense to not warn on undefined symbols.
 325   //
 326   // Note, ld.bfd --symbol-ordering-file= does not warn on undefined symbols,
 327   // but we don't have to be compatible here.
 328   if (sym->isUndefined() &&
 329       config->unresolvedSymbols == UnresolvedPolicy::Ignore)
 330     return;
 331
 332   const InputFile *file = sym->file;
 333   auto *d = dyn_cast<Defined>(sym);
 334
 335   auto report = [&](StringRef s) { warn(toString(file) + s + sym->getName()); };
 336
 337   if (sym->isUndefined())
 338     report(": unable to order undefined symbol: ");
 339   else if (sym->isShared())
 340     report(": unable to order shared symbol: ");
 341   else if (d && !d->section)
 342     report(": unable to order absolute symbol: ");
 343   else if (d && isa<OutputSection>(d->section))
 344     report(": unable to order synthetic symbol: ");
 345   else if (d && !d->section->repl->isLive())
 346     report(": unable to order discarded symbol: ");
 347 }
 348
 349 // Returns true if a symbol can be replaced at load-time by a symbol
 350 // with the same name defined in other ELF executable or DSO.
 351 bool elf::computeIsPreemptible(const Symbol &sym) {
 352   assert(!sym.isLocal());
 353
 354   // Only symbols with default visibility that appear in dynsym can be
 355   // preempted. Symbols with protected visibility cannot be preempted.
 356   if (!sym.includeInDynsym() || sym.visibility != STV_DEFAULT)
 357     return false;
 358
 359   // At this point copy relocations have not been created yet, so any
 360   // symbol that is not defined locally is preemptible.
 361   if (!sym.isDefined())
 362     return true;
 363
 364   if (!config->shared)
 365     return false;
 366
 367   // If -Bsymbolic or --dynamic-list is specified, or -Bsymbolic-functions is
 368   // specified and the symbol is STT_FUNC, the symbol is preemptible iff it is
 369   // in the dynamic list.
 370   if (config->symbolic || (config->bsymbolicFunctions && sym.isFunc()))
 371     return sym.inDynamicList;
 372   return true;
 373 }
 374
 375 void elf::reportBackrefs() {
 376   for (auto &it : backwardReferences) {
 377     const Symbol &sym = *it.first;
 378     std::string to = toString(it.second.second);
 379     // Some libraries have known problems and can cause noise. Filter them out
 380     // with --warn-backrefs-exclude=. to may look like *.o or *.a(*.o).
 381     bool exclude = false;
 382     for (const llvm::GlobPattern &pat : config->warnBackrefsExclude)
 383       if (pat.match(to)) {
 384         exclude = true;
 385         break;
 386       }
 387     if (!exclude)
 388       warn("backward reference detected: " + sym.getName() + " in " +
 389            toString(it.second.first) + " refers to " + to);
 390   }
 391 }
 392
 393 static uint8_t getMinVisibility(uint8_t va, uint8_t vb) {
 394   if (va == STV_DEFAULT)
 395     return vb;
 396   if (vb == STV_DEFAULT)
 397     return va;
 398   return std::min(va, vb);
 399 }
 400
 401 // Merge symbol properties.
 402 //
 403 // When we have many symbols of the same name, we choose one of them,
 404 // and that's the result of symbol resolution. However, symbols that
 405 // were not chosen still affect some symbol properties.
 406 void Symbol::mergeProperties(const Symbol &other) {
 407   if (other.exportDynamic)
 408     exportDynamic = true;
 409   if (other.isUsedInRegularObj)
 410     isUsedInRegularObj = true;
 411
 412   // DSO symbols do not affect visibility in the output.
 413   if (!other.isShared())
 414     visibility = getMinVisibility(visibility, other.visibility);
 415 }
 416
 417 void Symbol::resolve(const Symbol &other) {
 418   mergeProperties(other);
 419
 420   if (isPlaceholder()) {
 421     replace(other);
 422     return;
 423   }
 424
 425   switch (other.kind()) {
 426   case Symbol::UndefinedKind:
 427     resolveUndefined(cast<Undefined>(other));
 428     break;
 429   case Symbol::CommonKind:
 430     resolveCommon(cast<CommonSymbol>(other));
 431     break;
 432   case Symbol::DefinedKind:
 433     resolveDefined(cast<Defined>(other));
 434     break;
 435   case Symbol::LazyArchiveKind:
 436     resolveLazy(cast<LazyArchive>(other));
 437     break;
 438   case Symbol::LazyObjectKind:
 439     resolveLazy(cast<LazyObject>(other));
 440     break;
 441   case Symbol::SharedKind:
 442     resolveShared(cast<SharedSymbol>(other));
 443     break;
 444   case Symbol::PlaceholderKind:
 445     llvm_unreachable("bad symbol kind");
 446   }
 447 }
 448
 449 void Symbol::resolveUndefined(const Undefined &other) {
 450   // An undefined symbol with non default visibility must be satisfied
 451   // in the same DSO.
 452   //
 453   // If this is a non-weak defined symbol in a discarded section, override the
 454   // existing undefined symbol for better error message later.
 455   if ((isShared() && other.visibility != STV_DEFAULT) ||
 456       (isUndefined() && other.binding != STB_WEAK && other.discardedSecIdx)) {
 457     replace(other);
 458     return;
 459   }
 460
 461   if (traced)
 462     printTraceSymbol(&other);
 463
 464   if (isLazy()) {
 465     // An undefined weak will not fetch archive members. See comment on Lazy in
 466     // Symbols.h for the details.
 467     if (other.binding == STB_WEAK) {
 468       binding = STB_WEAK;
 469       type = other.type;
 470       return;
 471     }
 472
 473     // Do extra check for --warn-backrefs.
 474     //
 475     // --warn-backrefs is an option to prevent an undefined reference from
 476     // fetching an archive member written earlier in the command line. It can be
 477     // used to keep compatibility with GNU linkers to some degree.
 478     // I'll explain the feature and why you may find it useful in this comment.
 479     //
 480     // lld's symbol resolution semantics is more relaxed than traditional Unix
 481     // linkers. For example,
 482     //
 483     //   ld.lld foo.a bar.o
 484     //
 485     // succeeds even if bar.o contains an undefined symbol that has to be
 486     // resolved by some object file in foo.a. Traditional Unix linkers don't
 487     // allow this kind of backward reference, as they visit each file only once
 488     // from left to right in the command line while resolving all undefined
 489     // symbols at the moment of visiting.
 490     //
 491     // In the above case, since there's no undefined symbol when a linker visits
 492     // foo.a, no files are pulled out from foo.a, and because the linker forgets
 493     // about foo.a after visiting, it can't resolve undefined symbols in bar.o
 494     // that could have been resolved otherwise.
 495     //
 496     // That lld accepts more relaxed form means that (besides it'd make more
 497     // sense) you can accidentally write a command line or a build file that
 498     // works only with lld, even if you have a plan to distribute it to wider
 499     // users who may be using GNU linkers. With --warn-backrefs, you can detect
 500     // a library order that doesn't work with other Unix linkers.
 501     //
 502     // The option is also useful to detect cyclic dependencies between static
 503     // archives. Again, lld accepts
 504     //
 505     //   ld.lld foo.a bar.a
 506     //
 507     // even if foo.a and bar.a depend on each other. With --warn-backrefs, it is
 508     // handled as an error.
 509     //
 510     // Here is how the option works. We assign a group ID to each file. A file
 511     // with a smaller group ID can pull out object files from an archive file
 512     // with an equal or greater group ID. Otherwise, it is a reverse dependency
 513     // and an error.
 514     //
 515     // A file outside --{start,end}-group gets a fresh ID when instantiated. All
 516     // files within the same --{start,end}-group get the same group ID. E.g.
 517     //
 518     //   ld.lld A B --start-group C D --end-group E
 519     //
 520     // A forms group 0. B form group 1. C and D (including their member object
 521     // files) form group 2. E forms group 3. I think that you can see how this
 522     // group assignment rule simulates the traditional linker's semantics.
 523     bool backref = config->warnBackrefs && other.file &&
 524                    file->groupId < other.file->groupId;
 525     fetch();
 526
 527     // We don't report backward references to weak symbols as they can be
 528     // overridden later.
 529     //
 530     // A traditional linker does not error for -ldef1 -lref -ldef2 (linking
 531     // sandwich), where def2 may or may not be the same as def1. We don't want
 532     // to warn for this case, so dismiss the warning if we see a subsequent lazy
 533     // definition. this->file needs to be saved because in the case of LTO it
 534     // may be reset to nullptr or be replaced with a file named lto.tmp.
 535     if (backref && !isWeak())
 536       backwardReferences.try_emplace(this, std::make_pair(other.file, file));
 537     return;
 538   }
 539
 540   // Undefined symbols in a SharedFile do not change the binding.
 541   if (dyn_cast_or_null<SharedFile>(other.file))
 542     return;
 543
 544   if (isUndefined() || isShared()) {
 545     // The binding will be weak if there is at least one reference and all are
 546     // weak. The binding has one opportunity to change to weak: if the first
 547     // reference is weak.
 548     if (other.binding != STB_WEAK || !referenced)
 549       binding = other.binding;
 550   }
 551 }
 552
 553 // Using .symver foo,foo@@VER unfortunately creates two symbols: foo and
 554 // foo@@VER. We want to effectively ignore foo, so give precedence to
 555 // foo@@VER.
 556 // FIXME: If users can transition to using
 557 // .symver foo,foo@@@VER
 558 // we can delete this hack.
 559 static int compareVersion(StringRef a, StringRef b) {
 560   bool x = a.contains("@@");
 561   bool y = b.contains("@@");
 562   if (!x && y)
 563     return 1;
 564   if (x && !y)
 565     return -1;
 566   return 0;
 567 }
 568
 569 // Compare two symbols. Return 1 if the new symbol should win, -1 if
 570 // the new symbol should lose, or 0 if there is a conflict.
 571 int Symbol::compare(const Symbol *other) const {
 572   assert(other->isDefined() || other->isCommon());
 573
 574   if (!isDefined() && !isCommon())
 575     return 1;
 576
 577   if (int cmp = compareVersion(getName(), other->getName()))
 578     return cmp;
 579
 580   if (other->isWeak())
 581     return -1;
 582
 583   if (isWeak())
 584     return 1;
 585
 586   if (isCommon() && other->isCommon()) {
 587     if (config->warnCommon)
 588       warn("multiple common of " + getName());
 589     return 0;
 590   }
 591
 592   if (isCommon()) {
 593     if (config->warnCommon)
 594       warn("common " + getName() + " is overridden");
 595     return 1;
 596   }
 597
 598   if (other->isCommon()) {
 599     if (config->warnCommon)
 600       warn("common " + getName() + " is overridden");
 601     return -1;
 602   }
 603
 604   auto *oldSym = cast<Defined>(this);
 605   auto *newSym = cast<Defined>(other);
 606
 607   if (dyn_cast_or_null<BitcodeFile>(other->file))
 608     return 0;
 609
 610   if (!oldSym->section && !newSym->section && oldSym->value == newSym->value &&
 611       newSym->binding == STB_GLOBAL)
 612     return -1;
 613
 614   return 0;
 615 }
 616
 617 static void reportDuplicate(Symbol *sym, InputFile *newFile,
 618                             InputSectionBase *errSec, uint64_t errOffset) {
 619   if (config->allowMultipleDefinition)
 620     return;
 621
 622   Defined *d = cast<Defined>(sym);
 623   if (!d->section || !errSec) {
 624     error("duplicate symbol: " + toString(*sym) + "\n>>> defined in " +
 625           toString(sym->file) + "\n>>> defined in " + toString(newFile));
 626     return;
 627   }
 628
 629   // Construct and print an error message in the form of:
 630   //
 631   //   ld.lld: error: duplicate symbol: foo
 632   //   >>> defined at bar.c:30
 633   //   >>>            bar.o (/home/alice/src/bar.o)
 634   //   >>> defined at baz.c:563
 635   //   >>>            baz.o in archive libbaz.a
 636   auto *sec1 = cast<InputSectionBase>(d->section);
 637   std::string src1 = sec1->getSrcMsg(*sym, d->value);
 638   std::string obj1 = sec1->getObjMsg(d->value);
 639   std::string src2 = errSec->getSrcMsg(*sym, errOffset);
 640   std::string obj2 = errSec->getObjMsg(errOffset);
 641
 642   std::string msg = "duplicate symbol: " + toString(*sym) + "\n>>> defined at ";
 643   if (!src1.empty())
 644     msg += src1 + "\n>>>            ";
 645   msg += obj1 + "\n>>> defined at ";
 646   if (!src2.empty())
 647     msg += src2 + "\n>>>            ";
 648   msg += obj2;
 649   error(msg);
 650 }
 651
 652 void Symbol::resolveCommon(const CommonSymbol &other) {
 653   int cmp = compare(&other);
 654   if (cmp < 0)
 655     return;
 656
 657   if (cmp > 0) {
 658     if (auto *s = dyn_cast<SharedSymbol>(this)) {
 659       // Increase st_size if the shared symbol has a larger st_size. The shared
 660       // symbol may be created from common symbols. The fact that some object
 661       // files were linked into a shared object first should not change the
 662       // regular rule that picks the largest st_size.
 663       uint64_t size = s->size;
 664       replace(other);
 665       if (size > cast<CommonSymbol>(this)->size)
 666         cast<CommonSymbol>(this)->size = size;
 667     } else {
 668       replace(other);
 669     }
 670     return;
 671   }
 672
 673   CommonSymbol *oldSym = cast<CommonSymbol>(this);
 674
 675   oldSym->alignment = std::max(oldSym->alignment, other.alignment);
 676   if (oldSym->size < other.size) {
 677     oldSym->file = other.file;
 678     oldSym->size = other.size;
 679   }
 680 }
 681
 682 void Symbol::resolveDefined(const Defined &other) {
 683   int cmp = compare(&other);
 684   if (cmp > 0)
 685     replace(other);
 686   else if (cmp == 0)
 687     reportDuplicate(this, other.file,
 688                     dyn_cast_or_null<InputSectionBase>(other.section),
 689                     other.value);
 690 }
 691
 692 template <class LazyT>
 693 static void replaceCommon(Symbol &oldSym, const LazyT &newSym) {
 694   backwardReferences.erase(&oldSym);
 695   oldSym.replace(newSym);
 696   newSym.fetch();
 697 }
 698
 699 template <class LazyT> void Symbol::resolveLazy(const LazyT &other) {
 700   // For common objects, we want to look for global or weak definitions that
 701   // should be fetched as the cannonical definition instead.
 702   if (isCommon() && elf::config->fortranCommon) {
 703     if (auto *laSym = dyn_cast<LazyArchive>(&other)) {
 704       ArchiveFile *archive = cast<ArchiveFile>(laSym->file);
 705       const Archive::Symbol &archiveSym = laSym->sym;
 706       if (archive->shouldFetchForCommon(archiveSym)) {
 707         replaceCommon(*this, other);
 708         return;
 709       }
 710     } else if (auto *loSym = dyn_cast<LazyObject>(&other)) {
 711       LazyObjFile *obj = cast<LazyObjFile>(loSym->file);
 712       if (obj->shouldFetchForCommon(loSym->getName())) {
 713         replaceCommon(*this, other);
 714         return;
 715       }
 716     }
 717   }
 718
 719   if (!isUndefined()) {
 720     // See the comment in resolveUndefined().
 721     if (isDefined())
 722       backwardReferences.erase(this);
 723     return;
 724   }
 725
 726   // An undefined weak will not fetch archive members. See comment on Lazy in
 727   // Symbols.h for the details.
 728   if (isWeak()) {
 729     uint8_t ty = type;
 730     replace(other);
 731     type = ty;
 732     binding = STB_WEAK;
 733     return;
 734   }
 735
 736   other.fetch();
 737 }
 738
 739 void Symbol::resolveShared(const SharedSymbol &other) {
 740   if (isCommon()) {
 741     // See the comment in resolveCommon() above.
 742     if (other.size > cast<CommonSymbol>(this)->size)
 743       cast<CommonSymbol>(this)->size = other.size;
 744     return;
 745   }
 746   if (visibility == STV_DEFAULT && (isUndefined() || isLazy())) {
 747     // An undefined symbol with non default visibility must be satisfied
 748     // in the same DSO.
 749     uint8_t bind = binding;
 750     replace(other);
 751     binding = bind;
 752   } else if (traced)
 753     printTraceSymbol(&other);
 754 }