contrib/llvm/tools/lld/COFF/PDB.cpp

   1 //===- PDB.cpp ------------------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "PDB.h"
  11 #include "Chunks.h"
  12 #include "Config.h"
  13 #include "Driver.h"
  14 #include "SymbolTable.h"
  15 #include "Symbols.h"
  16 #include "Writer.h"
  17 #include "lld/Common/ErrorHandler.h"
  18 #include "lld/Common/Timer.h"
  19 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
  20 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
  21 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
  22 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  23 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
  24 #include "llvm/DebugInfo/CodeView/RecordName.h"
  25 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
  26 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
  27 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
  28 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
  29 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
  30 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
  31 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
  32 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
  33 #include "llvm/DebugInfo/MSF/MSFCommon.h"
  34 #include "llvm/DebugInfo/PDB/GenericError.h"
  35 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
  36 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  37 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
  38 #include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
  39 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
  40 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
  41 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
  42 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  43 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
  44 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
  45 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
  46 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  47 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
  48 #include "llvm/DebugInfo/PDB/PDB.h"
  49 #include "llvm/Object/COFF.h"
  50 #include "llvm/Object/CVDebugRecord.h"
  51 #include "llvm/Support/BinaryByteStream.h"
  52 #include "llvm/Support/Endian.h"
  53 #include "llvm/Support/Errc.h"
  54 #include "llvm/Support/FormatVariadic.h"
  55 #include "llvm/Support/JamCRC.h"
  56 #include "llvm/Support/Parallel.h"
  57 #include "llvm/Support/Path.h"
  58 #include "llvm/Support/ScopedPrinter.h"
  59 #include <memory>
  60
  61 using namespace lld;
  62 using namespace lld::coff;
  63 using namespace llvm;
  64 using namespace llvm::codeview;
  65
  66 using llvm::object::coff_section;
  67
  68 static ExitOnError ExitOnErr;
  69
  70 static Timer TotalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
  71
  72 static Timer AddObjectsTimer("Add Objects", TotalPdbLinkTimer);
  73 static Timer TypeMergingTimer("Type Merging", AddObjectsTimer);
  74 static Timer SymbolMergingTimer("Symbol Merging", AddObjectsTimer);
  75 static Timer GlobalsLayoutTimer("Globals Stream Layout", TotalPdbLinkTimer);
  76 static Timer TpiStreamLayoutTimer("TPI Stream Layout", TotalPdbLinkTimer);
  77 static Timer DiskCommitTimer("Commit to Disk", TotalPdbLinkTimer);
  78
  79 namespace {
  80 /// Map from type index and item index in a type server PDB to the
  81 /// corresponding index in the destination PDB.
  82 struct CVIndexMap {
  83   SmallVector<TypeIndex, 0> TPIMap;
  84   SmallVector<TypeIndex, 0> IPIMap;
  85   bool IsTypeServerMap = false;
  86   bool IsPrecompiledTypeMap = false;
  87 };
  88
  89 class DebugSHandler;
  90
  91 class PDBLinker {
  92   friend DebugSHandler;
  93
  94 public:
  95   PDBLinker(SymbolTable *Symtab)
  96       : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
  97         IDTable(Alloc), GlobalTypeTable(Alloc), GlobalIDTable(Alloc) {
  98     // This isn't strictly necessary, but link.exe usually puts an empty string
  99     // as the first "valid" string in the string table, so we do the same in
 100     // order to maintain as much byte-for-byte compatibility as possible.
 101     PDBStrTab.insert("");
 102   }
 103
 104   /// Emit the basic PDB structure: initial streams, headers, etc.
 105   void initialize(llvm::codeview::DebugInfo *BuildId);
 106
 107   /// Add natvis files specified on the command line.
 108   void addNatvisFiles();
 109
 110   /// Link CodeView from each object file in the symbol table into the PDB.
 111   void addObjectsToPDB();
 112
 113   /// Link CodeView from a single object file into the target (output) PDB.
 114   /// When a precompiled headers object is linked, its TPI map might be provided
 115   /// externally.
 116   void addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap = nullptr);
 117
 118   /// Produce a mapping from the type and item indices used in the object
 119   /// file to those in the destination PDB.
 120   ///
 121   /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
 122   /// and IPI from the type server PDB and return a map for it. Each unique type
 123   /// server PDB is merged at most once, so this may return an existing index
 124   /// mapping.
 125   ///
 126   /// If the object does not use a type server PDB (compiled with /Z7), we merge
 127   /// all the type and item records from the .debug$S stream and fill in the
 128   /// caller-provided ObjectIndexMap.
 129   Expected<const CVIndexMap &> mergeDebugT(ObjFile *File,
 130                                            CVIndexMap *ObjectIndexMap);
 131
 132   /// Reads and makes available a PDB.
 133   Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *File,
 134                                                        const CVType &FirstType);
 135
 136   /// Merges a precompiled headers TPI map into the current TPI map. The
 137   /// precompiled headers object will also be loaded and remapped in the
 138   /// process.
 139   Expected<const CVIndexMap &>
 140   mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
 141                           CVIndexMap *ObjectIndexMap);
 142
 143   /// Reads and makes available a precompiled headers object.
 144   ///
 145   /// This is a requirement for objects compiled with cl.exe /Yu. In that
 146   /// case, the referenced object (which was compiled with /Yc) has to be loaded
 147   /// first. This is mainly because the current object's TPI stream has external
 148   /// references to the precompiled headers object.
 149   ///
 150   /// If the precompiled headers object was already loaded, this function will
 151   /// simply return its (remapped) TPI map.
 152   Expected<const CVIndexMap &> aquirePrecompObj(ObjFile *File,
 153                                                 PrecompRecord Precomp);
 154
 155   /// Adds a precompiled headers object signature -> TPI mapping.
 156   std::pair<CVIndexMap &, bool /*already there*/>
 157   registerPrecompiledHeaders(uint32_t Signature);
 158
 159   void mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
 160                           std::vector<ulittle32_t *> &StringTableRefs,
 161                           BinaryStreamRef SymData);
 162
 163   /// Add the section map and section contributions to the PDB.
 164   void addSections(ArrayRef<OutputSection *> OutputSections,
 165                    ArrayRef<uint8_t> SectionTable);
 166
 167   /// Get the type table or the global type table if /DEBUG:GHASH is enabled.
 168   TypeCollection &getTypeTable() {
 169     if (Config->DebugGHashes)
 170       return GlobalTypeTable;
 171     return TypeTable;
 172   }
 173
 174   /// Get the ID table or the global ID table if /DEBUG:GHASH is enabled.
 175   TypeCollection &getIDTable() {
 176     if (Config->DebugGHashes)
 177       return GlobalIDTable;
 178     return IDTable;
 179   }
 180
 181   /// Write the PDB to disk and store the Guid generated for it in *Guid.
 182   void commit(codeview::GUID *Guid);
 183
 184 private:
 185   BumpPtrAllocator Alloc;
 186
 187   SymbolTable *Symtab;
 188
 189   pdb::PDBFileBuilder Builder;
 190
 191   /// Type records that will go into the PDB TPI stream.
 192   MergingTypeTableBuilder TypeTable;
 193
 194   /// Item records that will go into the PDB IPI stream.
 195   MergingTypeTableBuilder IDTable;
 196
 197   /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
 198   GlobalTypeTableBuilder GlobalTypeTable;
 199
 200   /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
 201   GlobalTypeTableBuilder GlobalIDTable;
 202
 203   /// PDBs use a single global string table for filenames in the file checksum
 204   /// table.
 205   DebugStringTableSubsection PDBStrTab;
 206
 207   llvm::SmallString<128> NativePath;
 208
 209   /// A list of other PDBs which are loaded during the linking process and which
 210   /// we need to keep around since the linking operation may reference pointers
 211   /// inside of these PDBs.
 212   llvm::SmallVector<std::unique_ptr<pdb::NativeSession>, 2> LoadedPDBs;
 213
 214   std::vector<pdb::SecMapEntry> SectionMap;
 215
 216   /// Type index mappings of type server PDBs that we've loaded so far.
 217   std::map<codeview::GUID, CVIndexMap> TypeServerIndexMappings;
 218
 219   /// Type index mappings of precompiled objects type map that we've loaded so
 220   /// far.
 221   std::map<uint32_t, CVIndexMap> PrecompTypeIndexMappings;
 222
 223   /// List of TypeServer PDBs which cannot be loaded.
 224   /// Cached to prevent repeated load attempts.
 225   std::map<codeview::GUID, std::string> MissingTypeServerPDBs;
 226 };
 227
 228 class DebugSHandler {
 229   PDBLinker &Linker;
 230
 231   /// The object file whose .debug$S sections we're processing.
 232   ObjFile &File;
 233
 234   /// The result of merging type indices.
 235   const CVIndexMap &IndexMap;
 236
 237   /// The DEBUG_S_STRINGTABLE subsection.  These strings are referred to by
 238   /// index from other records in the .debug$S section.  All of these strings
 239   /// need to be added to the global PDB string table, and all references to
 240   /// these strings need to have their indices re-written to refer to the
 241   /// global PDB string table.
 242   DebugStringTableSubsectionRef CVStrTab;
 243
 244   /// The DEBUG_S_FILECHKSMS subsection.  As above, these are referred to
 245   /// by other records in the .debug$S section and need to be merged into the
 246   /// PDB.
 247   DebugChecksumsSubsectionRef Checksums;
 248
 249   /// The DEBUG_S_FRAMEDATA subsection(s).  There can be more than one of
 250   /// these and they need not appear in any specific order.  However, they
 251   /// contain string table references which need to be re-written, so we
 252   /// collect them all here and re-write them after all subsections have been
 253   /// discovered and processed.
 254   std::vector<DebugFrameDataSubsectionRef> NewFpoFrames;
 255
 256   /// Pointers to raw memory that we determine have string table references
 257   /// that need to be re-written.  We first process all .debug$S subsections
 258   /// to ensure that we can handle subsections written in any order, building
 259   /// up this list as we go.  At the end, we use the string table (which must
 260   /// have been discovered by now else it is an error) to re-write these
 261   /// references.
 262   std::vector<ulittle32_t *> StringTableReferences;
 263
 264 public:
 265   DebugSHandler(PDBLinker &Linker, ObjFile &File, const CVIndexMap &IndexMap)
 266       : Linker(Linker), File(File), IndexMap(IndexMap) {}
 267
 268   void handleDebugS(lld::coff::SectionChunk &DebugS);
 269   void finish();
 270 };
 271 }
 272
 273 // Visual Studio's debugger requires absolute paths in various places in the
 274 // PDB to work without additional configuration:
 275 // https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box
 276 static void pdbMakeAbsolute(SmallVectorImpl<char> &FileName) {
 277   // The default behavior is to produce paths that are valid within the context
 278   // of the machine that you perform the link on.  If the linker is running on
 279   // a POSIX system, we will output absolute POSIX paths.  If the linker is
 280   // running on a Windows system, we will output absolute Windows paths.  If the
 281   // user desires any other kind of behavior, they should explicitly pass
 282   // /pdbsourcepath, in which case we will treat the exact string the user
 283   // passed in as the gospel and not normalize, canonicalize it.
 284   if (sys::path::is_absolute(FileName, sys::path::Style::windows) ||
 285       sys::path::is_absolute(FileName, sys::path::Style::posix))
 286     return;
 287
 288   // It's not absolute in any path syntax.  Relative paths necessarily refer to
 289   // the local file system, so we can make it native without ending up with a
 290   // nonsensical path.
 291   if (Config->PDBSourcePath.empty()) {
 292     sys::path::native(FileName);
 293     sys::fs::make_absolute(FileName);
 294     return;
 295   }
 296
 297   // Try to guess whether /PDBSOURCEPATH is a unix path or a windows path.
 298   // Since PDB's are more of a Windows thing, we make this conservative and only
 299   // decide that it's a unix path if we're fairly certain.  Specifically, if
 300   // it starts with a forward slash.
 301   SmallString<128> AbsoluteFileName = Config->PDBSourcePath;
 302   sys::path::Style GuessedStyle = AbsoluteFileName.startswith("/")
 303                                       ? sys::path::Style::posix
 304                                       : sys::path::Style::windows;
 305   sys::path::append(AbsoluteFileName, GuessedStyle, FileName);
 306   sys::path::native(AbsoluteFileName, GuessedStyle);
 307   sys::path::remove_dots(AbsoluteFileName, true, GuessedStyle);
 308
 309   FileName = std::move(AbsoluteFileName);
 310 }
 311
 312 static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
 313                                 StringRef Name) {
 314   for (SectionChunk *C : Sections)
 315     if (C->getSectionName() == Name)
 316       return C;
 317   return nullptr;
 318 }
 319
 320 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
 321                                            StringRef SecName) {
 322   // First 4 bytes are section magic.
 323   if (Data.size() < 4)
 324     fatal(SecName + " too short");
 325   if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
 326     fatal(SecName + " has an invalid magic");
 327   return Data.slice(4);
 328 }
 329
 330 static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
 331   if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
 332     return consumeDebugMagic(Sec->getContents(), SecName);
 333   return {};
 334 }
 335
 336 // A COFF .debug$H section is currently a clang extension.  This function checks
 337 // if a .debug$H section is in a format that we expect / understand, so that we
 338 // can ignore any sections which are coincidentally also named .debug$H but do
 339 // not contain a format we recognize.
 340 static bool canUseDebugH(ArrayRef<uint8_t> DebugH) {
 341   if (DebugH.size() < sizeof(object::debug_h_header))
 342     return false;
 343   auto *Header =
 344       reinterpret_cast<const object::debug_h_header *>(DebugH.data());
 345   DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
 346   return Header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
 347          Header->Version == 0 &&
 348          Header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) &&
 349          (DebugH.size() % 8 == 0);
 350 }
 351
 352 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) {
 353   SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$H");
 354   if (!Sec)
 355     return llvm::None;
 356   ArrayRef<uint8_t> Contents = Sec->getContents();
 357   if (!canUseDebugH(Contents))
 358     return None;
 359   return Contents;
 360 }
 361
 362 static ArrayRef<GloballyHashedType>
 363 getHashesFromDebugH(ArrayRef<uint8_t> DebugH) {
 364   assert(canUseDebugH(DebugH));
 365
 366   DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
 367   uint32_t Count = DebugH.size() / sizeof(GloballyHashedType);
 368   return {reinterpret_cast<const GloballyHashedType *>(DebugH.data()), Count};
 369 }
 370
 371 static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
 372                         TypeCollection &TypeTable) {
 373   // Start the TPI or IPI stream header.
 374   TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
 375
 376   // Flatten the in memory type table and hash each type.
 377   TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) {
 378     auto Hash = pdb::hashTypeRecord(Type);
 379     if (auto E = Hash.takeError())
 380       fatal("type hashing error");
 381     TpiBuilder.addTypeRecord(Type.RecordData, *Hash);
 382   });
 383 }
 384
 385 // OBJs usually start their symbol stream with a S_OBJNAME record. This record
 386 // also contains the signature/key of the current PCH session. The signature
 387 // must be same for all objects which depend on the precompiled object.
 388 // Recompiling the precompiled headers will generate a new PCH key and thus
 389 // invalidate all the dependent objects.
 390 static uint32_t extractPCHSignature(ObjFile *File) {
 391   auto DbgIt = find_if(File->getDebugChunks(), [](SectionChunk *C) {
 392     return C->getSectionName() == ".debug$S";
 393   });
 394   if (!DbgIt)
 395     return 0;
 396
 397   ArrayRef<uint8_t> Contents =
 398       consumeDebugMagic((*DbgIt)->getContents(), ".debug$S");
 399   DebugSubsectionArray Subsections;
 400   BinaryStreamReader Reader(Contents, support::little);
 401   ExitOnErr(Reader.readArray(Subsections, Contents.size()));
 402
 403   for (const DebugSubsectionRecord &SS : Subsections) {
 404     if (SS.kind() != DebugSubsectionKind::Symbols)
 405       continue;
 406
 407     // If it's there, the S_OBJNAME record shall come first in the stream.
 408     Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), 0);
 409     if (!Sym) {
 410       consumeError(Sym.takeError());
 411       continue;
 412     }
 413     if (auto ObjName = SymbolDeserializer::deserializeAs<ObjNameSym>(Sym.get()))
 414       return ObjName->Signature;
 415   }
 416   return 0;
 417 }
 418
 419 Expected<const CVIndexMap &>
 420 PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) {
 421   ScopedTimer T(TypeMergingTimer);
 422
 423   bool IsPrecompiledHeader = false;
 424
 425   ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
 426   if (Data.empty()) {
 427     // Try again, Microsoft precompiled headers use .debug$P instead of
 428     // .debug$T
 429     Data = getDebugSection(File, ".debug$P");
 430     IsPrecompiledHeader = true;
 431   }
 432   if (Data.empty())
 433     return *ObjectIndexMap; // no debug info
 434
 435   // Precompiled headers objects need to save the index map for further
 436   // reference by other objects which use the precompiled headers.
 437   if (IsPrecompiledHeader) {
 438     uint32_t PCHSignature = extractPCHSignature(File);
 439     if (PCHSignature == 0)
 440       fatal("No signature found for the precompiled headers OBJ (" +
 441             File->getName() + ")");
 442
 443     // When a precompiled headers object comes first on the command-line, we
 444     // update the mapping here. Otherwise, if an object referencing the
 445     // precompiled headers object comes first, the mapping is created in
 446     // aquirePrecompObj(), thus we would skip this block.
 447     if (!ObjectIndexMap->IsPrecompiledTypeMap) {
 448       auto R = registerPrecompiledHeaders(PCHSignature);
 449       if (R.second)
 450         fatal(
 451             "A precompiled headers OBJ with the same signature was already "
 452             "provided! (" +
 453             File->getName() + ")");
 454
 455       ObjectIndexMap = &R.first;
 456     }
 457   }
 458
 459   BinaryByteStream Stream(Data, support::little);
 460   CVTypeArray Types;
 461   BinaryStreamReader Reader(Stream);
 462   if (auto EC = Reader.readArray(Types, Reader.getLength()))
 463     fatal("Reader::readArray failed: " + toString(std::move(EC)));
 464
 465   auto FirstType = Types.begin();
 466   if (FirstType == Types.end())
 467     return *ObjectIndexMap;
 468
 469   if (FirstType->kind() == LF_TYPESERVER2) {
 470     // Look through type servers. If we've already seen this type server,
 471     // don't merge any type information.
 472     return maybeMergeTypeServerPDB(File, *FirstType);
 473   } else if (FirstType->kind() == LF_PRECOMP) {
 474     // This object was compiled with /Yu, so process the corresponding
 475     // precompiled headers object (/Yc) first. Some type indices in the current
 476     // object are referencing data in the precompiled headers object, so we need
 477     // both to be loaded.
 478     auto E = mergeInPrecompHeaderObj(File, *FirstType, ObjectIndexMap);
 479     if (!E)
 480       return E.takeError();
 481
 482     // Drop LF_PRECOMP record from the input stream, as it needs to be replaced
 483     // with the precompiled headers object type stream.
 484     // Note that we can't just call Types.drop_front(), as we explicitly want to
 485     // rebase the stream.
 486     Types.setUnderlyingStream(
 487         Types.getUnderlyingStream().drop_front(FirstType->RecordData.size()));
 488   }
 489
 490   // Fill in the temporary, caller-provided ObjectIndexMap.
 491   if (Config->DebugGHashes) {
 492     ArrayRef<GloballyHashedType> Hashes;
 493     std::vector<GloballyHashedType> OwnedHashes;
 494     if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File))
 495       Hashes = getHashesFromDebugH(*DebugH);
 496     else {
 497       OwnedHashes = GloballyHashedType::hashTypes(Types);
 498       Hashes = OwnedHashes;
 499     }
 500
 501     if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
 502                                          ObjectIndexMap->TPIMap, Types, Hashes,
 503                                          File->PCHSignature))
 504       fatal("codeview::mergeTypeAndIdRecords failed: " +
 505             toString(std::move(Err)));
 506   } else {
 507     if (auto Err =
 508             mergeTypeAndIdRecords(IDTable, TypeTable, ObjectIndexMap->TPIMap,
 509                                   Types, File->PCHSignature))
 510       fatal("codeview::mergeTypeAndIdRecords failed: " +
 511             toString(std::move(Err)));
 512   }
 513   return *ObjectIndexMap;
 514 }
 515
 516 static Expected<std::unique_ptr<pdb::NativeSession>>
 517 tryToLoadPDB(const codeview::GUID &GuidFromObj, StringRef TSPath) {
 518   // Ensure the file exists before anything else. We want to return ENOENT,
 519   // "file not found", even if the path points to a removable device (in which
 520   // case the return message would be EAGAIN, "resource unavailable try again")
 521   if (!llvm::sys::fs::exists(TSPath))
 522     return errorCodeToError(std::error_code(ENOENT, std::generic_category()));
 523
 524   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
 525       TSPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
 526   if (!MBOrErr)
 527     return errorCodeToError(MBOrErr.getError());
 528
 529   std::unique_ptr<pdb::IPDBSession> ThisSession;
 530   if (auto EC = pdb::NativeSession::createFromPdb(
 531           MemoryBuffer::getMemBuffer(Driver->takeBuffer(std::move(*MBOrErr)),
 532                                      /*RequiresNullTerminator=*/false),
 533           ThisSession))
 534     return std::move(EC);
 535
 536   std::unique_ptr<pdb::NativeSession> NS(
 537       static_cast<pdb::NativeSession *>(ThisSession.release()));
 538   pdb::PDBFile &File = NS->getPDBFile();
 539   auto ExpectedInfo = File.getPDBInfoStream();
 540   // All PDB Files should have an Info stream.
 541   if (!ExpectedInfo)
 542     return ExpectedInfo.takeError();
 543
 544   // Just because a file with a matching name was found and it was an actual
 545   // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
 546   // must match the GUID specified in the TypeServer2 record.
 547   if (ExpectedInfo->getGuid() != GuidFromObj)
 548     return make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date);
 549
 550   return std::move(NS);
 551 }
 552
 553 Expected<const CVIndexMap &>
 554 PDBLinker::maybeMergeTypeServerPDB(ObjFile *File, const CVType &FirstType) {
 555   TypeServer2Record TS;
 556   if (auto EC =
 557           TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType), TS))
 558     fatal("error reading record: " + toString(std::move(EC)));
 559
 560   const codeview::GUID &TSId = TS.getGuid();
 561   StringRef TSPath = TS.getName();
 562
 563   // First, check if the PDB has previously failed to load.
 564   auto PrevErr = MissingTypeServerPDBs.find(TSId);
 565   if (PrevErr != MissingTypeServerPDBs.end())
 566     return createFileError(
 567         TSPath,
 568         make_error<StringError>(PrevErr->second, inconvertibleErrorCode()));
 569
 570   // Second, check if we already loaded a PDB with this GUID. Return the type
 571   // index mapping if we have it.
 572   auto Insertion = TypeServerIndexMappings.insert({TSId, CVIndexMap()});
 573   CVIndexMap &IndexMap = Insertion.first->second;
 574   if (!Insertion.second)
 575     return IndexMap;
 576
 577   // Mark this map as a type server map.
 578   IndexMap.IsTypeServerMap = true;
 579
 580   // Check for a PDB at:
 581   // 1. The given file path
 582   // 2. Next to the object file or archive file
 583   auto ExpectedSession = handleExpected(
 584       tryToLoadPDB(TSId, TSPath),
 585       [&]() {
 586         StringRef LocalPath =
 587             !File->ParentName.empty() ? File->ParentName : File->getName();
 588         SmallString<128> Path = sys::path::parent_path(LocalPath);
 589         // Currently, type server PDBs are only created by cl, which only runs
 590         // on Windows, so we can assume type server paths are Windows style.
 591         sys::path::append(
 592             Path, sys::path::filename(TSPath, sys::path::Style::windows));
 593         return tryToLoadPDB(TSId, Path);
 594       },
 595       [&](std::unique_ptr<ECError> EC) -> Error {
 596         auto SysErr = EC->convertToErrorCode();
 597         // Only re-try loading if the previous error was "No such file or
 598         // directory"
 599         if (SysErr.category() == std::generic_category() &&
 600             SysErr.value() == ENOENT)
 601           return Error::success();
 602         return Error(std::move(EC));
 603       });
 604
 605   if (auto E = ExpectedSession.takeError()) {
 606     TypeServerIndexMappings.erase(TSId);
 607
 608     // Flatten the error to a string, for later display, if the error occurs
 609     // again on the same PDB.
 610     std::string ErrMsg;
 611     raw_string_ostream S(ErrMsg);
 612     S << E;
 613     MissingTypeServerPDBs.emplace(TSId, S.str());
 614
 615     return createFileError(TSPath, std::move(E));
 616   }
 617
 618   pdb::NativeSession *Session = ExpectedSession->get();
 619
 620   // Keep a strong reference to this PDB, so that it's safe to hold pointers
 621   // into the file.
 622   LoadedPDBs.push_back(std::move(*ExpectedSession));
 623
 624   auto ExpectedTpi = Session->getPDBFile().getPDBTpiStream();
 625   if (auto E = ExpectedTpi.takeError())
 626     fatal("Type server does not have TPI stream: " + toString(std::move(E)));
 627   auto ExpectedIpi = Session->getPDBFile().getPDBIpiStream();
 628   if (auto E = ExpectedIpi.takeError())
 629     fatal("Type server does not have TPI stream: " + toString(std::move(E)));
 630
 631   if (Config->DebugGHashes) {
 632     // PDBs do not actually store global hashes, so when merging a type server
 633     // PDB we have to synthesize global hashes.  To do this, we first synthesize
 634     // global hashes for the TPI stream, since it is independent, then we
 635     // synthesize hashes for the IPI stream, using the hashes for the TPI stream
 636     // as inputs.
 637     auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
 638     auto IpiHashes =
 639         GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
 640
 641     Optional<uint32_t> EndPrecomp;
 642     // Merge TPI first, because the IPI stream will reference type indices.
 643     if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
 644                                     ExpectedTpi->typeArray(), TpiHashes, EndPrecomp))
 645       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 646
 647     // Merge IPI.
 648     if (auto Err =
 649             mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
 650                            ExpectedIpi->typeArray(), IpiHashes))
 651       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
 652   } else {
 653     // Merge TPI first, because the IPI stream will reference type indices.
 654     if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
 655                                     ExpectedTpi->typeArray()))
 656       fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
 657
 658     // Merge IPI.
 659     if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
 660                                   ExpectedIpi->typeArray()))
 661       fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
 662   }
 663
 664   return IndexMap;
 665 }
 666
 667 Expected<const CVIndexMap &>
 668 PDBLinker::mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
 669                                    CVIndexMap *ObjectIndexMap) {
 670   PrecompRecord Precomp;
 671   if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType),
 672                                                 Precomp))
 673     fatal("error reading record: " + toString(std::move(EC)));
 674
 675   auto E = aquirePrecompObj(File, Precomp);
 676   if (!E)
 677     return E.takeError();
 678
 679   const CVIndexMap &PrecompIndexMap = *E;
 680   assert(PrecompIndexMap.IsPrecompiledTypeMap);
 681
 682   if (PrecompIndexMap.TPIMap.empty())
 683     return PrecompIndexMap;
 684
 685   assert(Precomp.getStartTypeIndex() == TypeIndex::FirstNonSimpleIndex);
 686   assert(Precomp.getTypesCount() <= PrecompIndexMap.TPIMap.size());
 687   // Use the previously remapped index map from the precompiled headers.
 688   ObjectIndexMap->TPIMap.append(PrecompIndexMap.TPIMap.begin(),
 689                                 PrecompIndexMap.TPIMap.begin() +
 690                                     Precomp.getTypesCount());
 691   return *ObjectIndexMap;
 692 }
 693
 694 static bool equals_path(StringRef path1, StringRef path2) {
 695 #if defined(_WIN32)
 696   return path1.equals_lower(path2);
 697 #else
 698   return path1.equals(path2);
 699 #endif
 700 }
 701
 702 // Find by name an OBJ provided on the command line
 703 static ObjFile *findObjByName(StringRef FileNameOnly) {
 704   SmallString<128> CurrentPath;
 705
 706   for (ObjFile *F : ObjFile::Instances) {
 707     StringRef CurrentFileName = sys::path::filename(F->getName());
 708
 709     // Compare based solely on the file name (link.exe behavior)
 710     if (equals_path(CurrentFileName, FileNameOnly))
 711       return F;
 712   }
 713   return nullptr;
 714 }
 715
 716 std::pair<CVIndexMap &, bool /*already there*/>
 717 PDBLinker::registerPrecompiledHeaders(uint32_t Signature) {
 718   auto Insertion = PrecompTypeIndexMappings.insert({Signature, CVIndexMap()});
 719   CVIndexMap &IndexMap = Insertion.first->second;
 720   if (!Insertion.second)
 721     return {IndexMap, true};
 722   // Mark this map as a precompiled types map.
 723   IndexMap.IsPrecompiledTypeMap = true;
 724   return {IndexMap, false};
 725 }
 726
 727 Expected<const CVIndexMap &>
 728 PDBLinker::aquirePrecompObj(ObjFile *File, PrecompRecord Precomp) {
 729   // First, check if we already loaded the precompiled headers object with this
 730   // signature. Return the type index mapping if we've already seen it.
 731   auto R = registerPrecompiledHeaders(Precomp.getSignature());
 732   if (R.second)
 733     return R.first;
 734
 735   CVIndexMap &IndexMap = R.first;
 736
 737   // Cross-compile warning: given that Clang doesn't generate LF_PRECOMP
 738   // records, we assume the OBJ comes from a Windows build of cl.exe. Thusly,
 739   // the paths embedded in the OBJs are in the Windows format.
 740   SmallString<128> PrecompFileName = sys::path::filename(
 741       Precomp.getPrecompFilePath(), sys::path::Style::windows);
 742
 743   // link.exe requires that a precompiled headers object must always be provided
 744   // on the command-line, even if that's not necessary.
 745   auto PrecompFile = findObjByName(PrecompFileName);
 746   if (!PrecompFile)
 747     return createFileError(
 748         PrecompFileName.str(),
 749         make_error<pdb::PDBError>(pdb::pdb_error_code::external_cmdline_ref));
 750
 751   addObjFile(PrecompFile, &IndexMap);
 752
 753   if (!PrecompFile->PCHSignature)
 754     fatal(PrecompFile->getName() + " is not a precompiled headers object");
 755
 756   if (Precomp.getSignature() != PrecompFile->PCHSignature.getValueOr(0))
 757     return createFileError(
 758         Precomp.getPrecompFilePath().str(),
 759         make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
 760
 761   return IndexMap;
 762 }
 763
 764 static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
 765   if (TI.isSimple())
 766     return true;
 767   if (TI.toArrayIndex() >= TypeIndexMap.size())
 768     return false;
 769   TI = TypeIndexMap[TI.toArrayIndex()];
 770   return true;
 771 }
 772
 773 static void remapTypesInSymbolRecord(ObjFile *File, SymbolKind SymKind,
 774                                      MutableArrayRef<uint8_t> RecordBytes,
 775                                      const CVIndexMap &IndexMap,
 776                                      ArrayRef<TiReference> TypeRefs) {
 777   MutableArrayRef<uint8_t> Contents =
 778       RecordBytes.drop_front(sizeof(RecordPrefix));
 779   for (const TiReference &Ref : TypeRefs) {
 780     unsigned ByteSize = Ref.Count * sizeof(TypeIndex);
 781     if (Contents.size() < Ref.Offset + ByteSize)
 782       fatal("symbol record too short");
 783
 784     // This can be an item index or a type index. Choose the appropriate map.
 785     ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap;
 786     bool IsItemIndex = Ref.Kind == TiRefKind::IndexRef;
 787     if (IsItemIndex && IndexMap.IsTypeServerMap)
 788       TypeOrItemMap = IndexMap.IPIMap;
 789
 790     MutableArrayRef<TypeIndex> TIs(
 791         reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count);
 792     for (TypeIndex &TI : TIs) {
 793       if (!remapTypeIndex(TI, TypeOrItemMap)) {
 794         log("ignoring symbol record of kind 0x" + utohexstr(SymKind) + " in " +
 795             File->getName() + " with bad " + (IsItemIndex ? "item" : "type") +
 796             " index 0x" + utohexstr(TI.getIndex()));
 797         TI = TypeIndex(SimpleTypeKind::NotTranslated);
 798         continue;
 799       }
 800     }
 801   }
 802 }
 803
 804 static void
 805 recordStringTableReferenceAtOffset(MutableArrayRef<uint8_t> Contents,
 806                                    uint32_t Offset,
 807                                    std::vector<ulittle32_t *> &StrTableRefs) {
 808   Contents =
 809       Contents.drop_front(Offset).take_front(sizeof(support::ulittle32_t));
 810   ulittle32_t *Index = reinterpret_cast<ulittle32_t *>(Contents.data());
 811   StrTableRefs.push_back(Index);
 812 }
 813
 814 static void
 815 recordStringTableReferences(SymbolKind Kind, MutableArrayRef<uint8_t> Contents,
 816                             std::vector<ulittle32_t *> &StrTableRefs) {
 817   // For now we only handle S_FILESTATIC, but we may need the same logic for
 818   // S_DEFRANGE and S_DEFRANGE_SUBFIELD.  However, I cannot seem to generate any
 819   // PDBs that contain these types of records, so because of the uncertainty
 820   // they are omitted here until we can prove that it's necessary.
 821   switch (Kind) {
 822   case SymbolKind::S_FILESTATIC:
 823     // FileStaticSym::ModFileOffset
 824     recordStringTableReferenceAtOffset(Contents, 8, StrTableRefs);
 825     break;
 826   case SymbolKind::S_DEFRANGE:
 827   case SymbolKind::S_DEFRANGE_SUBFIELD:
 828     log("Not fixing up string table reference in S_DEFRANGE / "
 829         "S_DEFRANGE_SUBFIELD record");
 830     break;
 831   default:
 832     break;
 833   }
 834 }
 835
 836 static SymbolKind symbolKind(ArrayRef<uint8_t> RecordData) {
 837   const RecordPrefix *Prefix =
 838       reinterpret_cast<const RecordPrefix *>(RecordData.data());
 839   return static_cast<SymbolKind>(uint16_t(Prefix->RecordKind));
 840 }
 841
 842 /// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
 843 static void translateIdSymbols(MutableArrayRef<uint8_t> &RecordData,
 844                                TypeCollection &IDTable) {
 845   RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(RecordData.data());
 846
 847   SymbolKind Kind = symbolKind(RecordData);
 848
 849   if (Kind == SymbolKind::S_PROC_ID_END) {
 850     Prefix->RecordKind = SymbolKind::S_END;
 851     return;
 852   }
 853
 854   // In an object file, GPROC32_ID has an embedded reference which refers to the
 855   // single object file type index namespace.  This has already been translated
 856   // to the PDB file's ID stream index space, but we need to convert this to a
 857   // symbol that refers to the type stream index space.  So we remap again from
 858   // ID index space to type index space.
 859   if (Kind == SymbolKind::S_GPROC32_ID || Kind == SymbolKind::S_LPROC32_ID) {
 860     SmallVector<TiReference, 1> Refs;
 861     auto Content = RecordData.drop_front(sizeof(RecordPrefix));
 862     CVSymbol Sym(Kind, RecordData);
 863     discoverTypeIndicesInSymbol(Sym, Refs);
 864     assert(Refs.size() == 1);
 865     assert(Refs.front().Count == 1);
 866
 867     TypeIndex *TI =
 868         reinterpret_cast<TypeIndex *>(Content.data() + Refs[0].Offset);
 869     // `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
 870     // the IPI stream, whose `FunctionType` member refers to the TPI stream.
 871     // Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
 872     // in both cases we just need the second type index.
 873     if (!TI->isSimple() && !TI->isNoneType()) {
 874       CVType FuncIdData = IDTable.getType(*TI);
 875       SmallVector<TypeIndex, 2> Indices;
 876       discoverTypeIndices(FuncIdData, Indices);
 877       assert(Indices.size() == 2);
 878       *TI = Indices[1];
 879     }
 880
 881     Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
 882                                               : SymbolKind::S_LPROC32;
 883     Prefix->RecordKind = uint16_t(Kind);
 884   }
 885 }
 886
 887 /// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
 888 /// The object file may not be aligned.
 889 static MutableArrayRef<uint8_t>
 890 copyAndAlignSymbol(const CVSymbol &Sym, MutableArrayRef<uint8_t> &AlignedMem) {
 891   size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
 892   assert(Size >= 4 && "record too short");
 893   assert(Size <= MaxRecordLength && "record too long");
 894   assert(AlignedMem.size() >= Size && "didn't preallocate enough");
 895
 896   // Copy the symbol record and zero out any padding bytes.
 897   MutableArrayRef<uint8_t> NewData = AlignedMem.take_front(Size);
 898   AlignedMem = AlignedMem.drop_front(Size);
 899   memcpy(NewData.data(), Sym.data().data(), Sym.length());
 900   memset(NewData.data() + Sym.length(), 0, Size - Sym.length());
 901
 902   // Update the record prefix length. It should point to the beginning of the
 903   // next record.
 904   auto *Prefix = reinterpret_cast<RecordPrefix *>(NewData.data());
 905   Prefix->RecordLen = Size - 2;
 906   return NewData;
 907 }
 908
 909 struct ScopeRecord {
 910   ulittle32_t PtrParent;
 911   ulittle32_t PtrEnd;
 912 };
 913
 914 struct SymbolScope {
 915   ScopeRecord *OpeningRecord;
 916   uint32_t ScopeOffset;
 917 };
 918
 919 static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
 920                            uint32_t CurOffset, CVSymbol &Sym) {
 921   assert(symbolOpensScope(Sym.kind()));
 922   SymbolScope S;
 923   S.ScopeOffset = CurOffset;
 924   S.OpeningRecord = const_cast<ScopeRecord *>(
 925       reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
 926   S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
 927   Stack.push_back(S);
 928 }
 929
 930 static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
 931                             uint32_t CurOffset, ObjFile *File) {
 932   if (Stack.empty()) {
 933     warn("symbol scopes are not balanced in " + File->getName());
 934     return;
 935   }
 936   SymbolScope S = Stack.pop_back_val();
 937   S.OpeningRecord->PtrEnd = CurOffset;
 938 }
 939
 940 static bool symbolGoesInModuleStream(const CVSymbol &Sym, bool IsGlobalScope) {
 941   switch (Sym.kind()) {
 942   case SymbolKind::S_GDATA32:
 943   case SymbolKind::S_CONSTANT:
 944   // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
 945   // since they are synthesized by the linker in response to S_GPROC32 and
 946   // S_LPROC32, but if we do see them, don't put them in the module stream I
 947   // guess.
 948   case SymbolKind::S_PROCREF:
 949   case SymbolKind::S_LPROCREF:
 950     return false;
 951   // S_UDT records go in the module stream if it is not a global S_UDT.
 952   case SymbolKind::S_UDT:
 953     return !IsGlobalScope;
 954   // S_GDATA32 does not go in the module stream, but S_LDATA32 does.
 955   case SymbolKind::S_LDATA32:
 956   default:
 957     return true;
 958   }
 959 }
 960
 961 static bool symbolGoesInGlobalsStream(const CVSymbol &Sym, bool IsGlobalScope) {
 962   switch (Sym.kind()) {
 963   case SymbolKind::S_CONSTANT:
 964   case SymbolKind::S_GDATA32:
 965   // S_LDATA32 goes in both the module stream and the globals stream.
 966   case SymbolKind::S_LDATA32:
 967   case SymbolKind::S_GPROC32:
 968   case SymbolKind::S_LPROC32:
 969   // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
 970   // since they are synthesized by the linker in response to S_GPROC32 and
 971   // S_LPROC32, but if we do see them, copy them straight through.
 972   case SymbolKind::S_PROCREF:
 973   case SymbolKind::S_LPROCREF:
 974     return true;
 975   // S_UDT records go in the globals stream if it is a global S_UDT.
 976   case SymbolKind::S_UDT:
 977     return IsGlobalScope;
 978   default:
 979     return false;
 980   }
 981 }
 982
 983 static void addGlobalSymbol(pdb::GSIStreamBuilder &Builder, uint16_t ModIndex,
 984                             unsigned SymOffset, const CVSymbol &Sym) {
 985   switch (Sym.kind()) {
 986   case SymbolKind::S_CONSTANT:
 987   case SymbolKind::S_UDT:
 988   case SymbolKind::S_GDATA32:
 989   case SymbolKind::S_LDATA32:
 990   case SymbolKind::S_PROCREF:
 991   case SymbolKind::S_LPROCREF:
 992     Builder.addGlobalSymbol(Sym);
 993     break;
 994   case SymbolKind::S_GPROC32:
 995   case SymbolKind::S_LPROC32: {
 996     SymbolRecordKind K = SymbolRecordKind::ProcRefSym;
 997     if (Sym.kind() == SymbolKind::S_LPROC32)
 998       K = SymbolRecordKind::LocalProcRef;
 999     ProcRefSym PS(K);
1000     PS.Module = ModIndex;
1001     // For some reason, MSVC seems to add one to this value.
1002     ++PS.Module;
1003     PS.Name = getSymbolName(Sym);
1004     PS.SumName = 0;
1005     PS.SymOffset = SymOffset;
1006     Builder.addGlobalSymbol(PS);
1007     break;
1008   }
1009   default:
1010     llvm_unreachable("Invalid symbol kind!");
1011   }
1012 }
1013
1014 void PDBLinker::mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
1015                                    std::vector<ulittle32_t *> &StringTableRefs,
1016                                    BinaryStreamRef SymData) {
1017   ArrayRef<uint8_t> SymsBuffer;
1018   cantFail(SymData.readBytes(0, SymData.getLength(), SymsBuffer));
1019   SmallVector<SymbolScope, 4> Scopes;
1020
1021   // Iterate every symbol to check if any need to be realigned, and if so, how
1022   // much space we need to allocate for them.
1023   bool NeedsRealignment = false;
1024   unsigned TotalRealignedSize = 0;
1025   auto EC = forEachCodeViewRecord<CVSymbol>(
1026       SymsBuffer, [&](CVSymbol Sym) -> llvm::Error {
1027         unsigned RealignedSize =
1028             alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
1029         NeedsRealignment |= RealignedSize != Sym.length();
1030         TotalRealignedSize += RealignedSize;
1031         return Error::success();
1032       });
1033
1034   // If any of the symbol record lengths was corrupt, ignore them all, warn
1035   // about it, and move on.
1036   if (EC) {
1037     warn("corrupt symbol records in " + File->getName());
1038     consumeError(std::move(EC));
1039     return;
1040   }
1041
1042   // If any symbol needed realignment, allocate enough contiguous memory for
1043   // them all. Typically symbol subsections are small enough that this will not
1044   // cause fragmentation.
1045   MutableArrayRef<uint8_t> AlignedSymbolMem;
1046   if (NeedsRealignment) {
1047     void *AlignedData =
1048         Alloc.Allocate(TotalRealignedSize, alignOf(CodeViewContainer::Pdb));
1049     AlignedSymbolMem = makeMutableArrayRef(
1050         reinterpret_cast<uint8_t *>(AlignedData), TotalRealignedSize);
1051   }
1052
1053   // Iterate again, this time doing the real work.
1054   unsigned CurSymOffset = File->ModuleDBI->getNextSymbolOffset();
1055   ArrayRef<uint8_t> BulkSymbols;
1056   cantFail(forEachCodeViewRecord<CVSymbol>(
1057       SymsBuffer, [&](CVSymbol Sym) -> llvm::Error {
1058         // Align the record if required.
1059         MutableArrayRef<uint8_t> RecordBytes;
1060         if (NeedsRealignment) {
1061           RecordBytes = copyAndAlignSymbol(Sym, AlignedSymbolMem);
1062           Sym = CVSymbol(Sym.kind(), RecordBytes);
1063         } else {
1064           // Otherwise, we can actually mutate the symbol directly, since we
1065           // copied it to apply relocations.
1066           RecordBytes = makeMutableArrayRef(
1067               const_cast<uint8_t *>(Sym.data().data()), Sym.length());
1068         }
1069
1070         // Discover type index references in the record. Skip it if we don't
1071         // know where they are.
1072         SmallVector<TiReference, 32> TypeRefs;
1073         if (!discoverTypeIndicesInSymbol(Sym, TypeRefs)) {
1074           log("ignoring unknown symbol record with kind 0x" +
1075               utohexstr(Sym.kind()));
1076           return Error::success();
1077         }
1078
1079         // Re-map all the type index references.
1080         remapTypesInSymbolRecord(File, Sym.kind(), RecordBytes, IndexMap,
1081                                  TypeRefs);
1082
1083         // An object file may have S_xxx_ID symbols, but these get converted to
1084         // "real" symbols in a PDB.
1085         translateIdSymbols(RecordBytes, getIDTable());
1086         Sym = CVSymbol(symbolKind(RecordBytes), RecordBytes);
1087
1088         // If this record refers to an offset in the object file's string table,
1089         // add that item to the global PDB string table and re-write the index.
1090         recordStringTableReferences(Sym.kind(), RecordBytes, StringTableRefs);
1091
1092         // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
1093         if (symbolOpensScope(Sym.kind()))
1094           scopeStackOpen(Scopes, CurSymOffset, Sym);
1095         else if (symbolEndsScope(Sym.kind()))
1096           scopeStackClose(Scopes, CurSymOffset, File);
1097
1098         // Add the symbol to the globals stream if necessary.  Do this before
1099         // adding the symbol to the module since we may need to get the next
1100         // symbol offset, and writing to the module's symbol stream will update
1101         // that offset.
1102         if (symbolGoesInGlobalsStream(Sym, Scopes.empty()))
1103           addGlobalSymbol(Builder.getGsiBuilder(),
1104                           File->ModuleDBI->getModuleIndex(), CurSymOffset, Sym);
1105
1106         if (symbolGoesInModuleStream(Sym, Scopes.empty())) {
1107           // Add symbols to the module in bulk. If this symbol is contiguous
1108           // with the previous run of symbols to add, combine the ranges. If
1109           // not, close the previous range of symbols and start a new one.
1110           if (Sym.data().data() == BulkSymbols.end()) {
1111             BulkSymbols = makeArrayRef(BulkSymbols.data(),
1112                                        BulkSymbols.size() + Sym.length());
1113           } else {
1114             File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
1115             BulkSymbols = RecordBytes;
1116           }
1117           CurSymOffset += Sym.length();
1118         }
1119         return Error::success();
1120       }));
1121
1122   // Add any remaining symbols we've accumulated.
1123   File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
1124 }
1125
1126 // Allocate memory for a .debug$S / .debug$F section and relocate it.
1127 static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
1128                                             SectionChunk &DebugChunk) {
1129   uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk.getSize());
1130   assert(DebugChunk.OutputSectionOff == 0 &&
1131          "debug sections should not be in output sections");
1132   DebugChunk.readRelocTargets();
1133   DebugChunk.writeTo(Buffer);
1134   return makeArrayRef(Buffer, DebugChunk.getSize());
1135 }
1136
1137 static pdb::SectionContrib createSectionContrib(const Chunk *C, uint32_t Modi) {
1138   OutputSection *OS = C->getOutputSection();
1139   pdb::SectionContrib SC;
1140   memset(&SC, 0, sizeof(SC));
1141   SC.ISect = OS->SectionIndex;
1142   SC.Off = C->getRVA() - OS->getRVA();
1143   SC.Size = C->getSize();
1144   if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
1145     SC.Characteristics = SecChunk->Header->Characteristics;
1146     SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
1147     ArrayRef<uint8_t> Contents = SecChunk->getContents();
1148     JamCRC CRC(0);
1149     ArrayRef<char> CharContents = makeArrayRef(
1150         reinterpret_cast<const char *>(Contents.data()), Contents.size());
1151     CRC.update(CharContents);
1152     SC.DataCrc = CRC.getCRC();
1153   } else {
1154     SC.Characteristics = OS->Header.Characteristics;
1155     // FIXME: When we start creating DBI for import libraries, use those here.
1156     SC.Imod = Modi;
1157   }
1158   SC.RelocCrc = 0; // FIXME
1159
1160   return SC;
1161 }
1162
1163 static uint32_t
1164 translateStringTableIndex(uint32_t ObjIndex,
1165                           const DebugStringTableSubsectionRef &ObjStrTable,
1166                           DebugStringTableSubsection &PdbStrTable) {
1167   auto ExpectedString = ObjStrTable.getString(ObjIndex);
1168   if (!ExpectedString) {
1169     warn("Invalid string table reference");
1170     consumeError(ExpectedString.takeError());
1171     return 0;
1172   }
1173
1174   return PdbStrTable.insert(*ExpectedString);
1175 }
1176
1177 void DebugSHandler::handleDebugS(lld::coff::SectionChunk &DebugS) {
1178   DebugSubsectionArray Subsections;
1179
1180   ArrayRef<uint8_t> RelocatedDebugContents = consumeDebugMagic(
1181       relocateDebugChunk(Linker.Alloc, DebugS), DebugS.getSectionName());
1182
1183   BinaryStreamReader Reader(RelocatedDebugContents, support::little);
1184   ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
1185
1186   for (const DebugSubsectionRecord &SS : Subsections) {
1187     switch (SS.kind()) {
1188     case DebugSubsectionKind::StringTable: {
1189       assert(!CVStrTab.valid() &&
1190              "Encountered multiple string table subsections!");
1191       ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
1192       break;
1193     }
1194     case DebugSubsectionKind::FileChecksums:
1195       assert(!Checksums.valid() &&
1196              "Encountered multiple checksum subsections!");
1197       ExitOnErr(Checksums.initialize(SS.getRecordData()));
1198       break;
1199     case DebugSubsectionKind::Lines:
1200       // We can add the relocated line table directly to the PDB without
1201       // modification because the file checksum offsets will stay the same.
1202       File.ModuleDBI->addDebugSubsection(SS);
1203       break;
1204     case DebugSubsectionKind::FrameData: {
1205       // We need to re-write string table indices here, so save off all
1206       // frame data subsections until we've processed the entire list of
1207       // subsections so that we can be sure we have the string table.
1208       DebugFrameDataSubsectionRef FDS;
1209       ExitOnErr(FDS.initialize(SS.getRecordData()));
1210       NewFpoFrames.push_back(std::move(FDS));
1211       break;
1212     }
1213     case DebugSubsectionKind::Symbols: {
1214       Linker.mergeSymbolRecords(&File, IndexMap, StringTableReferences,
1215                                 SS.getRecordData());
1216       break;
1217     }
1218     default:
1219       // FIXME: Process the rest of the subsections.
1220       break;
1221     }
1222   }
1223 }
1224
1225 void DebugSHandler::finish() {
1226   pdb::DbiStreamBuilder &DbiBuilder = Linker.Builder.getDbiBuilder();
1227
1228   // We should have seen all debug subsections across the entire object file now
1229   // which means that if a StringTable subsection and Checksums subsection were
1230   // present, now is the time to handle them.
1231   if (!CVStrTab.valid()) {
1232     if (Checksums.valid())
1233       fatal(".debug$S sections with a checksums subsection must also contain a "
1234             "string table subsection");
1235
1236     if (!StringTableReferences.empty())
1237       warn("No StringTable subsection was encountered, but there are string "
1238            "table references");
1239     return;
1240   }
1241
1242   // Rewrite string table indices in the Fpo Data and symbol records to refer to
1243   // the global PDB string table instead of the object file string table.
1244   for (DebugFrameDataSubsectionRef &FDS : NewFpoFrames) {
1245     const ulittle32_t *Reloc = FDS.getRelocPtr();
1246     for (codeview::FrameData FD : FDS) {
1247       FD.RvaStart += *Reloc;
1248       FD.FrameFunc =
1249           translateStringTableIndex(FD.FrameFunc, CVStrTab, Linker.PDBStrTab);
1250       DbiBuilder.addNewFpoData(FD);
1251     }
1252   }
1253
1254   for (ulittle32_t *Ref : StringTableReferences)
1255     *Ref = translateStringTableIndex(*Ref, CVStrTab, Linker.PDBStrTab);
1256
1257   // Make a new file checksum table that refers to offsets in the PDB-wide
1258   // string table. Generally the string table subsection appears after the
1259   // checksum table, so we have to do this after looping over all the
1260   // subsections.
1261   auto NewChecksums = make_unique<DebugChecksumsSubsection>(Linker.PDBStrTab);
1262   for (FileChecksumEntry &FC : Checksums) {
1263     SmallString<128> FileName =
1264         ExitOnErr(CVStrTab.getString(FC.FileNameOffset));
1265     pdbMakeAbsolute(FileName);
1266     ExitOnErr(Linker.Builder.getDbiBuilder().addModuleSourceFile(
1267         *File.ModuleDBI, FileName));
1268     NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
1269   }
1270   File.ModuleDBI->addDebugSubsection(std::move(NewChecksums));
1271 }
1272
1273 void PDBLinker::addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap) {
1274   if (File->wasProcessedForPDB())
1275     return;
1276   // Add a module descriptor for every object file. We need to put an absolute
1277   // path to the object into the PDB. If this is a plain object, we make its
1278   // path absolute. If it's an object in an archive, we make the archive path
1279   // absolute.
1280   bool InArchive = !File->ParentName.empty();
1281   SmallString<128> Path = InArchive ? File->ParentName : File->getName();
1282   pdbMakeAbsolute(Path);
1283   StringRef Name = InArchive ? File->getName() : StringRef(Path);
1284
1285   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
1286   File->ModuleDBI = &ExitOnErr(DbiBuilder.addModuleInfo(Name));
1287   File->ModuleDBI->setObjFileName(Path);
1288
1289   auto Chunks = File->getChunks();
1290   uint32_t Modi = File->ModuleDBI->getModuleIndex();
1291   for (Chunk *C : Chunks) {
1292     auto *SecChunk = dyn_cast<SectionChunk>(C);
1293     if (!SecChunk || !SecChunk->Live)
1294       continue;
1295     pdb::SectionContrib SC = createSectionContrib(SecChunk, Modi);
1296     File->ModuleDBI->setFirstSectionContrib(SC);
1297     break;
1298   }
1299
1300   // Before we can process symbol substreams from .debug$S, we need to process
1301   // type information, file checksums, and the string table.  Add type info to
1302   // the PDB first, so that we can get the map from object file type and item
1303   // indices to PDB type and item indices.
1304   CVIndexMap ObjectIndexMap;
1305   auto IndexMapResult =
1306       mergeDebugT(File, ExternIndexMap ? ExternIndexMap : &ObjectIndexMap);
1307
1308   // If the .debug$T sections fail to merge, assume there is no debug info.
1309   if (!IndexMapResult) {
1310     if (!Config->WarnDebugInfoUnusable) {
1311       consumeError(IndexMapResult.takeError());
1312       return;
1313     }
1314     StringRef FileName = sys::path::filename(Path);
1315     warn("Cannot use debug info for '" + FileName + "' [LNK4099]\n" +
1316          ">>> failed to load reference " +
1317          StringRef(toString(IndexMapResult.takeError())));
1318     return;
1319   }
1320
1321   ScopedTimer T(SymbolMergingTimer);
1322
1323   DebugSHandler DSH(*this, *File, *IndexMapResult);
1324   // Now do all live .debug$S and .debug$F sections.
1325   for (SectionChunk *DebugChunk : File->getDebugChunks()) {
1326     if (!DebugChunk->Live || DebugChunk->getSize() == 0)
1327       continue;
1328
1329     if (DebugChunk->getSectionName() == ".debug$S") {
1330       DSH.handleDebugS(*DebugChunk);
1331       continue;
1332     }
1333
1334     if (DebugChunk->getSectionName() == ".debug$F") {
1335       ArrayRef<uint8_t> RelocatedDebugContents =
1336           relocateDebugChunk(Alloc, *DebugChunk);
1337
1338       FixedStreamArray<object::FpoData> FpoRecords;
1339       BinaryStreamReader Reader(RelocatedDebugContents, support::little);
1340       uint32_t Count = RelocatedDebugContents.size() / sizeof(object::FpoData);
1341       ExitOnErr(Reader.readArray(FpoRecords, Count));
1342
1343       // These are already relocated and don't refer to the string table, so we
1344       // can just copy it.
1345       for (const object::FpoData &FD : FpoRecords)
1346         DbiBuilder.addOldFpoData(FD);
1347       continue;
1348     }
1349   }
1350
1351   // Do any post-processing now that all .debug$S sections have been processed.
1352   DSH.finish();
1353 }
1354
1355 static PublicSym32 createPublic(Defined *Def) {
1356   PublicSym32 Pub(SymbolKind::S_PUB32);
1357   Pub.Name = Def->getName();
1358   if (auto *D = dyn_cast<DefinedCOFF>(Def)) {
1359     if (D->getCOFFSymbol().isFunctionDefinition())
1360       Pub.Flags = PublicSymFlags::Function;
1361   } else if (isa<DefinedImportThunk>(Def)) {
1362     Pub.Flags = PublicSymFlags::Function;
1363   }
1364
1365   OutputSection *OS = Def->getChunk()->getOutputSection();
1366   assert(OS && "all publics should be in final image");
1367   Pub.Offset = Def->getRVA() - OS->getRVA();
1368   Pub.Segment = OS->SectionIndex;
1369   return Pub;
1370 }
1371
1372 // Add all object files to the PDB. Merge .debug$T sections into IpiData and
1373 // TpiData.
1374 void PDBLinker::addObjectsToPDB() {
1375   ScopedTimer T1(AddObjectsTimer);
1376   for (ObjFile *File : ObjFile::Instances)
1377     addObjFile(File);
1378
1379   Builder.getStringTableBuilder().setStrings(PDBStrTab);
1380   T1.stop();
1381
1382   // Construct TPI and IPI stream contents.
1383   ScopedTimer T2(TpiStreamLayoutTimer);
1384   addTypeInfo(Builder.getTpiBuilder(), getTypeTable());
1385   addTypeInfo(Builder.getIpiBuilder(), getIDTable());
1386   T2.stop();
1387
1388   ScopedTimer T3(GlobalsLayoutTimer);
1389   // Compute the public and global symbols.
1390   auto &GsiBuilder = Builder.getGsiBuilder();
1391   std::vector<PublicSym32> Publics;
1392   Symtab->forEachSymbol([&Publics](Symbol *S) {
1393     // Only emit defined, live symbols that have a chunk.
1394     auto *Def = dyn_cast<Defined>(S);
1395     if (Def && Def->isLive() && Def->getChunk())
1396       Publics.push_back(createPublic(Def));
1397   });
1398
1399   if (!Publics.empty()) {
1400     // Sort the public symbols and add them to the stream.
1401     sort(parallel::par, Publics.begin(), Publics.end(),
1402          [](const PublicSym32 &L, const PublicSym32 &R) {
1403            return L.Name < R.Name;
1404          });
1405     for (const PublicSym32 &Pub : Publics)
1406       GsiBuilder.addPublicSymbol(Pub);
1407   }
1408 }
1409
1410 void PDBLinker::addNatvisFiles() {
1411   for (StringRef File : Config->NatvisFiles) {
1412     ErrorOr<std::unique_ptr<MemoryBuffer>> DataOrErr =
1413         MemoryBuffer::getFile(File);
1414     if (!DataOrErr) {
1415       warn("Cannot open input file: " + File);
1416       continue;
1417     }
1418     Builder.addInjectedSource(File, std::move(*DataOrErr));
1419   }
1420 }
1421
1422 static codeview::CPUType toCodeViewMachine(COFF::MachineTypes Machine) {
1423   switch (Machine) {
1424   case COFF::IMAGE_FILE_MACHINE_AMD64:
1425     return codeview::CPUType::X64;
1426   case COFF::IMAGE_FILE_MACHINE_ARM:
1427     return codeview::CPUType::ARM7;
1428   case COFF::IMAGE_FILE_MACHINE_ARM64:
1429     return codeview::CPUType::ARM64;
1430   case COFF::IMAGE_FILE_MACHINE_ARMNT:
1431     return codeview::CPUType::ARMNT;
1432   case COFF::IMAGE_FILE_MACHINE_I386:
1433     return codeview::CPUType::Intel80386;
1434   default:
1435     llvm_unreachable("Unsupported CPU Type");
1436   }
1437 }
1438
1439 // Mimic MSVC which surrounds arguments containing whitespace with quotes.
1440 // Double double-quotes are handled, so that the resulting string can be
1441 // executed again on the cmd-line.
1442 static std::string quote(ArrayRef<StringRef> Args) {
1443   std::string R;
1444   R.reserve(256);
1445   for (StringRef A : Args) {
1446     if (!R.empty())
1447       R.push_back(' ');
1448     bool HasWS = A.find(' ') != StringRef::npos;
1449     bool HasQ = A.find('"') != StringRef::npos;
1450     if (HasWS || HasQ)
1451       R.push_back('"');
1452     if (HasQ) {
1453       SmallVector<StringRef, 4> S;
1454       A.split(S, '"');
1455       R.append(join(S, "\"\""));
1456     } else {
1457       R.append(A);
1458     }
1459     if (HasWS || HasQ)
1460       R.push_back('"');
1461   }
1462   return R;
1463 }
1464
1465 static void addCommonLinkerModuleSymbols(StringRef Path,
1466                                          pdb::DbiModuleDescriptorBuilder &Mod,
1467                                          BumpPtrAllocator &Allocator) {
1468   ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
1469   Compile3Sym CS(SymbolRecordKind::Compile3Sym);
1470   EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
1471
1472   ONS.Name = "* Linker *";
1473   ONS.Signature = 0;
1474
1475   CS.Machine = toCodeViewMachine(Config->Machine);
1476   // Interestingly, if we set the string to 0.0.0.0, then when trying to view
1477   // local variables WinDbg emits an error that private symbols are not present.
1478   // By setting this to a valid MSVC linker version string, local variables are
1479   // displayed properly.   As such, even though it is not representative of
1480   // LLVM's version information, we need this for compatibility.
1481   CS.Flags = CompileSym3Flags::None;
1482   CS.VersionBackendBuild = 25019;
1483   CS.VersionBackendMajor = 14;
1484   CS.VersionBackendMinor = 10;
1485   CS.VersionBackendQFE = 0;
1486
1487   // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
1488   // linker module (which is by definition a backend), so we don't need to do
1489   // anything here.  Also, it seems we can use "LLVM Linker" for the linker name
1490   // without any problems.  Only the backend version has to be hardcoded to a
1491   // magic number.
1492   CS.VersionFrontendBuild = 0;
1493   CS.VersionFrontendMajor = 0;
1494   CS.VersionFrontendMinor = 0;
1495   CS.VersionFrontendQFE = 0;
1496   CS.Version = "LLVM Linker";
1497   CS.setLanguage(SourceLanguage::Link);
1498
1499   ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
1500   std::string ArgStr = quote(Args);
1501   EBS.Fields.push_back("cwd");
1502   SmallString<64> cwd;
1503   if (Config->PDBSourcePath.empty())
1504     sys::fs::current_path(cwd);
1505   else
1506     cwd = Config->PDBSourcePath;
1507   EBS.Fields.push_back(cwd);
1508   EBS.Fields.push_back("exe");
1509   SmallString<64> exe = Config->Argv[0];
1510   pdbMakeAbsolute(exe);
1511   EBS.Fields.push_back(exe);
1512   EBS.Fields.push_back("pdb");
1513   EBS.Fields.push_back(Path);
1514   EBS.Fields.push_back("cmd");
1515   EBS.Fields.push_back(ArgStr);
1516   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
1517       ONS, Allocator, CodeViewContainer::Pdb));
1518   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
1519       CS, Allocator, CodeViewContainer::Pdb));
1520   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
1521       EBS, Allocator, CodeViewContainer::Pdb));
1522 }
1523
1524 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
1525                                          OutputSection &OS,
1526                                          BumpPtrAllocator &Allocator) {
1527   SectionSym Sym(SymbolRecordKind::SectionSym);
1528   Sym.Alignment = 12; // 2^12 = 4KB
1529   Sym.Characteristics = OS.Header.Characteristics;
1530   Sym.Length = OS.getVirtualSize();
1531   Sym.Name = OS.Name;
1532   Sym.Rva = OS.getRVA();
1533   Sym.SectionNumber = OS.SectionIndex;
1534   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
1535       Sym, Allocator, CodeViewContainer::Pdb));
1536 }
1537
1538 // Creates a PDB file.
1539 void coff::createPDB(SymbolTable *Symtab,
1540                      ArrayRef<OutputSection *> OutputSections,
1541                      ArrayRef<uint8_t> SectionTable,
1542                      llvm::codeview::DebugInfo *BuildId) {
1543   ScopedTimer T1(TotalPdbLinkTimer);
1544   PDBLinker PDB(Symtab);
1545
1546   PDB.initialize(BuildId);
1547   PDB.addObjectsToPDB();
1548   PDB.addSections(OutputSections, SectionTable);
1549   PDB.addNatvisFiles();
1550
1551   ScopedTimer T2(DiskCommitTimer);
1552   codeview::GUID Guid;
1553   PDB.commit(&Guid);
1554   memcpy(&BuildId->PDB70.Signature, &Guid, 16);
1555 }
1556
1557 void PDBLinker::initialize(llvm::codeview::DebugInfo *BuildId) {
1558   ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
1559
1560   BuildId->Signature.CVSignature = OMF::Signature::PDB70;
1561   // Signature is set to a hash of the PDB contents when the PDB is done.
1562   memset(BuildId->PDB70.Signature, 0, 16);
1563   BuildId->PDB70.Age = 1;
1564
1565   // Create streams in MSF for predefined streams, namely
1566   // PDB, TPI, DBI and IPI.
1567   for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
1568     ExitOnErr(Builder.getMsfBuilder().addStream(0));
1569
1570   // Add an Info stream.
1571   auto &InfoBuilder = Builder.getInfoBuilder();
1572   InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
1573   InfoBuilder.setHashPDBContentsToGUID(true);
1574
1575   // Add an empty DBI stream.
1576   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
1577   DbiBuilder.setAge(BuildId->PDB70.Age);
1578   DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
1579   DbiBuilder.setMachineType(Config->Machine);
1580   // Technically we are not link.exe 14.11, but there are known cases where
1581   // debugging tools on Windows expect Microsoft-specific version numbers or
1582   // they fail to work at all.  Since we know we produce PDBs that are
1583   // compatible with LINK 14.11, we set that version number here.
1584   DbiBuilder.setBuildNumber(14, 11);
1585 }
1586
1587 void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
1588                             ArrayRef<uint8_t> SectionTable) {
1589   // It's not entirely clear what this is, but the * Linker * module uses it.
1590   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
1591   NativePath = Config->PDBPath;
1592   pdbMakeAbsolute(NativePath);
1593   uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
1594   auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
1595   LinkerModule.setPdbFilePathNI(PdbFilePathNI);
1596   addCommonLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
1597
1598   // Add section contributions. They must be ordered by ascending RVA.
1599   for (OutputSection *OS : OutputSections) {
1600     addLinkerModuleSectionSymbol(LinkerModule, *OS, Alloc);
1601     for (Chunk *C : OS->Chunks) {
1602       pdb::SectionContrib SC =
1603           createSectionContrib(C, LinkerModule.getModuleIndex());
1604       Builder.getDbiBuilder().addSectionContrib(SC);
1605     }
1606   }
1607
1608   // Add Section Map stream.
1609   ArrayRef<object::coff_section> Sections = {
1610       (const object::coff_section *)SectionTable.data(),
1611       SectionTable.size() / sizeof(object::coff_section)};
1612   SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
1613   DbiBuilder.setSectionMap(SectionMap);
1614
1615   // Add COFF section header stream.
1616   ExitOnErr(
1617       DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
1618 }
1619
1620 void PDBLinker::commit(codeview::GUID *Guid) {
1621   // Write to a file.
1622   ExitOnErr(Builder.commit(Config->PDBPath, Guid));
1623 }
1624
1625 static Expected<StringRef>
1626 getFileName(const DebugStringTableSubsectionRef &Strings,
1627             const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID) {
1628   auto Iter = Checksums.getArray().at(FileID);
1629   if (Iter == Checksums.getArray().end())
1630     return make_error<CodeViewError>(cv_error_code::no_records);
1631   uint32_t Offset = Iter->FileNameOffset;
1632   return Strings.getString(Offset);
1633 }
1634
1635 static uint32_t getSecrelReloc() {
1636   switch (Config->Machine) {
1637   case AMD64:
1638     return COFF::IMAGE_REL_AMD64_SECREL;
1639   case I386:
1640     return COFF::IMAGE_REL_I386_SECREL;
1641   case ARMNT:
1642     return COFF::IMAGE_REL_ARM_SECREL;
1643   case ARM64:
1644     return COFF::IMAGE_REL_ARM64_SECREL;
1645   default:
1646     llvm_unreachable("unknown machine type");
1647   }
1648 }
1649
1650 // Try to find a line table for the given offset Addr into the given chunk C.
1651 // If a line table was found, the line table, the string and checksum tables
1652 // that are used to interpret the line table, and the offset of Addr in the line
1653 // table are stored in the output arguments. Returns whether a line table was
1654 // found.
1655 static bool findLineTable(const SectionChunk *C, uint32_t Addr,
1656                           DebugStringTableSubsectionRef &CVStrTab,
1657                           DebugChecksumsSubsectionRef &Checksums,
1658                           DebugLinesSubsectionRef &Lines,
1659                           uint32_t &OffsetInLinetable) {
1660   ExitOnError ExitOnErr;
1661   uint32_t SecrelReloc = getSecrelReloc();
1662
1663   for (SectionChunk *DbgC : C->File->getDebugChunks()) {
1664     if (DbgC->getSectionName() != ".debug$S")
1665       continue;
1666
1667     // Build a mapping of SECREL relocations in DbgC that refer to C.
1668     DenseMap<uint32_t, uint32_t> Secrels;
1669     for (const coff_relocation &R : DbgC->Relocs) {
1670       if (R.Type != SecrelReloc)
1671         continue;
1672
1673       if (auto *S = dyn_cast_or_null<DefinedRegular>(
1674               C->File->getSymbols()[R.SymbolTableIndex]))
1675         if (S->getChunk() == C)
1676           Secrels[R.VirtualAddress] = S->getValue();
1677     }
1678
1679     ArrayRef<uint8_t> Contents =
1680         consumeDebugMagic(DbgC->getContents(), ".debug$S");
1681     DebugSubsectionArray Subsections;
1682     BinaryStreamReader Reader(Contents, support::little);
1683     ExitOnErr(Reader.readArray(Subsections, Contents.size()));
1684
1685     for (const DebugSubsectionRecord &SS : Subsections) {
1686       switch (SS.kind()) {
1687       case DebugSubsectionKind::StringTable: {
1688         assert(!CVStrTab.valid() &&
1689                "Encountered multiple string table subsections!");
1690         ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
1691         break;
1692       }
1693       case DebugSubsectionKind::FileChecksums:
1694         assert(!Checksums.valid() &&
1695                "Encountered multiple checksum subsections!");
1696         ExitOnErr(Checksums.initialize(SS.getRecordData()));
1697         break;
1698       case DebugSubsectionKind::Lines: {
1699         ArrayRef<uint8_t> Bytes;
1700         auto Ref = SS.getRecordData();
1701         ExitOnErr(Ref.readLongestContiguousChunk(0, Bytes));
1702         size_t OffsetInDbgC = Bytes.data() - DbgC->getContents().data();
1703
1704         // Check whether this line table refers to C.
1705         auto I = Secrels.find(OffsetInDbgC);
1706         if (I == Secrels.end())
1707           break;
1708
1709         // Check whether this line table covers Addr in C.
1710         DebugLinesSubsectionRef LinesTmp;
1711         ExitOnErr(LinesTmp.initialize(BinaryStreamReader(Ref)));
1712         uint32_t OffsetInC = I->second + LinesTmp.header()->RelocOffset;
1713         if (Addr < OffsetInC || Addr >= OffsetInC + LinesTmp.header()->CodeSize)
1714           break;
1715
1716         assert(!Lines.header() &&
1717                "Encountered multiple line tables for function!");
1718         ExitOnErr(Lines.initialize(BinaryStreamReader(Ref)));
1719         OffsetInLinetable = Addr - OffsetInC;
1720         break;
1721       }
1722       default:
1723         break;
1724       }
1725
1726       if (CVStrTab.valid() && Checksums.valid() && Lines.header())
1727         return true;
1728     }
1729   }
1730
1731   return false;
1732 }
1733
1734 // Use CodeView line tables to resolve a file and line number for the given
1735 // offset into the given chunk and return them, or {"", 0} if a line table was
1736 // not found.
1737 std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *C,
1738                                                  uint32_t Addr) {
1739   ExitOnError ExitOnErr;
1740
1741   DebugStringTableSubsectionRef CVStrTab;
1742   DebugChecksumsSubsectionRef Checksums;
1743   DebugLinesSubsectionRef Lines;
1744   uint32_t OffsetInLinetable;
1745
1746   if (!findLineTable(C, Addr, CVStrTab, Checksums, Lines, OffsetInLinetable))
1747     return {"", 0};
1748
1749   Optional<uint32_t> NameIndex;
1750   Optional<uint32_t> LineNumber;
1751   for (LineColumnEntry &Entry : Lines) {
1752     for (const LineNumberEntry &LN : Entry.LineNumbers) {
1753       LineInfo LI(LN.Flags);
1754       if (LN.Offset > OffsetInLinetable) {
1755         if (!NameIndex) {
1756           NameIndex = Entry.NameIndex;
1757           LineNumber = LI.getStartLine();
1758         }
1759         StringRef Filename =
1760             ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex));
1761         return {Filename, *LineNumber};
1762       }
1763       NameIndex = Entry.NameIndex;
1764       LineNumber = LI.getStartLine();
1765     }
1766   }
1767   if (!NameIndex)
1768     return {"", 0};
1769   StringRef Filename = ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex));
1770   return {Filename, *LineNumber};
1771 }