1 //===- PDB.cpp ------------------------------------------------------------===//
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
14 #include "SymbolTable.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"
62 using namespace lld::coff;
64 using namespace llvm::codeview;
66 using llvm::object::coff_section;
68 static ExitOnError ExitOnErr;
70 static Timer TotalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
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);
80 /// Map from type index and item index in a type server PDB to the
81 /// corresponding index in the destination PDB.
83 SmallVector<TypeIndex, 0> TPIMap;
84 SmallVector<TypeIndex, 0> IPIMap;
85 bool IsTypeServerMap = false;
86 bool IsPrecompiledTypeMap = false;
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("");
104 /// Emit the basic PDB structure: initial streams, headers, etc.
105 void initialize(llvm::codeview::DebugInfo *BuildId);
107 /// Add natvis files specified on the command line.
108 void addNatvisFiles();
110 /// Link CodeView from each object file in the symbol table into the PDB.
111 void addObjectsToPDB();
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
116 void addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap = nullptr);
118 /// Produce a mapping from the type and item indices used in the object
119 /// file to those in the destination PDB.
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
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);
132 /// Reads and makes available a PDB.
133 Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *File,
134 const CVType &FirstType);
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
139 Expected<const CVIndexMap &>
140 mergeInPrecompHeaderObj(ObjFile *File, const CVType &FirstType,
141 CVIndexMap *ObjectIndexMap);
143 /// Reads and makes available a precompiled headers object.
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.
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);
155 /// Adds a precompiled headers object signature -> TPI mapping.
156 std::pair<CVIndexMap &, bool /*already there*/>
157 registerPrecompiledHeaders(uint32_t Signature);
159 void mergeSymbolRecords(ObjFile *File, const CVIndexMap &IndexMap,
160 std::vector<ulittle32_t *> &StringTableRefs,
161 BinaryStreamRef SymData);
163 /// Add the section map and section contributions to the PDB.
164 void addSections(ArrayRef<OutputSection *> OutputSections,
165 ArrayRef<uint8_t> SectionTable);
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;
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;
181 /// Write the PDB to disk and store the Guid generated for it in *Guid.
182 void commit(codeview::GUID *Guid);
185 BumpPtrAllocator Alloc;
189 pdb::PDBFileBuilder Builder;
191 /// Type records that will go into the PDB TPI stream.
192 MergingTypeTableBuilder TypeTable;
194 /// Item records that will go into the PDB IPI stream.
195 MergingTypeTableBuilder IDTable;
197 /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
198 GlobalTypeTableBuilder GlobalTypeTable;
200 /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
201 GlobalTypeTableBuilder GlobalIDTable;
203 /// PDBs use a single global string table for filenames in the file checksum
205 DebugStringTableSubsection PDBStrTab;
207 llvm::SmallString<128> NativePath;
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;
214 std::vector<pdb::SecMapEntry> SectionMap;
216 /// Type index mappings of type server PDBs that we've loaded so far.
217 std::map<codeview::GUID, CVIndexMap> TypeServerIndexMappings;
219 /// Type index mappings of precompiled objects type map that we've loaded so
221 std::map<uint32_t, CVIndexMap> PrecompTypeIndexMappings;
223 /// List of TypeServer PDBs which cannot be loaded.
224 /// Cached to prevent repeated load attempts.
225 std::map<codeview::GUID, std::string> MissingTypeServerPDBs;
228 class DebugSHandler {
231 /// The object file whose .debug$S sections we're processing.
234 /// The result of merging type indices.
235 const CVIndexMap &IndexMap;
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;
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
247 DebugChecksumsSubsectionRef Checksums;
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;
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
262 std::vector<ulittle32_t *> StringTableReferences;
265 DebugSHandler(PDBLinker &Linker, ObjFile &File, const CVIndexMap &IndexMap)
266 : Linker(Linker), File(File), IndexMap(IndexMap) {}
268 void handleDebugS(lld::coff::SectionChunk &DebugS);
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))
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
291 if (Config->PDBSourcePath.empty()) {
292 sys::path::native(FileName);
293 sys::fs::make_absolute(FileName);
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);
309 FileName = std::move(AbsoluteFileName);
312 static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
314 for (SectionChunk *C : Sections)
315 if (C->getSectionName() == Name)
320 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
322 // First 4 bytes are section magic.
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);
330 static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
331 if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
332 return consumeDebugMagic(Sec->getContents(), SecName);
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))
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);
352 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) {
353 SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$H");
356 ArrayRef<uint8_t> Contents = Sec->getContents();
357 if (!canUseDebugH(Contents))
362 static ArrayRef<GloballyHashedType>
363 getHashesFromDebugH(ArrayRef<uint8_t> DebugH) {
364 assert(canUseDebugH(DebugH));
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};
371 static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
372 TypeCollection &TypeTable) {
373 // Start the TPI or IPI stream header.
374 TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
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);
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";
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()));
403 for (const DebugSubsectionRecord &SS : Subsections) {
404 if (SS.kind() != DebugSubsectionKind::Symbols)
407 // If it's there, the S_OBJNAME record shall come first in the stream.
408 Expected<CVSymbol> Sym = readSymbolFromStream(SS.getRecordData(), 0);
410 consumeError(Sym.takeError());
413 if (auto ObjName = SymbolDeserializer::deserializeAs<ObjNameSym>(Sym.get()))
414 return ObjName->Signature;
419 Expected<const CVIndexMap &>
420 PDBLinker::mergeDebugT(ObjFile *File, CVIndexMap *ObjectIndexMap) {
421 ScopedTimer T(TypeMergingTimer);
423 bool IsPrecompiledHeader = false;
425 ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
427 // Try again, Microsoft precompiled headers use .debug$P instead of
429 Data = getDebugSection(File, ".debug$P");
430 IsPrecompiledHeader = true;
433 return *ObjectIndexMap; // no debug info
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() + ")");
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);
451 "A precompiled headers OBJ with the same signature was already "
453 File->getName() + ")");
455 ObjectIndexMap = &R.first;
459 BinaryByteStream Stream(Data, support::little);
461 BinaryStreamReader Reader(Stream);
462 if (auto EC = Reader.readArray(Types, Reader.getLength()))
463 fatal("Reader::readArray failed: " + toString(std::move(EC)));
465 auto FirstType = Types.begin();
466 if (FirstType == Types.end())
467 return *ObjectIndexMap;
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);
480 return E.takeError();
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()));
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);
497 OwnedHashes = GloballyHashedType::hashTypes(Types);
498 Hashes = OwnedHashes;
501 if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
502 ObjectIndexMap->TPIMap, Types, Hashes,
504 fatal("codeview::mergeTypeAndIdRecords failed: " +
505 toString(std::move(Err)));
508 mergeTypeAndIdRecords(IDTable, TypeTable, ObjectIndexMap->TPIMap,
509 Types, File->PCHSignature))
510 fatal("codeview::mergeTypeAndIdRecords failed: " +
511 toString(std::move(Err)));
513 return *ObjectIndexMap;
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()));
524 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
525 TSPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
527 return errorCodeToError(MBOrErr.getError());
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),
534 return std::move(EC);
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.
542 return ExpectedInfo.takeError();
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);
550 return std::move(NS);
553 Expected<const CVIndexMap &>
554 PDBLinker::maybeMergeTypeServerPDB(ObjFile *File, const CVType &FirstType) {
555 TypeServer2Record TS;
557 TypeDeserializer::deserializeAs(const_cast<CVType &>(FirstType), TS))
558 fatal("error reading record: " + toString(std::move(EC)));
560 const codeview::GUID &TSId = TS.getGuid();
561 StringRef TSPath = TS.getName();
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(
568 make_error<StringError>(PrevErr->second, inconvertibleErrorCode()));
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)
577 // Mark this map as a type server map.
578 IndexMap.IsTypeServerMap = true;
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),
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.
592 Path, sys::path::filename(TSPath, sys::path::Style::windows));
593 return tryToLoadPDB(TSId, Path);
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
599 if (SysErr.category() == std::generic_category() &&
600 SysErr.value() == ENOENT)
601 return Error::success();
602 return Error(std::move(EC));
605 if (auto E = ExpectedSession.takeError()) {
606 TypeServerIndexMappings.erase(TSId);
608 // Flatten the error to a string, for later display, if the error occurs
609 // again on the same PDB.
611 raw_string_ostream S(ErrMsg);
613 MissingTypeServerPDBs.emplace(TSId, S.str());
615 return createFileError(TSPath, std::move(E));
618 pdb::NativeSession *Session = ExpectedSession->get();
620 // Keep a strong reference to this PDB, so that it's safe to hold pointers
622 LoadedPDBs.push_back(std::move(*ExpectedSession));
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)));
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
637 auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
639 GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
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)));
649 mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
650 ExpectedIpi->typeArray(), IpiHashes))
651 fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
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)));
659 if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
660 ExpectedIpi->typeArray()))
661 fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
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),
673 fatal("error reading record: " + toString(std::move(EC)));
675 auto E = aquirePrecompObj(File, Precomp);
677 return E.takeError();
679 const CVIndexMap &PrecompIndexMap = *E;
680 assert(PrecompIndexMap.IsPrecompiledTypeMap);
682 if (PrecompIndexMap.TPIMap.empty())
683 return PrecompIndexMap;
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;
694 static bool equals_path(StringRef path1, StringRef path2) {
696 return path1.equals_lower(path2);
698 return path1.equals(path2);
702 // Find by name an OBJ provided on the command line
703 static ObjFile *findObjByName(StringRef FileNameOnly) {
704 SmallString<128> CurrentPath;
706 for (ObjFile *F : ObjFile::Instances) {
707 StringRef CurrentFileName = sys::path::filename(F->getName());
709 // Compare based solely on the file name (link.exe behavior)
710 if (equals_path(CurrentFileName, FileNameOnly))
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};
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());
735 CVIndexMap &IndexMap = R.first;
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);
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);
747 return createFileError(
748 PrecompFileName.str(),
749 make_error<pdb::PDBError>(pdb::pdb_error_code::external_cmdline_ref));
751 addObjFile(PrecompFile, &IndexMap);
753 if (!PrecompFile->PCHSignature)
754 fatal(PrecompFile->getName() + " is not a precompiled headers object");
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));
764 static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
767 if (TI.toArrayIndex() >= TypeIndexMap.size())
769 TI = TypeIndexMap[TI.toArrayIndex()];
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");
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;
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);
805 recordStringTableReferenceAtOffset(MutableArrayRef<uint8_t> Contents,
807 std::vector<ulittle32_t *> &StrTableRefs) {
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);
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.
822 case SymbolKind::S_FILESTATIC:
823 // FileStaticSym::ModFileOffset
824 recordStringTableReferenceAtOffset(Contents, 8, StrTableRefs);
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");
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));
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());
847 SymbolKind Kind = symbolKind(RecordData);
849 if (Kind == SymbolKind::S_PROC_ID_END) {
850 Prefix->RecordKind = SymbolKind::S_END;
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);
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);
881 Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
882 : SymbolKind::S_LPROC32;
883 Prefix->RecordKind = uint16_t(Kind);
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");
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());
902 // Update the record prefix length. It should point to the beginning of the
904 auto *Prefix = reinterpret_cast<RecordPrefix *>(NewData.data());
905 Prefix->RecordLen = Size - 2;
910 ulittle32_t PtrParent;
915 ScopeRecord *OpeningRecord;
916 uint32_t ScopeOffset;
919 static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
920 uint32_t CurOffset, CVSymbol &Sym) {
921 assert(symbolOpensScope(Sym.kind()));
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;
930 static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
931 uint32_t CurOffset, ObjFile *File) {
933 warn("symbol scopes are not balanced in " + File->getName());
936 SymbolScope S = Stack.pop_back_val();
937 S.OpeningRecord->PtrEnd = CurOffset;
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
948 case SymbolKind::S_PROCREF:
949 case SymbolKind::S_LPROCREF:
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:
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:
975 // S_UDT records go in the globals stream if it is a global S_UDT.
976 case SymbolKind::S_UDT:
977 return IsGlobalScope;
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);
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;
1000 PS.Module = ModIndex;
1001 // For some reason, MSVC seems to add one to this value.
1003 PS.Name = getSymbolName(Sym);
1005 PS.SymOffset = SymOffset;
1006 Builder.addGlobalSymbol(PS);
1010 llvm_unreachable("Invalid symbol kind!");
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;
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();
1034 // If any of the symbol record lengths was corrupt, ignore them all, warn
1035 // about it, and move on.
1037 warn("corrupt symbol records in " + File->getName());
1038 consumeError(std::move(EC));
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) {
1048 Alloc.Allocate(TotalRealignedSize, alignOf(CodeViewContainer::Pdb));
1049 AlignedSymbolMem = makeMutableArrayRef(
1050 reinterpret_cast<uint8_t *>(AlignedData), TotalRealignedSize);
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);
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());
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();
1079 // Re-map all the type index references.
1080 remapTypesInSymbolRecord(File, Sym.kind(), RecordBytes, IndexMap,
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);
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);
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);
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
1102 if (symbolGoesInGlobalsStream(Sym, Scopes.empty()))
1103 addGlobalSymbol(Builder.getGsiBuilder(),
1104 File->ModuleDBI->getModuleIndex(), CurSymOffset, Sym);
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());
1114 File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
1115 BulkSymbols = RecordBytes;
1117 CurSymOffset += Sym.length();
1119 return Error::success();
1122 // Add any remaining symbols we've accumulated.
1123 File->ModuleDBI->addSymbolsInBulk(BulkSymbols);
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());
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();
1149 ArrayRef<char> CharContents = makeArrayRef(
1150 reinterpret_cast<const char *>(Contents.data()), Contents.size());
1151 CRC.update(CharContents);
1152 SC.DataCrc = CRC.getCRC();
1154 SC.Characteristics = OS->Header.Characteristics;
1155 // FIXME: When we start creating DBI for import libraries, use those here.
1158 SC.RelocCrc = 0; // FIXME
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());
1174 return PdbStrTable.insert(*ExpectedString);
1177 void DebugSHandler::handleDebugS(lld::coff::SectionChunk &DebugS) {
1178 DebugSubsectionArray Subsections;
1180 ArrayRef<uint8_t> RelocatedDebugContents = consumeDebugMagic(
1181 relocateDebugChunk(Linker.Alloc, DebugS), DebugS.getSectionName());
1183 BinaryStreamReader Reader(RelocatedDebugContents, support::little);
1184 ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
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()));
1194 case DebugSubsectionKind::FileChecksums:
1195 assert(!Checksums.valid() &&
1196 "Encountered multiple checksum subsections!");
1197 ExitOnErr(Checksums.initialize(SS.getRecordData()));
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);
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));
1213 case DebugSubsectionKind::Symbols: {
1214 Linker.mergeSymbolRecords(&File, IndexMap, StringTableReferences,
1215 SS.getRecordData());
1219 // FIXME: Process the rest of the subsections.
1225 void DebugSHandler::finish() {
1226 pdb::DbiStreamBuilder &DbiBuilder = Linker.Builder.getDbiBuilder();
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");
1236 if (!StringTableReferences.empty())
1237 warn("No StringTable subsection was encountered, but there are string "
1238 "table references");
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;
1249 translateStringTableIndex(FD.FrameFunc, CVStrTab, Linker.PDBStrTab);
1250 DbiBuilder.addNewFpoData(FD);
1254 for (ulittle32_t *Ref : StringTableReferences)
1255 *Ref = translateStringTableIndex(*Ref, CVStrTab, Linker.PDBStrTab);
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
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);
1270 File.ModuleDBI->addDebugSubsection(std::move(NewChecksums));
1273 void PDBLinker::addObjFile(ObjFile *File, CVIndexMap *ExternIndexMap) {
1274 if (File->wasProcessedForPDB())
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
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);
1285 pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
1286 File->ModuleDBI = &ExitOnErr(DbiBuilder.addModuleInfo(Name));
1287 File->ModuleDBI->setObjFileName(Path);
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)
1295 pdb::SectionContrib SC = createSectionContrib(SecChunk, Modi);
1296 File->ModuleDBI->setFirstSectionContrib(SC);
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);
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());
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())));
1321 ScopedTimer T(SymbolMergingTimer);
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)
1329 if (DebugChunk->getSectionName() == ".debug$S") {
1330 DSH.handleDebugS(*DebugChunk);
1334 if (DebugChunk->getSectionName() == ".debug$F") {
1335 ArrayRef<uint8_t> RelocatedDebugContents =
1336 relocateDebugChunk(Alloc, *DebugChunk);
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));
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);
1351 // Do any post-processing now that all .debug$S sections have been processed.
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;
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;
1372 // Add all object files to the PDB. Merge .debug$T sections into IpiData and
1374 void PDBLinker::addObjectsToPDB() {
1375 ScopedTimer T1(AddObjectsTimer);
1376 for (ObjFile *File : ObjFile::Instances)
1379 Builder.getStringTableBuilder().setStrings(PDBStrTab);
1382 // Construct TPI and IPI stream contents.
1383 ScopedTimer T2(TpiStreamLayoutTimer);
1384 addTypeInfo(Builder.getTpiBuilder(), getTypeTable());
1385 addTypeInfo(Builder.getIpiBuilder(), getIDTable());
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));
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;
1405 for (const PublicSym32 &Pub : Publics)
1406 GsiBuilder.addPublicSymbol(Pub);
1410 void PDBLinker::addNatvisFiles() {
1411 for (StringRef File : Config->NatvisFiles) {
1412 ErrorOr<std::unique_ptr<MemoryBuffer>> DataOrErr =
1413 MemoryBuffer::getFile(File);
1415 warn("Cannot open input file: " + File);
1418 Builder.addInjectedSource(File, std::move(*DataOrErr));
1422 static codeview::CPUType toCodeViewMachine(COFF::MachineTypes 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;
1435 llvm_unreachable("Unsupported CPU Type");
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) {
1445 for (StringRef A : Args) {
1448 bool HasWS = A.find(' ') != StringRef::npos;
1449 bool HasQ = A.find('"') != StringRef::npos;
1453 SmallVector<StringRef, 4> S;
1455 R.append(join(S, "\"\""));
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);
1472 ONS.Name = "* Linker *";
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;
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
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);
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);
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));
1524 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
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();
1532 Sym.Rva = OS.getRVA();
1533 Sym.SectionNumber = OS.SectionIndex;
1534 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
1535 Sym, Allocator, CodeViewContainer::Pdb));
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);
1546 PDB.initialize(BuildId);
1547 PDB.addObjectsToPDB();
1548 PDB.addSections(OutputSections, SectionTable);
1549 PDB.addNatvisFiles();
1551 ScopedTimer T2(DiskCommitTimer);
1552 codeview::GUID Guid;
1554 memcpy(&BuildId->PDB70.Signature, &Guid, 16);
1557 void PDBLinker::initialize(llvm::codeview::DebugInfo *BuildId) {
1558 ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
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;
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));
1570 // Add an Info stream.
1571 auto &InfoBuilder = Builder.getInfoBuilder();
1572 InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
1573 InfoBuilder.setHashPDBContentsToGUID(true);
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);
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);
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);
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);
1615 // Add COFF section header stream.
1617 DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
1620 void PDBLinker::commit(codeview::GUID *Guid) {
1622 ExitOnErr(Builder.commit(Config->PDBPath, Guid));
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);
1635 static uint32_t getSecrelReloc() {
1636 switch (Config->Machine) {
1638 return COFF::IMAGE_REL_AMD64_SECREL;
1640 return COFF::IMAGE_REL_I386_SECREL;
1642 return COFF::IMAGE_REL_ARM_SECREL;
1644 return COFF::IMAGE_REL_ARM64_SECREL;
1646 llvm_unreachable("unknown machine type");
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
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();
1663 for (SectionChunk *DbgC : C->File->getDebugChunks()) {
1664 if (DbgC->getSectionName() != ".debug$S")
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)
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();
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()));
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()));
1693 case DebugSubsectionKind::FileChecksums:
1694 assert(!Checksums.valid() &&
1695 "Encountered multiple checksum subsections!");
1696 ExitOnErr(Checksums.initialize(SS.getRecordData()));
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();
1704 // Check whether this line table refers to C.
1705 auto I = Secrels.find(OffsetInDbgC);
1706 if (I == Secrels.end())
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)
1716 assert(!Lines.header() &&
1717 "Encountered multiple line tables for function!");
1718 ExitOnErr(Lines.initialize(BinaryStreamReader(Ref)));
1719 OffsetInLinetable = Addr - OffsetInC;
1726 if (CVStrTab.valid() && Checksums.valid() && Lines.header())
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
1737 std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *C,
1739 ExitOnError ExitOnErr;
1741 DebugStringTableSubsectionRef CVStrTab;
1742 DebugChecksumsSubsectionRef Checksums;
1743 DebugLinesSubsectionRef Lines;
1744 uint32_t OffsetInLinetable;
1746 if (!findLineTable(C, Addr, CVStrTab, Checksums, Lines, OffsetInLinetable))
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) {
1756 NameIndex = Entry.NameIndex;
1757 LineNumber = LI.getStartLine();
1759 StringRef Filename =
1760 ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex));
1761 return {Filename, *LineNumber};
1763 NameIndex = Entry.NameIndex;
1764 LineNumber = LI.getStartLine();
1769 StringRef Filename = ExitOnErr(getFileName(CVStrTab, Checksums, *NameIndex));
1770 return {Filename, *LineNumber};