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 "Error.h"
  14 #include "SymbolTable.h"
  15 #include "Symbols.h"
  16 #include "llvm/DebugInfo/CodeView/CVDebugRecord.h"
  17 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
  18 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  19 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
  20 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
  21 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
  22 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
  23 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
  24 #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
  25 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
  26 #include "llvm/DebugInfo/MSF/MSFCommon.h"
  27 #include "llvm/DebugInfo/PDB/GenericError.h"
  28 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
  29 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  30 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
  31 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
  32 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
  33 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
  34 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  35 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
  36 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
  37 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  38 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
  39 #include "llvm/DebugInfo/PDB/PDB.h"
  40 #include "llvm/Object/COFF.h"
  41 #include "llvm/Support/BinaryByteStream.h"
  42 #include "llvm/Support/Endian.h"
  43 #include "llvm/Support/FileOutputBuffer.h"
  44 #include "llvm/Support/Path.h"
  45 #include "llvm/Support/ScopedPrinter.h"
  46 #include <memory>
  47
  48 using namespace lld;
  49 using namespace lld::coff;
  50 using namespace llvm;
  51 using namespace llvm::codeview;
  52
  53 using llvm::object::coff_section;
  54
  55 static ExitOnError ExitOnErr;
  56
  57 namespace {
  58 /// Map from type index and item index in a type server PDB to the
  59 /// corresponding index in the destination PDB.
  60 struct CVIndexMap {
  61   SmallVector<TypeIndex, 0> TPIMap;
  62   SmallVector<TypeIndex, 0> IPIMap;
  63   bool IsTypeServerMap = false;
  64 };
  65
  66 class PDBLinker {
  67 public:
  68   PDBLinker(SymbolTable *Symtab)
  69       : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
  70         IDTable(Alloc) {}
  71
  72   /// Emit the basic PDB structure: initial streams, headers, etc.
  73   void initialize(const llvm::codeview::DebugInfo *DI);
  74
  75   /// Link CodeView from each object file in the symbol table into the PDB.
  76   void addObjectsToPDB();
  77
  78   /// Link CodeView from a single object file into the PDB.
  79   void addObjectFile(ObjectFile *File);
  80
  81   /// Produce a mapping from the type and item indices used in the object
  82   /// file to those in the destination PDB.
  83   ///
  84   /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
  85   /// and IPI from the type server PDB and return a map for it. Each unique type
  86   /// server PDB is merged at most once, so this may return an existing index
  87   /// mapping.
  88   ///
  89   /// If the object does not use a type server PDB (compiled with /Z7), we merge
  90   /// all the type and item records from the .debug$S stream and fill in the
  91   /// caller-provided ObjectIndexMap.
  92   const CVIndexMap &mergeDebugT(ObjectFile *File, CVIndexMap &ObjectIndexMap);
  93
  94   const CVIndexMap &maybeMergeTypeServerPDB(ObjectFile *File,
  95                                             TypeServer2Record &TS);
  96
  97   /// Add the section map and section contributions to the PDB.
  98   void addSections(ArrayRef<uint8_t> SectionTable);
  99
 100   /// Write the PDB to disk.
 101   void commit();
 102
 103 private:
 104   BumpPtrAllocator Alloc;
 105
 106   SymbolTable *Symtab;
 107
 108   pdb::PDBFileBuilder Builder;
 109
 110   /// Type records that will go into the PDB TPI stream.
 111   TypeTableBuilder TypeTable;
 112
 113   /// Item records that will go into the PDB IPI stream.
 114   TypeTableBuilder IDTable;
 115
 116   /// PDBs use a single global string table for filenames in the file checksum
 117   /// table.
 118   DebugStringTableSubsection PDBStrTab;
 119
 120   llvm::SmallString<128> NativePath;
 121
 122   std::vector<pdb::SecMapEntry> SectionMap;
 123
 124   /// Type index mappings of type server PDBs that we've loaded so far.
 125   std::map<GUID, CVIndexMap> TypeServerIndexMappings;
 126 };
 127 }
 128
 129 // Returns a list of all SectionChunks.
 130 static void addSectionContribs(SymbolTable *Symtab,
 131                                pdb::DbiStreamBuilder &DbiBuilder) {
 132   for (Chunk *C : Symtab->getChunks())
 133     if (auto *SC = dyn_cast<SectionChunk>(C))
 134       DbiBuilder.addSectionContrib(SC->File->ModuleDBI, SC->Header);
 135 }
 136
 137 static SectionChunk *findByName(std::vector<SectionChunk *> &Sections,
 138                                 StringRef Name) {
 139   for (SectionChunk *C : Sections)
 140     if (C->getSectionName() == Name)
 141       return C;
 142   return nullptr;
 143 }
 144
 145 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
 146                                            StringRef SecName) {
 147   // First 4 bytes are section magic.
 148   if (Data.size() < 4)
 149     fatal(SecName + " too short");
 150   if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
 151     fatal(SecName + " has an invalid magic");
 152   return Data.slice(4);
 153 }
 154
 155 static ArrayRef<uint8_t> getDebugSection(ObjectFile *File, StringRef SecName) {
 156   if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
 157     return consumeDebugMagic(Sec->getContents(), SecName);
 158   return {};
 159 }
 160
 161 static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
 162                         TypeTableBuilder &TypeTable) {
 163   // Start the TPI or IPI stream header.
 164   TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
 165
 166   // Flatten the in memory type table.
 167   TypeTable.ForEachRecord([&](TypeIndex TI, ArrayRef<uint8_t> Rec) {
 168     // FIXME: Hash types.
 169     TpiBuilder.addTypeRecord(Rec, None);
 170   });
 171 }
 172
 173 static Optional<TypeServer2Record>
 174 maybeReadTypeServerRecord(CVTypeArray &Types) {
 175   auto I = Types.begin();
 176   if (I == Types.end())
 177     return None;
 178   const CVType &Type = *I;
 179   if (Type.kind() != LF_TYPESERVER2)
 180     return None;
 181   TypeServer2Record TS;
 182   if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type), TS))
 183     fatal(EC, "error reading type server record");
 184   return std::move(TS);
 185 }
 186
 187 const CVIndexMap &PDBLinker::mergeDebugT(ObjectFile *File,
 188                                          CVIndexMap &ObjectIndexMap) {
 189   ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
 190   if (Data.empty())
 191     return ObjectIndexMap;
 192
 193   BinaryByteStream Stream(Data, support::little);
 194   CVTypeArray Types;
 195   BinaryStreamReader Reader(Stream);
 196   if (auto EC = Reader.readArray(Types, Reader.getLength()))
 197     fatal(EC, "Reader::readArray failed");
 198
 199   // Look through type servers. If we've already seen this type server, don't
 200   // merge any type information.
 201   if (Optional<TypeServer2Record> TS = maybeReadTypeServerRecord(Types))
 202     return maybeMergeTypeServerPDB(File, *TS);
 203
 204   // This is a /Z7 object. Fill in the temporary, caller-provided
 205   // ObjectIndexMap.
 206   if (auto Err = mergeTypeAndIdRecords(IDTable, TypeTable,
 207                                        ObjectIndexMap.TPIMap, Types))
 208     fatal(Err, "codeview::mergeTypeAndIdRecords failed");
 209   return ObjectIndexMap;
 210 }
 211
 212 static Expected<std::unique_ptr<pdb::NativeSession>>
 213 tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
 214   std::unique_ptr<pdb::IPDBSession> ThisSession;
 215   if (auto EC =
 216           pdb::loadDataForPDB(pdb::PDB_ReaderType::Native, TSPath, ThisSession))
 217     return std::move(EC);
 218
 219   std::unique_ptr<pdb::NativeSession> NS(
 220       static_cast<pdb::NativeSession *>(ThisSession.release()));
 221   pdb::PDBFile &File = NS->getPDBFile();
 222   auto ExpectedInfo = File.getPDBInfoStream();
 223   // All PDB Files should have an Info stream.
 224   if (!ExpectedInfo)
 225     return ExpectedInfo.takeError();
 226
 227   // Just because a file with a matching name was found and it was an actual
 228   // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
 229   // must match the GUID specified in the TypeServer2 record.
 230   if (ExpectedInfo->getGuid() != GuidFromObj)
 231     return make_error<pdb::GenericError>(
 232         pdb::generic_error_code::type_server_not_found, TSPath);
 233
 234   return std::move(NS);
 235 }
 236
 237 const CVIndexMap &PDBLinker::maybeMergeTypeServerPDB(ObjectFile *File,
 238                                                      TypeServer2Record &TS) {
 239   // First, check if we already loaded a PDB with this GUID. Return the type
 240   // index mapping if we have it.
 241   auto Insertion = TypeServerIndexMappings.insert({TS.getGuid(), CVIndexMap()});
 242   CVIndexMap &IndexMap = Insertion.first->second;
 243   if (!Insertion.second)
 244     return IndexMap;
 245
 246   // Mark this map as a type server map.
 247   IndexMap.IsTypeServerMap = true;
 248
 249   // Check for a PDB at:
 250   // 1. The given file path
 251   // 2. Next to the object file or archive file
 252   auto ExpectedSession = tryToLoadPDB(TS.getGuid(), TS.getName());
 253   if (!ExpectedSession) {
 254     consumeError(ExpectedSession.takeError());
 255     StringRef LocalPath =
 256         !File->ParentName.empty() ? File->ParentName : File->getName();
 257     SmallString<128> Path = sys::path::parent_path(LocalPath);
 258     sys::path::append(
 259         Path, sys::path::filename(TS.getName(), sys::path::Style::windows));
 260     ExpectedSession = tryToLoadPDB(TS.getGuid(), Path);
 261   }
 262   if (auto E = ExpectedSession.takeError())
 263     fatal(E, "Type server PDB was not found");
 264
 265   // Merge TPI first, because the IPI stream will reference type indices.
 266   auto ExpectedTpi = (*ExpectedSession)->getPDBFile().getPDBTpiStream();
 267   if (auto E = ExpectedTpi.takeError())
 268     fatal(E, "Type server does not have TPI stream");
 269   if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
 270                                   ExpectedTpi->typeArray()))
 271     fatal(Err, "codeview::mergeTypeRecords failed");
 272
 273   // Merge IPI.
 274   auto ExpectedIpi = (*ExpectedSession)->getPDBFile().getPDBIpiStream();
 275   if (auto E = ExpectedIpi.takeError())
 276     fatal(E, "Type server does not have TPI stream");
 277   if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
 278                                 ExpectedIpi->typeArray()))
 279     fatal(Err, "codeview::mergeIdRecords failed");
 280
 281   return IndexMap;
 282 }
 283
 284 static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
 285   if (TI.isSimple())
 286     return true;
 287   if (TI.toArrayIndex() >= TypeIndexMap.size())
 288     return false;
 289   TI = TypeIndexMap[TI.toArrayIndex()];
 290   return true;
 291 }
 292
 293 static void remapTypesInSymbolRecord(ObjectFile *File,
 294                                      MutableArrayRef<uint8_t> Contents,
 295                                      const CVIndexMap &IndexMap,
 296                                      ArrayRef<TiReference> TypeRefs) {
 297   for (const TiReference &Ref : TypeRefs) {
 298     unsigned ByteSize = Ref.Count * sizeof(TypeIndex);
 299     if (Contents.size() < Ref.Offset + ByteSize)
 300       fatal("symbol record too short");
 301
 302     // This can be an item index or a type index. Choose the appropriate map.
 303     ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap;
 304     if (Ref.Kind == TiRefKind::IndexRef && IndexMap.IsTypeServerMap)
 305       TypeOrItemMap = IndexMap.IPIMap;
 306
 307     MutableArrayRef<TypeIndex> TIs(
 308         reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count);
 309     for (TypeIndex &TI : TIs) {
 310       if (!remapTypeIndex(TI, TypeOrItemMap)) {
 311         TI = TypeIndex(SimpleTypeKind::NotTranslated);
 312         log("ignoring symbol record in " + File->getName() +
 313             " with bad type index 0x" + utohexstr(TI.getIndex()));
 314         continue;
 315       }
 316     }
 317   }
 318 }
 319
 320 /// MSVC translates S_PROC_ID_END to S_END.
 321 uint16_t canonicalizeSymbolKind(SymbolKind Kind) {
 322   if (Kind == SymbolKind::S_PROC_ID_END)
 323     return SymbolKind::S_END;
 324   return Kind;
 325 }
 326
 327 /// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
 328 /// The object file may not be aligned.
 329 static MutableArrayRef<uint8_t> copySymbolForPdb(const CVSymbol &Sym,
 330                                                  BumpPtrAllocator &Alloc) {
 331   size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
 332   assert(Size >= 4 && "record too short");
 333   assert(Size <= MaxRecordLength && "record too long");
 334   void *Mem = Alloc.Allocate(Size, 4);
 335
 336   // Copy the symbol record and zero out any padding bytes.
 337   MutableArrayRef<uint8_t> NewData(reinterpret_cast<uint8_t *>(Mem), Size);
 338   memcpy(NewData.data(), Sym.data().data(), Sym.length());
 339   memset(NewData.data() + Sym.length(), 0, Size - Sym.length());
 340
 341   // Update the record prefix length. It should point to the beginning of the
 342   // next record. MSVC does some canonicalization of the record kind, so we do
 343   // that as well.
 344   auto *Prefix = reinterpret_cast<RecordPrefix *>(Mem);
 345   Prefix->RecordKind = canonicalizeSymbolKind(Sym.kind());
 346   Prefix->RecordLen = Size - 2;
 347   return NewData;
 348 }
 349
 350 /// Return true if this symbol opens a scope. This implies that the symbol has
 351 /// "parent" and "end" fields, which contain the offset of the S_END or
 352 /// S_INLINESITE_END record.
 353 static bool symbolOpensScope(SymbolKind Kind) {
 354   switch (Kind) {
 355   case SymbolKind::S_GPROC32:
 356   case SymbolKind::S_LPROC32:
 357   case SymbolKind::S_LPROC32_ID:
 358   case SymbolKind::S_GPROC32_ID:
 359   case SymbolKind::S_BLOCK32:
 360   case SymbolKind::S_SEPCODE:
 361   case SymbolKind::S_THUNK32:
 362   case SymbolKind::S_INLINESITE:
 363   case SymbolKind::S_INLINESITE2:
 364     return true;
 365   default:
 366     break;
 367   }
 368   return false;
 369 }
 370
 371 static bool symbolEndsScope(SymbolKind Kind) {
 372   switch (Kind) {
 373   case SymbolKind::S_END:
 374   case SymbolKind::S_PROC_ID_END:
 375   case SymbolKind::S_INLINESITE_END:
 376     return true;
 377   default:
 378     break;
 379   }
 380   return false;
 381 }
 382
 383 struct ScopeRecord {
 384   ulittle32_t PtrParent;
 385   ulittle32_t PtrEnd;
 386 };
 387
 388 struct SymbolScope {
 389   ScopeRecord *OpeningRecord;
 390   uint32_t ScopeOffset;
 391 };
 392
 393 static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
 394                            uint32_t CurOffset, CVSymbol &Sym) {
 395   assert(symbolOpensScope(Sym.kind()));
 396   SymbolScope S;
 397   S.ScopeOffset = CurOffset;
 398   S.OpeningRecord = const_cast<ScopeRecord *>(
 399       reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
 400   S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
 401   Stack.push_back(S);
 402 }
 403
 404 static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
 405                             uint32_t CurOffset, ObjectFile *File) {
 406   if (Stack.empty()) {
 407     warn("symbol scopes are not balanced in " + File->getName());
 408     return;
 409   }
 410   SymbolScope S = Stack.pop_back_val();
 411   S.OpeningRecord->PtrEnd = CurOffset;
 412 }
 413
 414 static void mergeSymbolRecords(BumpPtrAllocator &Alloc, ObjectFile *File,
 415                                const CVIndexMap &IndexMap,
 416                                BinaryStreamRef SymData) {
 417   // FIXME: Improve error recovery by warning and skipping records when
 418   // possible.
 419   CVSymbolArray Syms;
 420   BinaryStreamReader Reader(SymData);
 421   ExitOnErr(Reader.readArray(Syms, Reader.getLength()));
 422   SmallVector<SymbolScope, 4> Scopes;
 423   for (const CVSymbol &Sym : Syms) {
 424     // Discover type index references in the record. Skip it if we don't know
 425     // where they are.
 426     SmallVector<TiReference, 32> TypeRefs;
 427     if (!discoverTypeIndices(Sym, TypeRefs)) {
 428       log("ignoring unknown symbol record with kind 0x" + utohexstr(Sym.kind()));
 429       continue;
 430     }
 431
 432     // Copy the symbol record so we can mutate it.
 433     MutableArrayRef<uint8_t> NewData = copySymbolForPdb(Sym, Alloc);
 434
 435     // Re-map all the type index references.
 436     MutableArrayRef<uint8_t> Contents =
 437         NewData.drop_front(sizeof(RecordPrefix));
 438     remapTypesInSymbolRecord(File, Contents, IndexMap, TypeRefs);
 439
 440     // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
 441     CVSymbol NewSym(Sym.kind(), NewData);
 442     if (symbolOpensScope(Sym.kind()))
 443       scopeStackOpen(Scopes, File->ModuleDBI->getNextSymbolOffset(), NewSym);
 444     else if (symbolEndsScope(Sym.kind()))
 445       scopeStackClose(Scopes, File->ModuleDBI->getNextSymbolOffset(), File);
 446
 447     // Add the symbol to the module.
 448     File->ModuleDBI->addSymbol(NewSym);
 449   }
 450 }
 451
 452 // Allocate memory for a .debug$S section and relocate it.
 453 static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
 454                                             SectionChunk *DebugChunk) {
 455   uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk->getSize());
 456   assert(DebugChunk->OutputSectionOff == 0 &&
 457          "debug sections should not be in output sections");
 458   DebugChunk->writeTo(Buffer);
 459   return consumeDebugMagic(makeArrayRef(Buffer, DebugChunk->getSize()),
 460                            ".debug$S");
 461 }
 462
 463 void PDBLinker::addObjectFile(ObjectFile *File) {
 464   // Add a module descriptor for every object file. We need to put an absolute
 465   // path to the object into the PDB. If this is a plain object, we make its
 466   // path absolute. If it's an object in an archive, we make the archive path
 467   // absolute.
 468   bool InArchive = !File->ParentName.empty();
 469   SmallString<128> Path = InArchive ? File->ParentName : File->getName();
 470   sys::fs::make_absolute(Path);
 471   sys::path::native(Path, sys::path::Style::windows);
 472   StringRef Name = InArchive ? File->getName() : StringRef(Path);
 473
 474   File->ModuleDBI = &ExitOnErr(Builder.getDbiBuilder().addModuleInfo(Name));
 475   File->ModuleDBI->setObjFileName(Path);
 476
 477   // Before we can process symbol substreams from .debug$S, we need to process
 478   // type information, file checksums, and the string table.  Add type info to
 479   // the PDB first, so that we can get the map from object file type and item
 480   // indices to PDB type and item indices.
 481   CVIndexMap ObjectIndexMap;
 482   const CVIndexMap &IndexMap = mergeDebugT(File, ObjectIndexMap);
 483
 484   // Now do all live .debug$S sections.
 485   for (SectionChunk *DebugChunk : File->getDebugChunks()) {
 486     if (!DebugChunk->isLive() || DebugChunk->getSectionName() != ".debug$S")
 487       continue;
 488
 489     ArrayRef<uint8_t> RelocatedDebugContents =
 490         relocateDebugChunk(Alloc, DebugChunk);
 491     if (RelocatedDebugContents.empty())
 492       continue;
 493
 494     DebugSubsectionArray Subsections;
 495     BinaryStreamReader Reader(RelocatedDebugContents, support::little);
 496     ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
 497
 498     DebugStringTableSubsectionRef CVStrTab;
 499     DebugChecksumsSubsectionRef Checksums;
 500     for (const DebugSubsectionRecord &SS : Subsections) {
 501       switch (SS.kind()) {
 502       case DebugSubsectionKind::StringTable:
 503         ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
 504         break;
 505       case DebugSubsectionKind::FileChecksums:
 506         ExitOnErr(Checksums.initialize(SS.getRecordData()));
 507         break;
 508       case DebugSubsectionKind::Lines:
 509         // We can add the relocated line table directly to the PDB without
 510         // modification because the file checksum offsets will stay the same.
 511         File->ModuleDBI->addDebugSubsection(SS);
 512         break;
 513       case DebugSubsectionKind::Symbols:
 514         mergeSymbolRecords(Alloc, File, IndexMap, SS.getRecordData());
 515         break;
 516       default:
 517         // FIXME: Process the rest of the subsections.
 518         break;
 519       }
 520     }
 521
 522     if (Checksums.valid()) {
 523       // Make a new file checksum table that refers to offsets in the PDB-wide
 524       // string table. Generally the string table subsection appears after the
 525       // checksum table, so we have to do this after looping over all the
 526       // subsections.
 527       if (!CVStrTab.valid())
 528         fatal(".debug$S sections must have both a string table subsection "
 529               "and a checksum subsection table or neither");
 530       auto NewChecksums = make_unique<DebugChecksumsSubsection>(PDBStrTab);
 531       for (FileChecksumEntry &FC : Checksums) {
 532         StringRef FileName = ExitOnErr(CVStrTab.getString(FC.FileNameOffset));
 533         ExitOnErr(Builder.getDbiBuilder().addModuleSourceFile(*File->ModuleDBI,
 534                                                               FileName));
 535         NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
 536       }
 537       File->ModuleDBI->addDebugSubsection(std::move(NewChecksums));
 538     }
 539   }
 540 }
 541
 542 // Add all object files to the PDB. Merge .debug$T sections into IpiData and
 543 // TpiData.
 544 void PDBLinker::addObjectsToPDB() {
 545   for (ObjectFile *File : Symtab->ObjectFiles)
 546     addObjectFile(File);
 547
 548   Builder.getStringTableBuilder().setStrings(PDBStrTab);
 549
 550   // Construct TPI stream contents.
 551   addTypeInfo(Builder.getTpiBuilder(), TypeTable);
 552
 553   // Construct IPI stream contents.
 554   addTypeInfo(Builder.getIpiBuilder(), IDTable);
 555
 556   // Add public and symbol records stream.
 557
 558   // For now we don't actually write any thing useful to the publics stream, but
 559   // the act of "getting" it also creates it lazily so that we write an empty
 560   // stream.
 561   (void)Builder.getPublicsBuilder();
 562 }
 563
 564 static void addLinkerModuleSymbols(StringRef Path,
 565                                    pdb::DbiModuleDescriptorBuilder &Mod,
 566                                    BumpPtrAllocator &Allocator) {
 567   codeview::SymbolSerializer Serializer(Allocator, CodeViewContainer::Pdb);
 568   codeview::ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
 569   codeview::Compile3Sym CS(SymbolRecordKind::Compile3Sym);
 570   codeview::EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
 571
 572   ONS.Name = "* Linker *";
 573   ONS.Signature = 0;
 574
 575   CS.Machine = Config->is64() ? CPUType::X64 : CPUType::Intel80386;
 576   CS.Flags = CompileSym3Flags::None;
 577   CS.VersionBackendBuild = 0;
 578   CS.VersionBackendMajor = 0;
 579   CS.VersionBackendMinor = 0;
 580   CS.VersionBackendQFE = 0;
 581   CS.VersionFrontendBuild = 0;
 582   CS.VersionFrontendMajor = 0;
 583   CS.VersionFrontendMinor = 0;
 584   CS.VersionFrontendQFE = 0;
 585   CS.Version = "LLVM Linker";
 586   CS.setLanguage(SourceLanguage::Link);
 587
 588   ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
 589   std::string ArgStr = llvm::join(Args, " ");
 590   EBS.Fields.push_back("cwd");
 591   SmallString<64> cwd;
 592   sys::fs::current_path(cwd);
 593   EBS.Fields.push_back(cwd);
 594   EBS.Fields.push_back("exe");
 595   EBS.Fields.push_back(Config->Argv[0]);
 596   EBS.Fields.push_back("pdb");
 597   EBS.Fields.push_back(Path);
 598   EBS.Fields.push_back("cmd");
 599   EBS.Fields.push_back(ArgStr);
 600   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
 601       ONS, Allocator, CodeViewContainer::Pdb));
 602   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
 603       CS, Allocator, CodeViewContainer::Pdb));
 604   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
 605       EBS, Allocator, CodeViewContainer::Pdb));
 606 }
 607
 608 // Creates a PDB file.
 609 void coff::createPDB(SymbolTable *Symtab, ArrayRef<uint8_t> SectionTable,
 610                      const llvm::codeview::DebugInfo *DI) {
 611   PDBLinker PDB(Symtab);
 612   PDB.initialize(DI);
 613   PDB.addObjectsToPDB();
 614   PDB.addSections(SectionTable);
 615   PDB.commit();
 616 }
 617
 618 void PDBLinker::initialize(const llvm::codeview::DebugInfo *DI) {
 619   ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
 620
 621   // Create streams in MSF for predefined streams, namely
 622   // PDB, TPI, DBI and IPI.
 623   for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
 624     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 625
 626   // Add an Info stream.
 627   auto &InfoBuilder = Builder.getInfoBuilder();
 628   InfoBuilder.setAge(DI ? DI->PDB70.Age : 0);
 629
 630   GUID uuid{};
 631   if (DI)
 632     memcpy(&uuid, &DI->PDB70.Signature, sizeof(uuid));
 633   InfoBuilder.setGuid(uuid);
 634   InfoBuilder.setSignature(time(nullptr));
 635   InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
 636
 637   // Add an empty DBI stream.
 638   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
 639   DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
 640   ExitOnErr(DbiBuilder.addDbgStream(pdb::DbgHeaderType::NewFPO, {}));
 641 }
 642
 643 void PDBLinker::addSections(ArrayRef<uint8_t> SectionTable) {
 644   // Add Section Contributions.
 645   pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
 646   addSectionContribs(Symtab, DbiBuilder);
 647
 648   // Add Section Map stream.
 649   ArrayRef<object::coff_section> Sections = {
 650       (const object::coff_section *)SectionTable.data(),
 651       SectionTable.size() / sizeof(object::coff_section)};
 652   SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
 653   DbiBuilder.setSectionMap(SectionMap);
 654
 655   // It's not entirely clear what this is, but the * Linker * module uses it.
 656   NativePath = Config->PDBPath;
 657   sys::fs::make_absolute(NativePath);
 658   sys::path::native(NativePath, sys::path::Style::windows);
 659   uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
 660   auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
 661   LinkerModule.setPdbFilePathNI(PdbFilePathNI);
 662   addLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
 663
 664   // Add COFF section header stream.
 665   ExitOnErr(
 666       DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
 667 }
 668
 669 void PDBLinker::commit() {
 670   // Write to a file.
 671   ExitOnErr(Builder.commit(Config->PDBPath));
 672 }