contrib/llvm-project/lld/COFF/InputFiles.cpp

   1 //===- InputFiles.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 "InputFiles.h"
  10 #include "Chunks.h"
  11 #include "Config.h"
  12 #include "DebugTypes.h"
  13 #include "Driver.h"
  14 #include "SymbolTable.h"
  15 #include "Symbols.h"
  16 #include "lld/Common/ErrorHandler.h"
  17 #include "lld/Common/Memory.h"
  18 #include "llvm-c/lto.h"
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/ADT/Triple.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/BinaryFormat/COFF.h"
  23 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
  24 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
  25 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
  26 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
  27 #include "llvm/Object/Binary.h"
  28 #include "llvm/Object/COFF.h"
  29 #include "llvm/Support/Casting.h"
  30 #include "llvm/Support/Endian.h"
  31 #include "llvm/Support/Error.h"
  32 #include "llvm/Support/ErrorOr.h"
  33 #include "llvm/Support/FileSystem.h"
  34 #include "llvm/Support/Path.h"
  35 #include "llvm/Target/TargetOptions.h"
  36 #include <cstring>
  37 #include <system_error>
  38 #include <utility>
  39
  40 using namespace llvm;
  41 using namespace llvm::COFF;
  42 using namespace llvm::codeview;
  43 using namespace llvm::object;
  44 using namespace llvm::support::endian;
  45
  46 using llvm::Triple;
  47 using llvm::support::ulittle32_t;
  48
  49 namespace lld {
  50 namespace coff {
  51
  52 std::vector<ObjFile *> ObjFile::instances;
  53 std::vector<ImportFile *> ImportFile::instances;
  54 std::vector<BitcodeFile *> BitcodeFile::instances;
  55
  56 /// Checks that Source is compatible with being a weak alias to Target.
  57 /// If Source is Undefined and has no weak alias set, makes it a weak
  58 /// alias to Target.
  59 static void checkAndSetWeakAlias(SymbolTable *symtab, InputFile *f,
  60                                  Symbol *source, Symbol *target) {
  61   if (auto *u = dyn_cast<Undefined>(source)) {
  62     if (u->weakAlias && u->weakAlias != target) {
  63       // Weak aliases as produced by GCC are named in the form
  64       // .weak.<weaksymbol>.<othersymbol>, where <othersymbol> is the name
  65       // of another symbol emitted near the weak symbol.
  66       // Just use the definition from the first object file that defined
  67       // this weak symbol.
  68       if (config->mingw)
  69         return;
  70       symtab->reportDuplicate(source, f);
  71     }
  72     u->weakAlias = target;
  73   }
  74 }
  75
  76 ArchiveFile::ArchiveFile(MemoryBufferRef m) : InputFile(ArchiveKind, m) {}
  77
  78 void ArchiveFile::parse() {
  79   // Parse a MemoryBufferRef as an archive file.
  80   file = CHECK(Archive::create(mb), this);
  81
  82   // Read the symbol table to construct Lazy objects.
  83   for (const Archive::Symbol &sym : file->symbols())
  84     symtab->addLazy(this, sym);
  85 }
  86
  87 // Returns a buffer pointing to a member file containing a given symbol.
  88 void ArchiveFile::addMember(const Archive::Symbol &sym) {
  89   const Archive::Child &c =
  90       CHECK(sym.getMember(),
  91             "could not get the member for symbol " + toCOFFString(sym));
  92
  93   // Return an empty buffer if we have already returned the same buffer.
  94   if (!seen.insert(c.getChildOffset()).second)
  95     return;
  96
  97   driver->enqueueArchiveMember(c, sym, getName());
  98 }
  99
 100 std::vector<MemoryBufferRef> getArchiveMembers(Archive *file) {
 101   std::vector<MemoryBufferRef> v;
 102   Error err = Error::success();
 103   for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
 104     Archive::Child c =
 105         CHECK(cOrErr,
 106               file->getFileName() + ": could not get the child of the archive");
 107     MemoryBufferRef mbref =
 108         CHECK(c.getMemoryBufferRef(),
 109               file->getFileName() +
 110                   ": could not get the buffer for a child of the archive");
 111     v.push_back(mbref);
 112   }
 113   if (err)
 114     fatal(file->getFileName() +
 115           ": Archive::children failed: " + toString(std::move(err)));
 116   return v;
 117 }
 118
 119 void ObjFile::parse() {
 120   // Parse a memory buffer as a COFF file.
 121   std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
 122
 123   if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
 124     bin.release();
 125     coffObj.reset(obj);
 126   } else {
 127     fatal(toString(this) + " is not a COFF file");
 128   }
 129
 130   // Read section and symbol tables.
 131   initializeChunks();
 132   initializeSymbols();
 133   initializeFlags();
 134   initializeDependencies();
 135 }
 136
 137 const coff_section* ObjFile::getSection(uint32_t i) {
 138   const coff_section *sec;
 139   if (auto ec = coffObj->getSection(i, sec))
 140     fatal("getSection failed: #" + Twine(i) + ": " + ec.message());
 141   return sec;
 142 }
 143
 144 // We set SectionChunk pointers in the SparseChunks vector to this value
 145 // temporarily to mark comdat sections as having an unknown resolution. As we
 146 // walk the object file's symbol table, once we visit either a leader symbol or
 147 // an associative section definition together with the parent comdat's leader,
 148 // we set the pointer to either nullptr (to mark the section as discarded) or a
 149 // valid SectionChunk for that section.
 150 static SectionChunk *const pendingComdat = reinterpret_cast<SectionChunk *>(1);
 151
 152 void ObjFile::initializeChunks() {
 153   uint32_t numSections = coffObj->getNumberOfSections();
 154   chunks.reserve(numSections);
 155   sparseChunks.resize(numSections + 1);
 156   for (uint32_t i = 1; i < numSections + 1; ++i) {
 157     const coff_section *sec = getSection(i);
 158     if (sec->Characteristics & IMAGE_SCN_LNK_COMDAT)
 159       sparseChunks[i] = pendingComdat;
 160     else
 161       sparseChunks[i] = readSection(i, nullptr, "");
 162   }
 163 }
 164
 165 SectionChunk *ObjFile::readSection(uint32_t sectionNumber,
 166                                    const coff_aux_section_definition *def,
 167                                    StringRef leaderName) {
 168   const coff_section *sec = getSection(sectionNumber);
 169
 170   StringRef name;
 171   if (Expected<StringRef> e = coffObj->getSectionName(sec))
 172     name = *e;
 173   else
 174     fatal("getSectionName failed: #" + Twine(sectionNumber) + ": " +
 175           toString(e.takeError()));
 176
 177   if (name == ".drectve") {
 178     ArrayRef<uint8_t> data;
 179     cantFail(coffObj->getSectionContents(sec, data));
 180     directives = StringRef((const char *)data.data(), data.size());
 181     return nullptr;
 182   }
 183
 184   if (name == ".llvm_addrsig") {
 185     addrsigSec = sec;
 186     return nullptr;
 187   }
 188
 189   // Object files may have DWARF debug info or MS CodeView debug info
 190   // (or both).
 191   //
 192   // DWARF sections don't need any special handling from the perspective
 193   // of the linker; they are just a data section containing relocations.
 194   // We can just link them to complete debug info.
 195   //
 196   // CodeView needs linker support. We need to interpret debug info,
 197   // and then write it to a separate .pdb file.
 198
 199   // Ignore DWARF debug info unless /debug is given.
 200   if (!config->debug && name.startswith(".debug_"))
 201     return nullptr;
 202
 203   if (sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
 204     return nullptr;
 205   auto *c = make<SectionChunk>(this, sec);
 206   if (def)
 207     c->checksum = def->CheckSum;
 208
 209   // link.exe uses the presence of .rsrc$01 for LNK4078, so match that.
 210   if (name == ".rsrc$01")
 211     isResourceObjFile = true;
 212
 213   // CodeView sections are stored to a different vector because they are not
 214   // linked in the regular manner.
 215   if (c->isCodeView())
 216     debugChunks.push_back(c);
 217   else if (name == ".gfids$y")
 218     guardFidChunks.push_back(c);
 219   else if (name == ".gljmp$y")
 220     guardLJmpChunks.push_back(c);
 221   else if (name == ".sxdata")
 222     sXDataChunks.push_back(c);
 223   else if (config->tailMerge && sec->NumberOfRelocations == 0 &&
 224            name == ".rdata" && leaderName.startswith("??_C@"))
 225     // COFF sections that look like string literal sections (i.e. no
 226     // relocations, in .rdata, leader symbol name matches the MSVC name mangling
 227     // for string literals) are subject to string tail merging.
 228     MergeChunk::addSection(c);
 229   else
 230     chunks.push_back(c);
 231
 232   return c;
 233 }
 234
 235 void ObjFile::readAssociativeDefinition(
 236     COFFSymbolRef sym, const coff_aux_section_definition *def) {
 237   readAssociativeDefinition(sym, def, def->getNumber(sym.isBigObj()));
 238 }
 239
 240 void ObjFile::readAssociativeDefinition(COFFSymbolRef sym,
 241                                         const coff_aux_section_definition *def,
 242                                         uint32_t parentIndex) {
 243   SectionChunk *parent = sparseChunks[parentIndex];
 244   int32_t sectionNumber = sym.getSectionNumber();
 245
 246   auto diag = [&]() {
 247     StringRef name, parentName;
 248     coffObj->getSymbolName(sym, name);
 249
 250     const coff_section *parentSec = getSection(parentIndex);
 251     if (Expected<StringRef> e = coffObj->getSectionName(parentSec))
 252       parentName = *e;
 253     error(toString(this) + ": associative comdat " + name + " (sec " +
 254           Twine(sectionNumber) + ") has invalid reference to section " +
 255           parentName + " (sec " + Twine(parentIndex) + ")");
 256   };
 257
 258   if (parent == pendingComdat) {
 259     // This can happen if an associative comdat refers to another associative
 260     // comdat that appears after it (invalid per COFF spec) or to a section
 261     // without any symbols.
 262     diag();
 263     return;
 264   }
 265
 266   // Check whether the parent is prevailing. If it is, so are we, and we read
 267   // the section; otherwise mark it as discarded.
 268   if (parent) {
 269     SectionChunk *c = readSection(sectionNumber, def, "");
 270     sparseChunks[sectionNumber] = c;
 271     if (c) {
 272       c->selection = IMAGE_COMDAT_SELECT_ASSOCIATIVE;
 273       parent->addAssociative(c);
 274     }
 275   } else {
 276     sparseChunks[sectionNumber] = nullptr;
 277   }
 278 }
 279
 280 void ObjFile::recordPrevailingSymbolForMingw(
 281     COFFSymbolRef sym, DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
 282   // For comdat symbols in executable sections, where this is the copy
 283   // of the section chunk we actually include instead of discarding it,
 284   // add the symbol to a map to allow using it for implicitly
 285   // associating .[px]data$<func> sections to it.
 286   int32_t sectionNumber = sym.getSectionNumber();
 287   SectionChunk *sc = sparseChunks[sectionNumber];
 288   if (sc && sc->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE) {
 289     StringRef name;
 290     coffObj->getSymbolName(sym, name);
 291     if (getMachineType() == I386)
 292       name.consume_front("_");
 293     prevailingSectionMap[name] = sectionNumber;
 294   }
 295 }
 296
 297 void ObjFile::maybeAssociateSEHForMingw(
 298     COFFSymbolRef sym, const coff_aux_section_definition *def,
 299     const DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
 300   StringRef name;
 301   coffObj->getSymbolName(sym, name);
 302   if (name.consume_front(".pdata$") || name.consume_front(".xdata$") ||
 303       name.consume_front(".eh_frame$")) {
 304     // For MinGW, treat .[px]data$<func> and .eh_frame$<func> as implicitly
 305     // associative to the symbol <func>.
 306     auto parentSym = prevailingSectionMap.find(name);
 307     if (parentSym != prevailingSectionMap.end())
 308       readAssociativeDefinition(sym, def, parentSym->second);
 309   }
 310 }
 311
 312 Symbol *ObjFile::createRegular(COFFSymbolRef sym) {
 313   SectionChunk *sc = sparseChunks[sym.getSectionNumber()];
 314   if (sym.isExternal()) {
 315     StringRef name;
 316     coffObj->getSymbolName(sym, name);
 317     if (sc)
 318       return symtab->addRegular(this, name, sym.getGeneric(), sc);
 319     // For MinGW symbols named .weak.* that point to a discarded section,
 320     // don't create an Undefined symbol. If nothing ever refers to the symbol,
 321     // everything should be fine. If something actually refers to the symbol
 322     // (e.g. the undefined weak alias), linking will fail due to undefined
 323     // references at the end.
 324     if (config->mingw && name.startswith(".weak."))
 325       return nullptr;
 326     return symtab->addUndefined(name, this, false);
 327   }
 328   if (sc)
 329     return make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
 330                                 /*IsExternal*/ false, sym.getGeneric(), sc);
 331   return nullptr;
 332 }
 333
 334 void ObjFile::initializeSymbols() {
 335   uint32_t numSymbols = coffObj->getNumberOfSymbols();
 336   symbols.resize(numSymbols);
 337
 338   SmallVector<std::pair<Symbol *, uint32_t>, 8> weakAliases;
 339   std::vector<uint32_t> pendingIndexes;
 340   pendingIndexes.reserve(numSymbols);
 341
 342   DenseMap<StringRef, uint32_t> prevailingSectionMap;
 343   std::vector<const coff_aux_section_definition *> comdatDefs(
 344       coffObj->getNumberOfSections() + 1);
 345
 346   for (uint32_t i = 0; i < numSymbols; ++i) {
 347     COFFSymbolRef coffSym = check(coffObj->getSymbol(i));
 348     bool prevailingComdat;
 349     if (coffSym.isUndefined()) {
 350       symbols[i] = createUndefined(coffSym);
 351     } else if (coffSym.isWeakExternal()) {
 352       symbols[i] = createUndefined(coffSym);
 353       uint32_t tagIndex = coffSym.getAux<coff_aux_weak_external>()->TagIndex;
 354       weakAliases.emplace_back(symbols[i], tagIndex);
 355     } else if (Optional<Symbol *> optSym =
 356                    createDefined(coffSym, comdatDefs, prevailingComdat)) {
 357       symbols[i] = *optSym;
 358       if (config->mingw && prevailingComdat)
 359         recordPrevailingSymbolForMingw(coffSym, prevailingSectionMap);
 360     } else {
 361       // createDefined() returns None if a symbol belongs to a section that
 362       // was pending at the point when the symbol was read. This can happen in
 363       // two cases:
 364       // 1) section definition symbol for a comdat leader;
 365       // 2) symbol belongs to a comdat section associated with another section.
 366       // In both of these cases, we can expect the section to be resolved by
 367       // the time we finish visiting the remaining symbols in the symbol
 368       // table. So we postpone the handling of this symbol until that time.
 369       pendingIndexes.push_back(i);
 370     }
 371     i += coffSym.getNumberOfAuxSymbols();
 372   }
 373
 374   for (uint32_t i : pendingIndexes) {
 375     COFFSymbolRef sym = check(coffObj->getSymbol(i));
 376     if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
 377       if (def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
 378         readAssociativeDefinition(sym, def);
 379       else if (config->mingw)
 380         maybeAssociateSEHForMingw(sym, def, prevailingSectionMap);
 381     }
 382     if (sparseChunks[sym.getSectionNumber()] == pendingComdat) {
 383       StringRef name;
 384       coffObj->getSymbolName(sym, name);
 385       log("comdat section " + name +
 386           " without leader and unassociated, discarding");
 387       continue;
 388     }
 389     symbols[i] = createRegular(sym);
 390   }
 391
 392   for (auto &kv : weakAliases) {
 393     Symbol *sym = kv.first;
 394     uint32_t idx = kv.second;
 395     checkAndSetWeakAlias(symtab, this, sym, symbols[idx]);
 396   }
 397 }
 398
 399 Symbol *ObjFile::createUndefined(COFFSymbolRef sym) {
 400   StringRef name;
 401   coffObj->getSymbolName(sym, name);
 402   return symtab->addUndefined(name, this, sym.isWeakExternal());
 403 }
 404
 405 void ObjFile::handleComdatSelection(COFFSymbolRef sym, COMDATType &selection,
 406                                     bool &prevailing, DefinedRegular *leader) {
 407   if (prevailing)
 408     return;
 409   // There's already an existing comdat for this symbol: `Leader`.
 410   // Use the comdats's selection field to determine if the new
 411   // symbol in `Sym` should be discarded, produce a duplicate symbol
 412   // error, etc.
 413
 414   SectionChunk *leaderChunk = nullptr;
 415   COMDATType leaderSelection = IMAGE_COMDAT_SELECT_ANY;
 416
 417   if (leader->data) {
 418     leaderChunk = leader->getChunk();
 419     leaderSelection = leaderChunk->selection;
 420   } else {
 421     // FIXME: comdats from LTO files don't know their selection; treat them
 422     // as "any".
 423     selection = leaderSelection;
 424   }
 425
 426   if ((selection == IMAGE_COMDAT_SELECT_ANY &&
 427        leaderSelection == IMAGE_COMDAT_SELECT_LARGEST) ||
 428       (selection == IMAGE_COMDAT_SELECT_LARGEST &&
 429        leaderSelection == IMAGE_COMDAT_SELECT_ANY)) {
 430     // cl.exe picks "any" for vftables when building with /GR- and
 431     // "largest" when building with /GR. To be able to link object files
 432     // compiled with each flag, "any" and "largest" are merged as "largest".
 433     leaderSelection = selection = IMAGE_COMDAT_SELECT_LARGEST;
 434   }
 435
 436   // Other than that, comdat selections must match.  This is a bit more
 437   // strict than link.exe which allows merging "any" and "largest" if "any"
 438   // is the first symbol the linker sees, and it allows merging "largest"
 439   // with everything (!) if "largest" is the first symbol the linker sees.
 440   // Making this symmetric independent of which selection is seen first
 441   // seems better though.
 442   // (This behavior matches ModuleLinker::getComdatResult().)
 443   if (selection != leaderSelection) {
 444     log(("conflicting comdat type for " + toString(*leader) + ": " +
 445          Twine((int)leaderSelection) + " in " + toString(leader->getFile()) +
 446          " and " + Twine((int)selection) + " in " + toString(this))
 447             .str());
 448     symtab->reportDuplicate(leader, this);
 449     return;
 450   }
 451
 452   switch (selection) {
 453   case IMAGE_COMDAT_SELECT_NODUPLICATES:
 454     symtab->reportDuplicate(leader, this);
 455     break;
 456
 457   case IMAGE_COMDAT_SELECT_ANY:
 458     // Nothing to do.
 459     break;
 460
 461   case IMAGE_COMDAT_SELECT_SAME_SIZE:
 462     if (leaderChunk->getSize() != getSection(sym)->SizeOfRawData)
 463       symtab->reportDuplicate(leader, this);
 464     break;
 465
 466   case IMAGE_COMDAT_SELECT_EXACT_MATCH: {
 467     SectionChunk newChunk(this, getSection(sym));
 468     // link.exe only compares section contents here and doesn't complain
 469     // if the two comdat sections have e.g. different alignment.
 470     // Match that.
 471     if (leaderChunk->getContents() != newChunk.getContents())
 472       symtab->reportDuplicate(leader, this);
 473     break;
 474   }
 475
 476   case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
 477     // createDefined() is never called for IMAGE_COMDAT_SELECT_ASSOCIATIVE.
 478     // (This means lld-link doesn't produce duplicate symbol errors for
 479     // associative comdats while link.exe does, but associate comdats
 480     // are never extern in practice.)
 481     llvm_unreachable("createDefined not called for associative comdats");
 482
 483   case IMAGE_COMDAT_SELECT_LARGEST:
 484     if (leaderChunk->getSize() < getSection(sym)->SizeOfRawData) {
 485       // Replace the existing comdat symbol with the new one.
 486       StringRef name;
 487       coffObj->getSymbolName(sym, name);
 488       // FIXME: This is incorrect: With /opt:noref, the previous sections
 489       // make it into the final executable as well. Correct handling would
 490       // be to undo reading of the whole old section that's being replaced,
 491       // or doing one pass that determines what the final largest comdat
 492       // is for all IMAGE_COMDAT_SELECT_LARGEST comdats and then reading
 493       // only the largest one.
 494       replaceSymbol<DefinedRegular>(leader, this, name, /*IsCOMDAT*/ true,
 495                                     /*IsExternal*/ true, sym.getGeneric(),
 496                                     nullptr);
 497       prevailing = true;
 498     }
 499     break;
 500
 501   case IMAGE_COMDAT_SELECT_NEWEST:
 502     llvm_unreachable("should have been rejected earlier");
 503   }
 504 }
 505
 506 Optional<Symbol *> ObjFile::createDefined(
 507     COFFSymbolRef sym,
 508     std::vector<const coff_aux_section_definition *> &comdatDefs,
 509     bool &prevailing) {
 510   prevailing = false;
 511   auto getName = [&]() {
 512     StringRef s;
 513     coffObj->getSymbolName(sym, s);
 514     return s;
 515   };
 516
 517   if (sym.isCommon()) {
 518     auto *c = make<CommonChunk>(sym);
 519     chunks.push_back(c);
 520     return symtab->addCommon(this, getName(), sym.getValue(), sym.getGeneric(),
 521                              c);
 522   }
 523
 524   if (sym.isAbsolute()) {
 525     StringRef name = getName();
 526
 527     // Skip special symbols.
 528     if (name == "@comp.id")
 529       return nullptr;
 530     if (name == "@feat.00") {
 531       feat00Flags = sym.getValue();
 532       return nullptr;
 533     }
 534
 535     if (sym.isExternal())
 536       return symtab->addAbsolute(name, sym);
 537     return make<DefinedAbsolute>(name, sym);
 538   }
 539
 540   int32_t sectionNumber = sym.getSectionNumber();
 541   if (sectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
 542     return nullptr;
 543
 544   if (llvm::COFF::isReservedSectionNumber(sectionNumber))
 545     fatal(toString(this) + ": " + getName() +
 546           " should not refer to special section " + Twine(sectionNumber));
 547
 548   if ((uint32_t)sectionNumber >= sparseChunks.size())
 549     fatal(toString(this) + ": " + getName() +
 550           " should not refer to non-existent section " + Twine(sectionNumber));
 551
 552   // Comdat handling.
 553   // A comdat symbol consists of two symbol table entries.
 554   // The first symbol entry has the name of the section (e.g. .text), fixed
 555   // values for the other fields, and one auxilliary record.
 556   // The second symbol entry has the name of the comdat symbol, called the
 557   // "comdat leader".
 558   // When this function is called for the first symbol entry of a comdat,
 559   // it sets comdatDefs and returns None, and when it's called for the second
 560   // symbol entry it reads comdatDefs and then sets it back to nullptr.
 561
 562   // Handle comdat leader.
 563   if (const coff_aux_section_definition *def = comdatDefs[sectionNumber]) {
 564     comdatDefs[sectionNumber] = nullptr;
 565     DefinedRegular *leader;
 566
 567     if (sym.isExternal()) {
 568       std::tie(leader, prevailing) =
 569           symtab->addComdat(this, getName(), sym.getGeneric());
 570     } else {
 571       leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
 572                                     /*IsExternal*/ false, sym.getGeneric());
 573       prevailing = true;
 574     }
 575
 576     if (def->Selection < (int)IMAGE_COMDAT_SELECT_NODUPLICATES ||
 577         // Intentionally ends at IMAGE_COMDAT_SELECT_LARGEST: link.exe
 578         // doesn't understand IMAGE_COMDAT_SELECT_NEWEST either.
 579         def->Selection > (int)IMAGE_COMDAT_SELECT_LARGEST) {
 580       fatal("unknown comdat type " + std::to_string((int)def->Selection) +
 581             " for " + getName() + " in " + toString(this));
 582     }
 583     COMDATType selection = (COMDATType)def->Selection;
 584
 585     if (leader->isCOMDAT)
 586       handleComdatSelection(sym, selection, prevailing, leader);
 587
 588     if (prevailing) {
 589       SectionChunk *c = readSection(sectionNumber, def, getName());
 590       sparseChunks[sectionNumber] = c;
 591       c->sym = cast<DefinedRegular>(leader);
 592       c->selection = selection;
 593       cast<DefinedRegular>(leader)->data = &c->repl;
 594     } else {
 595       sparseChunks[sectionNumber] = nullptr;
 596     }
 597     return leader;
 598   }
 599
 600   // Prepare to handle the comdat leader symbol by setting the section's
 601   // ComdatDefs pointer if we encounter a non-associative comdat.
 602   if (sparseChunks[sectionNumber] == pendingComdat) {
 603     if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
 604       if (def->Selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE)
 605         comdatDefs[sectionNumber] = def;
 606     }
 607     return None;
 608   }
 609
 610   return createRegular(sym);
 611 }
 612
 613 MachineTypes ObjFile::getMachineType() {
 614   if (coffObj)
 615     return static_cast<MachineTypes>(coffObj->getMachine());
 616   return IMAGE_FILE_MACHINE_UNKNOWN;
 617 }
 618
 619 ArrayRef<uint8_t> ObjFile::getDebugSection(StringRef secName) {
 620   if (SectionChunk *sec = SectionChunk::findByName(debugChunks, secName))
 621     return sec->consumeDebugMagic();
 622   return {};
 623 }
 624
 625 // OBJ files systematically store critical informations in a .debug$S stream,
 626 // even if the TU was compiled with no debug info. At least two records are
 627 // always there. S_OBJNAME stores a 32-bit signature, which is loaded into the
 628 // PCHSignature member. S_COMPILE3 stores compile-time cmd-line flags. This is
 629 // currently used to initialize the hotPatchable member.
 630 void ObjFile::initializeFlags() {
 631   ArrayRef<uint8_t> data = getDebugSection(".debug$S");
 632   if (data.empty())
 633     return;
 634
 635   DebugSubsectionArray subsections;
 636
 637   BinaryStreamReader reader(data, support::little);
 638   ExitOnError exitOnErr;
 639   exitOnErr(reader.readArray(subsections, data.size()));
 640
 641   for (const DebugSubsectionRecord &ss : subsections) {
 642     if (ss.kind() != DebugSubsectionKind::Symbols)
 643       continue;
 644
 645     unsigned offset = 0;
 646
 647     // Only parse the first two records. We are only looking for S_OBJNAME
 648     // and S_COMPILE3, and they usually appear at the beginning of the
 649     // stream.
 650     for (unsigned i = 0; i < 2; ++i) {
 651       Expected<CVSymbol> sym = readSymbolFromStream(ss.getRecordData(), offset);
 652       if (!sym) {
 653         consumeError(sym.takeError());
 654         return;
 655       }
 656       if (sym->kind() == SymbolKind::S_COMPILE3) {
 657         auto cs =
 658             cantFail(SymbolDeserializer::deserializeAs<Compile3Sym>(sym.get()));
 659         hotPatchable =
 660             (cs.Flags & CompileSym3Flags::HotPatch) != CompileSym3Flags::None;
 661       }
 662       if (sym->kind() == SymbolKind::S_OBJNAME) {
 663         auto objName = cantFail(SymbolDeserializer::deserializeAs<ObjNameSym>(
 664             sym.get()));
 665         pchSignature = objName.Signature;
 666       }
 667       offset += sym->length();
 668     }
 669   }
 670 }
 671
 672 // Depending on the compilation flags, OBJs can refer to external files,
 673 // necessary to merge this OBJ into the final PDB. We currently support two
 674 // types of external files: Precomp/PCH OBJs, when compiling with /Yc and /Yu.
 675 // And PDB type servers, when compiling with /Zi. This function extracts these
 676 // dependencies and makes them available as a TpiSource interface (see
 677 // DebugTypes.h). Both cases only happen with cl.exe: clang-cl produces regular
 678 // output even with /Yc and /Yu and with /Zi.
 679 void ObjFile::initializeDependencies() {
 680   if (!config->debug)
 681     return;
 682
 683   bool isPCH = false;
 684
 685   ArrayRef<uint8_t> data = getDebugSection(".debug$P");
 686   if (!data.empty())
 687     isPCH = true;
 688   else
 689     data = getDebugSection(".debug$T");
 690
 691   if (data.empty())
 692     return;
 693
 694   CVTypeArray types;
 695   BinaryStreamReader reader(data, support::little);
 696   cantFail(reader.readArray(types, reader.getLength()));
 697
 698   CVTypeArray::Iterator firstType = types.begin();
 699   if (firstType == types.end())
 700     return;
 701
 702   debugTypes.emplace(types);
 703
 704   if (isPCH) {
 705     debugTypesObj = makePrecompSource(this);
 706     return;
 707   }
 708
 709   if (firstType->kind() == LF_TYPESERVER2) {
 710     TypeServer2Record ts = cantFail(
 711         TypeDeserializer::deserializeAs<TypeServer2Record>(firstType->data()));
 712     debugTypesObj = makeUseTypeServerSource(this, &ts);
 713     return;
 714   }
 715
 716   if (firstType->kind() == LF_PRECOMP) {
 717     PrecompRecord precomp = cantFail(
 718         TypeDeserializer::deserializeAs<PrecompRecord>(firstType->data()));
 719     debugTypesObj = makeUsePrecompSource(this, &precomp);
 720     return;
 721   }
 722
 723   debugTypesObj = makeTpiSource(this);
 724 }
 725
 726 StringRef ltrim1(StringRef s, const char *chars) {
 727   if (!s.empty() && strchr(chars, s[0]))
 728     return s.substr(1);
 729   return s;
 730 }
 731
 732 void ImportFile::parse() {
 733   const char *buf = mb.getBufferStart();
 734   const auto *hdr = reinterpret_cast<const coff_import_header *>(buf);
 735
 736   // Check if the total size is valid.
 737   if (mb.getBufferSize() != sizeof(*hdr) + hdr->SizeOfData)
 738     fatal("broken import library");
 739
 740   // Read names and create an __imp_ symbol.
 741   StringRef name = saver.save(StringRef(buf + sizeof(*hdr)));
 742   StringRef impName = saver.save("__imp_" + name);
 743   const char *nameStart = buf + sizeof(coff_import_header) + name.size() + 1;
 744   dllName = StringRef(nameStart);
 745   StringRef extName;
 746   switch (hdr->getNameType()) {
 747   case IMPORT_ORDINAL:
 748     extName = "";
 749     break;
 750   case IMPORT_NAME:
 751     extName = name;
 752     break;
 753   case IMPORT_NAME_NOPREFIX:
 754     extName = ltrim1(name, "?@_");
 755     break;
 756   case IMPORT_NAME_UNDECORATE:
 757     extName = ltrim1(name, "?@_");
 758     extName = extName.substr(0, extName.find('@'));
 759     break;
 760   }
 761
 762   this->hdr = hdr;
 763   externalName = extName;
 764
 765   impSym = symtab->addImportData(impName, this);
 766   // If this was a duplicate, we logged an error but may continue;
 767   // in this case, impSym is nullptr.
 768   if (!impSym)
 769     return;
 770
 771   if (hdr->getType() == llvm::COFF::IMPORT_CONST)
 772     static_cast<void>(symtab->addImportData(name, this));
 773
 774   // If type is function, we need to create a thunk which jump to an
 775   // address pointed by the __imp_ symbol. (This allows you to call
 776   // DLL functions just like regular non-DLL functions.)
 777   if (hdr->getType() == llvm::COFF::IMPORT_CODE)
 778     thunkSym = symtab->addImportThunk(
 779         name, cast_or_null<DefinedImportData>(impSym), hdr->Machine);
 780 }
 781
 782 BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
 783                          uint64_t offsetInArchive)
 784     : InputFile(BitcodeKind, mb) {
 785   std::string path = mb.getBufferIdentifier().str();
 786   if (config->thinLTOIndexOnly)
 787     path = replaceThinLTOSuffix(mb.getBufferIdentifier());
 788
 789   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
 790   // name. If two archives define two members with the same name, this
 791   // causes a collision which result in only one of the objects being taken
 792   // into consideration at LTO time (which very likely causes undefined
 793   // symbols later in the link stage). So we append file offset to make
 794   // filename unique.
 795   MemoryBufferRef mbref(
 796       mb.getBuffer(),
 797       saver.save(archiveName + path +
 798                  (archiveName.empty() ? "" : utostr(offsetInArchive))));
 799
 800   obj = check(lto::InputFile::create(mbref));
 801 }
 802
 803 void BitcodeFile::parse() {
 804   std::vector<std::pair<Symbol *, bool>> comdat(obj->getComdatTable().size());
 805   for (size_t i = 0; i != obj->getComdatTable().size(); ++i)
 806     // FIXME: lto::InputFile doesn't keep enough data to do correct comdat
 807     // selection handling.
 808     comdat[i] = symtab->addComdat(this, saver.save(obj->getComdatTable()[i]));
 809   for (const lto::InputFile::Symbol &objSym : obj->symbols()) {
 810     StringRef symName = saver.save(objSym.getName());
 811     int comdatIndex = objSym.getComdatIndex();
 812     Symbol *sym;
 813     if (objSym.isUndefined()) {
 814       sym = symtab->addUndefined(symName, this, false);
 815     } else if (objSym.isCommon()) {
 816       sym = symtab->addCommon(this, symName, objSym.getCommonSize());
 817     } else if (objSym.isWeak() && objSym.isIndirect()) {
 818       // Weak external.
 819       sym = symtab->addUndefined(symName, this, true);
 820       std::string fallback = objSym.getCOFFWeakExternalFallback();
 821       Symbol *alias = symtab->addUndefined(saver.save(fallback));
 822       checkAndSetWeakAlias(symtab, this, sym, alias);
 823     } else if (comdatIndex != -1) {
 824       if (symName == obj->getComdatTable()[comdatIndex])
 825         sym = comdat[comdatIndex].first;
 826       else if (comdat[comdatIndex].second)
 827         sym = symtab->addRegular(this, symName);
 828       else
 829         sym = symtab->addUndefined(symName, this, false);
 830     } else {
 831       sym = symtab->addRegular(this, symName);
 832     }
 833     symbols.push_back(sym);
 834     if (objSym.isUsed())
 835       config->gcroot.push_back(sym);
 836   }
 837   directives = obj->getCOFFLinkerOpts();
 838 }
 839
 840 MachineTypes BitcodeFile::getMachineType() {
 841   switch (Triple(obj->getTargetTriple()).getArch()) {
 842   case Triple::x86_64:
 843     return AMD64;
 844   case Triple::x86:
 845     return I386;
 846   case Triple::arm:
 847     return ARMNT;
 848   case Triple::aarch64:
 849     return ARM64;
 850   default:
 851     return IMAGE_FILE_MACHINE_UNKNOWN;
 852   }
 853 }
 854
 855 std::string replaceThinLTOSuffix(StringRef path) {
 856   StringRef suffix = config->thinLTOObjectSuffixReplace.first;
 857   StringRef repl = config->thinLTOObjectSuffixReplace.second;
 858
 859   if (path.consume_back(suffix))
 860     return (path + repl).str();
 861   return path;
 862 }
 863 } // namespace coff
 864 } // namespace lld
 865
 866 // Returns the last element of a path, which is supposed to be a filename.
 867 static StringRef getBasename(StringRef path) {
 868   return sys::path::filename(path, sys::path::Style::windows);
 869 }
 870
 871 // Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
 872 std::string lld::toString(const coff::InputFile *file) {
 873   if (!file)
 874     return "<internal>";
 875   if (file->parentName.empty() || file->kind() == coff::InputFile::ImportKind)
 876     return file->getName();
 877
 878   return (getBasename(file->parentName) + "(" + getBasename(file->getName()) +
 879           ")")
 880       .str();
 881 }