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 "llvm/DebugInfo/CodeView/CVDebugRecord.h"
19 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
20 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
21 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
22 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
23 #include "llvm/DebugInfo/CodeView/RecordName.h"
24 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
25 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
26 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
27 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
28 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
29 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
30 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
31 #include "llvm/DebugInfo/MSF/MSFCommon.h"
32 #include "llvm/DebugInfo/PDB/GenericError.h"
33 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
34 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
35 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
36 #include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
37 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
38 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
39 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
40 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
41 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
42 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
43 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
44 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
45 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
46 #include "llvm/DebugInfo/PDB/PDB.h"
47 #include "llvm/Object/COFF.h"
48 #include "llvm/Support/BinaryByteStream.h"
49 #include "llvm/Support/Endian.h"
50 #include "llvm/Support/JamCRC.h"
51 #include "llvm/Support/Path.h"
52 #include "llvm/Support/ScopedPrinter.h"
56 using namespace lld::coff;
58 using namespace llvm::codeview;
60 using llvm::object::coff_section;
62 static ExitOnError ExitOnErr;
65 /// Map from type index and item index in a type server PDB to the
66 /// corresponding index in the destination PDB.
68 SmallVector<TypeIndex, 0> TPIMap;
69 SmallVector<TypeIndex, 0> IPIMap;
70 bool IsTypeServerMap = false;
75 PDBLinker(SymbolTable *Symtab)
76 : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
77 IDTable(Alloc), GlobalTypeTable(Alloc), GlobalIDTable(Alloc) {}
79 /// Emit the basic PDB structure: initial streams, headers, etc.
80 void initialize(const llvm::codeview::DebugInfo &BuildId);
82 /// Link CodeView from each object file in the symbol table into the PDB.
83 void addObjectsToPDB();
85 /// Link CodeView from a single object file into the PDB.
86 void addObjFile(ObjFile *File);
88 /// Produce a mapping from the type and item indices used in the object
89 /// file to those in the destination PDB.
91 /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
92 /// and IPI from the type server PDB and return a map for it. Each unique type
93 /// server PDB is merged at most once, so this may return an existing index
96 /// If the object does not use a type server PDB (compiled with /Z7), we merge
97 /// all the type and item records from the .debug$S stream and fill in the
98 /// caller-provided ObjectIndexMap.
99 Expected<const CVIndexMap&> mergeDebugT(ObjFile *File,
100 CVIndexMap &ObjectIndexMap);
102 Expected<const CVIndexMap&> maybeMergeTypeServerPDB(ObjFile *File,
103 TypeServer2Record &TS);
105 /// Add the section map and section contributions to the PDB.
106 void addSections(ArrayRef<OutputSection *> OutputSections,
107 ArrayRef<uint8_t> SectionTable);
109 void addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
110 OutputSection *OS, Chunk *C);
112 /// Write the PDB to disk.
116 BumpPtrAllocator Alloc;
120 pdb::PDBFileBuilder Builder;
122 /// Type records that will go into the PDB TPI stream.
123 MergingTypeTableBuilder TypeTable;
125 /// Item records that will go into the PDB IPI stream.
126 MergingTypeTableBuilder IDTable;
128 /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
129 GlobalTypeTableBuilder GlobalTypeTable;
131 /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
132 GlobalTypeTableBuilder GlobalIDTable;
134 /// PDBs use a single global string table for filenames in the file checksum
136 DebugStringTableSubsection PDBStrTab;
138 llvm::SmallString<128> NativePath;
140 std::vector<pdb::SecMapEntry> SectionMap;
142 /// Type index mappings of type server PDBs that we've loaded so far.
143 std::map<GUID, CVIndexMap> TypeServerIndexMappings;
145 /// List of TypeServer PDBs which cannot be loaded.
146 /// Cached to prevent repeated load attempts.
147 std::set<GUID> MissingTypeServerPDBs;
151 static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
153 for (SectionChunk *C : Sections)
154 if (C->getSectionName() == Name)
159 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
161 // First 4 bytes are section magic.
163 fatal(SecName + " too short");
164 if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
165 fatal(SecName + " has an invalid magic");
166 return Data.slice(4);
169 static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
170 if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
171 return consumeDebugMagic(Sec->getContents(), SecName);
175 // A COFF .debug$H section is currently a clang extension. This function checks
176 // if a .debug$H section is in a format that we expect / understand, so that we
177 // can ignore any sections which are coincidentally also named .debug$H but do
178 // not contain a format we recognize.
179 static bool canUseDebugH(ArrayRef<uint8_t> DebugH) {
180 if (DebugH.size() < sizeof(object::debug_h_header))
183 reinterpret_cast<const object::debug_h_header *>(DebugH.data());
184 DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
185 return Header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
186 Header->Version == 0 &&
187 Header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1) &&
188 (DebugH.size() % 20 == 0);
191 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) {
192 SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$H");
195 ArrayRef<uint8_t> Contents = Sec->getContents();
196 if (!canUseDebugH(Contents))
201 static ArrayRef<GloballyHashedType>
202 getHashesFromDebugH(ArrayRef<uint8_t> DebugH) {
203 assert(canUseDebugH(DebugH));
205 DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
206 uint32_t Count = DebugH.size() / sizeof(GloballyHashedType);
207 return {reinterpret_cast<const GloballyHashedType *>(DebugH.data()), Count};
210 static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
211 TypeCollection &TypeTable) {
212 // Start the TPI or IPI stream header.
213 TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
215 // Flatten the in memory type table and hash each type.
216 TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) {
217 auto Hash = pdb::hashTypeRecord(Type);
218 if (auto E = Hash.takeError())
219 fatal("type hashing error");
220 TpiBuilder.addTypeRecord(Type.RecordData, *Hash);
224 static Optional<TypeServer2Record>
225 maybeReadTypeServerRecord(CVTypeArray &Types) {
226 auto I = Types.begin();
227 if (I == Types.end())
229 const CVType &Type = *I;
230 if (Type.kind() != LF_TYPESERVER2)
232 TypeServer2Record TS;
233 if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type), TS))
234 fatal("error reading type server record: " + toString(std::move(EC)));
235 return std::move(TS);
238 Expected<const CVIndexMap&> PDBLinker::mergeDebugT(ObjFile *File,
239 CVIndexMap &ObjectIndexMap) {
240 ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
242 return ObjectIndexMap;
244 BinaryByteStream Stream(Data, support::little);
246 BinaryStreamReader Reader(Stream);
247 if (auto EC = Reader.readArray(Types, Reader.getLength()))
248 fatal("Reader::readArray failed: " + toString(std::move(EC)));
250 // Look through type servers. If we've already seen this type server, don't
251 // merge any type information.
252 if (Optional<TypeServer2Record> TS = maybeReadTypeServerRecord(Types))
253 return maybeMergeTypeServerPDB(File, *TS);
255 // This is a /Z7 object. Fill in the temporary, caller-provided
257 if (Config->DebugGHashes) {
258 ArrayRef<GloballyHashedType> Hashes;
259 std::vector<GloballyHashedType> OwnedHashes;
260 if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File))
261 Hashes = getHashesFromDebugH(*DebugH);
263 OwnedHashes = GloballyHashedType::hashTypes(Types);
264 Hashes = OwnedHashes;
267 if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
268 ObjectIndexMap.TPIMap, Types, Hashes))
269 fatal("codeview::mergeTypeAndIdRecords failed: " +
270 toString(std::move(Err)));
272 if (auto Err = mergeTypeAndIdRecords(IDTable, TypeTable,
273 ObjectIndexMap.TPIMap, Types))
274 fatal("codeview::mergeTypeAndIdRecords failed: " +
275 toString(std::move(Err)));
277 return ObjectIndexMap;
280 static Expected<std::unique_ptr<pdb::NativeSession>>
281 tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
282 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
283 TSPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
285 return errorCodeToError(MBOrErr.getError());
287 std::unique_ptr<pdb::IPDBSession> ThisSession;
288 if (auto EC = pdb::NativeSession::createFromPdb(
289 MemoryBuffer::getMemBuffer(Driver->takeBuffer(std::move(*MBOrErr)),
290 /*RequiresNullTerminator=*/false),
292 return std::move(EC);
294 std::unique_ptr<pdb::NativeSession> NS(
295 static_cast<pdb::NativeSession *>(ThisSession.release()));
296 pdb::PDBFile &File = NS->getPDBFile();
297 auto ExpectedInfo = File.getPDBInfoStream();
298 // All PDB Files should have an Info stream.
300 return ExpectedInfo.takeError();
302 // Just because a file with a matching name was found and it was an actual
303 // PDB file doesn't mean it matches. For it to match the InfoStream's GUID
304 // must match the GUID specified in the TypeServer2 record.
305 if (ExpectedInfo->getGuid() != GuidFromObj)
306 return make_error<pdb::GenericError>(
307 pdb::generic_error_code::type_server_not_found, TSPath);
309 return std::move(NS);
312 Expected<const CVIndexMap&> PDBLinker::maybeMergeTypeServerPDB(ObjFile *File,
313 TypeServer2Record &TS) {
314 const GUID& TSId = TS.getGuid();
315 StringRef TSPath = TS.getName();
317 // First, check if the PDB has previously failed to load.
318 if (MissingTypeServerPDBs.count(TSId))
319 return make_error<pdb::GenericError>(
320 pdb::generic_error_code::type_server_not_found, TSPath);
322 // Second, check if we already loaded a PDB with this GUID. Return the type
323 // index mapping if we have it.
324 auto Insertion = TypeServerIndexMappings.insert({TSId, CVIndexMap()});
325 CVIndexMap &IndexMap = Insertion.first->second;
326 if (!Insertion.second)
329 // Mark this map as a type server map.
330 IndexMap.IsTypeServerMap = true;
332 // Check for a PDB at:
333 // 1. The given file path
334 // 2. Next to the object file or archive file
335 auto ExpectedSession = tryToLoadPDB(TSId, TSPath);
336 if (!ExpectedSession) {
337 consumeError(ExpectedSession.takeError());
338 StringRef LocalPath =
339 !File->ParentName.empty() ? File->ParentName : File->getName();
340 SmallString<128> Path = sys::path::parent_path(LocalPath);
342 Path, sys::path::filename(TSPath, sys::path::Style::windows));
343 ExpectedSession = tryToLoadPDB(TSId, Path);
345 if (auto E = ExpectedSession.takeError()) {
346 TypeServerIndexMappings.erase(TSId);
347 MissingTypeServerPDBs.emplace(TSId);
351 auto ExpectedTpi = (*ExpectedSession)->getPDBFile().getPDBTpiStream();
352 if (auto E = ExpectedTpi.takeError())
353 fatal("Type server does not have TPI stream: " + toString(std::move(E)));
354 auto ExpectedIpi = (*ExpectedSession)->getPDBFile().getPDBIpiStream();
355 if (auto E = ExpectedIpi.takeError())
356 fatal("Type server does not have TPI stream: " + toString(std::move(E)));
358 if (Config->DebugGHashes) {
359 // PDBs do not actually store global hashes, so when merging a type server
360 // PDB we have to synthesize global hashes. To do this, we first synthesize
361 // global hashes for the TPI stream, since it is independent, then we
362 // synthesize hashes for the IPI stream, using the hashes for the TPI stream
364 auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
366 GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
368 // Merge TPI first, because the IPI stream will reference type indices.
369 if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
370 ExpectedTpi->typeArray(), TpiHashes))
371 fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
375 mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
376 ExpectedIpi->typeArray(), IpiHashes))
377 fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
379 // Merge TPI first, because the IPI stream will reference type indices.
380 if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
381 ExpectedTpi->typeArray()))
382 fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
385 if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
386 ExpectedIpi->typeArray()))
387 fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
393 static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
396 if (TI.toArrayIndex() >= TypeIndexMap.size())
398 TI = TypeIndexMap[TI.toArrayIndex()];
402 static void remapTypesInSymbolRecord(ObjFile *File, SymbolKind SymKind,
403 MutableArrayRef<uint8_t> Contents,
404 const CVIndexMap &IndexMap,
405 ArrayRef<TiReference> TypeRefs) {
406 for (const TiReference &Ref : TypeRefs) {
407 unsigned ByteSize = Ref.Count * sizeof(TypeIndex);
408 if (Contents.size() < Ref.Offset + ByteSize)
409 fatal("symbol record too short");
411 // This can be an item index or a type index. Choose the appropriate map.
412 ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap;
413 bool IsItemIndex = Ref.Kind == TiRefKind::IndexRef;
414 if (IsItemIndex && IndexMap.IsTypeServerMap)
415 TypeOrItemMap = IndexMap.IPIMap;
417 MutableArrayRef<TypeIndex> TIs(
418 reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count);
419 for (TypeIndex &TI : TIs) {
420 if (!remapTypeIndex(TI, TypeOrItemMap)) {
421 log("ignoring symbol record of kind 0x" + utohexstr(SymKind) + " in " +
422 File->getName() + " with bad " + (IsItemIndex ? "item" : "type") +
423 " index 0x" + utohexstr(TI.getIndex()));
424 TI = TypeIndex(SimpleTypeKind::NotTranslated);
431 static SymbolKind symbolKind(ArrayRef<uint8_t> RecordData) {
432 const RecordPrefix *Prefix =
433 reinterpret_cast<const RecordPrefix *>(RecordData.data());
434 return static_cast<SymbolKind>(uint16_t(Prefix->RecordKind));
437 /// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
438 static void translateIdSymbols(MutableArrayRef<uint8_t> &RecordData,
439 TypeCollection &IDTable) {
440 RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(RecordData.data());
442 SymbolKind Kind = symbolKind(RecordData);
444 if (Kind == SymbolKind::S_PROC_ID_END) {
445 Prefix->RecordKind = SymbolKind::S_END;
449 // In an object file, GPROC32_ID has an embedded reference which refers to the
450 // single object file type index namespace. This has already been translated
451 // to the PDB file's ID stream index space, but we need to convert this to a
452 // symbol that refers to the type stream index space. So we remap again from
453 // ID index space to type index space.
454 if (Kind == SymbolKind::S_GPROC32_ID || Kind == SymbolKind::S_LPROC32_ID) {
455 SmallVector<TiReference, 1> Refs;
456 auto Content = RecordData.drop_front(sizeof(RecordPrefix));
457 CVSymbol Sym(Kind, RecordData);
458 discoverTypeIndicesInSymbol(Sym, Refs);
459 assert(Refs.size() == 1);
460 assert(Refs.front().Count == 1);
463 reinterpret_cast<TypeIndex *>(Content.data() + Refs[0].Offset);
464 // `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
465 // the IPI stream, whose `FunctionType` member refers to the TPI stream.
466 // Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
467 // in both cases we just need the second type index.
468 if (!TI->isSimple() && !TI->isNoneType()) {
469 CVType FuncIdData = IDTable.getType(*TI);
470 SmallVector<TypeIndex, 2> Indices;
471 discoverTypeIndices(FuncIdData, Indices);
472 assert(Indices.size() == 2);
476 Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
477 : SymbolKind::S_LPROC32;
478 Prefix->RecordKind = uint16_t(Kind);
482 /// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
483 /// The object file may not be aligned.
484 static MutableArrayRef<uint8_t> copySymbolForPdb(const CVSymbol &Sym,
485 BumpPtrAllocator &Alloc) {
486 size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
487 assert(Size >= 4 && "record too short");
488 assert(Size <= MaxRecordLength && "record too long");
489 void *Mem = Alloc.Allocate(Size, 4);
491 // Copy the symbol record and zero out any padding bytes.
492 MutableArrayRef<uint8_t> NewData(reinterpret_cast<uint8_t *>(Mem), Size);
493 memcpy(NewData.data(), Sym.data().data(), Sym.length());
494 memset(NewData.data() + Sym.length(), 0, Size - Sym.length());
496 // Update the record prefix length. It should point to the beginning of the
498 auto *Prefix = reinterpret_cast<RecordPrefix *>(Mem);
499 Prefix->RecordLen = Size - 2;
503 /// Return true if this symbol opens a scope. This implies that the symbol has
504 /// "parent" and "end" fields, which contain the offset of the S_END or
505 /// S_INLINESITE_END record.
506 static bool symbolOpensScope(SymbolKind Kind) {
508 case SymbolKind::S_GPROC32:
509 case SymbolKind::S_LPROC32:
510 case SymbolKind::S_LPROC32_ID:
511 case SymbolKind::S_GPROC32_ID:
512 case SymbolKind::S_BLOCK32:
513 case SymbolKind::S_SEPCODE:
514 case SymbolKind::S_THUNK32:
515 case SymbolKind::S_INLINESITE:
516 case SymbolKind::S_INLINESITE2:
524 static bool symbolEndsScope(SymbolKind Kind) {
526 case SymbolKind::S_END:
527 case SymbolKind::S_PROC_ID_END:
528 case SymbolKind::S_INLINESITE_END:
537 ulittle32_t PtrParent;
542 ScopeRecord *OpeningRecord;
543 uint32_t ScopeOffset;
546 static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
547 uint32_t CurOffset, CVSymbol &Sym) {
548 assert(symbolOpensScope(Sym.kind()));
550 S.ScopeOffset = CurOffset;
551 S.OpeningRecord = const_cast<ScopeRecord *>(
552 reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
553 S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
557 static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
558 uint32_t CurOffset, ObjFile *File) {
560 warn("symbol scopes are not balanced in " + File->getName());
563 SymbolScope S = Stack.pop_back_val();
564 S.OpeningRecord->PtrEnd = CurOffset;
567 static bool symbolGoesInModuleStream(const CVSymbol &Sym) {
568 switch (Sym.kind()) {
569 case SymbolKind::S_GDATA32:
570 case SymbolKind::S_CONSTANT:
571 case SymbolKind::S_UDT:
572 // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
573 // since they are synthesized by the linker in response to S_GPROC32 and
574 // S_LPROC32, but if we do see them, don't put them in the module stream I
576 case SymbolKind::S_PROCREF:
577 case SymbolKind::S_LPROCREF:
579 // S_GDATA32 does not go in the module stream, but S_LDATA32 does.
580 case SymbolKind::S_LDATA32:
586 static bool symbolGoesInGlobalsStream(const CVSymbol &Sym) {
587 switch (Sym.kind()) {
588 case SymbolKind::S_CONSTANT:
589 case SymbolKind::S_GDATA32:
590 // S_LDATA32 goes in both the module stream and the globals stream.
591 case SymbolKind::S_LDATA32:
592 case SymbolKind::S_GPROC32:
593 case SymbolKind::S_LPROC32:
594 // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
595 // since they are synthesized by the linker in response to S_GPROC32 and
596 // S_LPROC32, but if we do see them, copy them straight through.
597 case SymbolKind::S_PROCREF:
598 case SymbolKind::S_LPROCREF:
600 // FIXME: For now, we drop all S_UDT symbols (i.e. they don't go in the
601 // globals stream or the modules stream). These have special handling which
602 // needs more investigation before we can get right, but by putting them all
603 // into the globals stream WinDbg fails to display local variables of class
604 // types saying that it cannot find the type Foo *. So as a stopgap just to
605 // keep things working, we drop them.
606 case SymbolKind::S_UDT:
612 static void addGlobalSymbol(pdb::GSIStreamBuilder &Builder, ObjFile &File,
613 const CVSymbol &Sym) {
614 switch (Sym.kind()) {
615 case SymbolKind::S_CONSTANT:
616 case SymbolKind::S_UDT:
617 case SymbolKind::S_GDATA32:
618 case SymbolKind::S_LDATA32:
619 case SymbolKind::S_PROCREF:
620 case SymbolKind::S_LPROCREF:
621 Builder.addGlobalSymbol(Sym);
623 case SymbolKind::S_GPROC32:
624 case SymbolKind::S_LPROC32: {
625 SymbolRecordKind K = SymbolRecordKind::ProcRefSym;
626 if (Sym.kind() == SymbolKind::S_LPROC32)
627 K = SymbolRecordKind::LocalProcRef;
629 PS.Module = static_cast<uint16_t>(File.ModuleDBI->getModuleIndex());
630 // For some reason, MSVC seems to add one to this value.
632 PS.Name = getSymbolName(Sym);
634 PS.SymOffset = File.ModuleDBI->getNextSymbolOffset();
635 Builder.addGlobalSymbol(PS);
639 llvm_unreachable("Invalid symbol kind!");
643 static void mergeSymbolRecords(BumpPtrAllocator &Alloc, ObjFile *File,
644 pdb::GSIStreamBuilder &GsiBuilder,
645 const CVIndexMap &IndexMap,
646 TypeCollection &IDTable,
647 BinaryStreamRef SymData) {
648 // FIXME: Improve error recovery by warning and skipping records when
651 BinaryStreamReader Reader(SymData);
652 ExitOnErr(Reader.readArray(Syms, Reader.getLength()));
653 SmallVector<SymbolScope, 4> Scopes;
654 for (CVSymbol Sym : Syms) {
655 // Discover type index references in the record. Skip it if we don't know
657 SmallVector<TiReference, 32> TypeRefs;
658 if (!discoverTypeIndicesInSymbol(Sym, TypeRefs)) {
659 log("ignoring unknown symbol record with kind 0x" + utohexstr(Sym.kind()));
663 // Copy the symbol record so we can mutate it.
664 MutableArrayRef<uint8_t> NewData = copySymbolForPdb(Sym, Alloc);
666 // Re-map all the type index references.
667 MutableArrayRef<uint8_t> Contents =
668 NewData.drop_front(sizeof(RecordPrefix));
669 remapTypesInSymbolRecord(File, Sym.kind(), Contents, IndexMap, TypeRefs);
671 // An object file may have S_xxx_ID symbols, but these get converted to
672 // "real" symbols in a PDB.
673 translateIdSymbols(NewData, IDTable);
675 SymbolKind NewKind = symbolKind(NewData);
677 // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
678 CVSymbol NewSym(NewKind, NewData);
679 if (symbolOpensScope(NewKind))
680 scopeStackOpen(Scopes, File->ModuleDBI->getNextSymbolOffset(), NewSym);
681 else if (symbolEndsScope(NewKind))
682 scopeStackClose(Scopes, File->ModuleDBI->getNextSymbolOffset(), File);
684 // Add the symbol to the globals stream if necessary. Do this before adding
685 // the symbol to the module since we may need to get the next symbol offset,
686 // and writing to the module's symbol stream will update that offset.
687 if (symbolGoesInGlobalsStream(NewSym))
688 addGlobalSymbol(GsiBuilder, *File, NewSym);
690 // Add the symbol to the module.
691 if (symbolGoesInModuleStream(NewSym))
692 File->ModuleDBI->addSymbol(NewSym);
696 // Allocate memory for a .debug$S section and relocate it.
697 static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
698 SectionChunk *DebugChunk) {
699 uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk->getSize());
700 assert(DebugChunk->OutputSectionOff == 0 &&
701 "debug sections should not be in output sections");
702 DebugChunk->writeTo(Buffer);
703 return consumeDebugMagic(makeArrayRef(Buffer, DebugChunk->getSize()),
707 void PDBLinker::addObjFile(ObjFile *File) {
708 // Add a module descriptor for every object file. We need to put an absolute
709 // path to the object into the PDB. If this is a plain object, we make its
710 // path absolute. If it's an object in an archive, we make the archive path
712 bool InArchive = !File->ParentName.empty();
713 SmallString<128> Path = InArchive ? File->ParentName : File->getName();
714 sys::fs::make_absolute(Path);
715 sys::path::native(Path, sys::path::Style::windows);
716 StringRef Name = InArchive ? File->getName() : StringRef(Path);
718 File->ModuleDBI = &ExitOnErr(Builder.getDbiBuilder().addModuleInfo(Name));
719 File->ModuleDBI->setObjFileName(Path);
721 // Before we can process symbol substreams from .debug$S, we need to process
722 // type information, file checksums, and the string table. Add type info to
723 // the PDB first, so that we can get the map from object file type and item
724 // indices to PDB type and item indices.
725 CVIndexMap ObjectIndexMap;
726 auto IndexMapResult = mergeDebugT(File, ObjectIndexMap);
728 // If the .debug$T sections fail to merge, assume there is no debug info.
729 if (!IndexMapResult) {
730 warn("Type server PDB for " + Name + " is invalid, ignoring debug info. " +
731 toString(IndexMapResult.takeError()));
735 const CVIndexMap &IndexMap = *IndexMapResult;
737 // Now do all live .debug$S sections.
738 for (SectionChunk *DebugChunk : File->getDebugChunks()) {
739 if (!DebugChunk->isLive() || DebugChunk->getSectionName() != ".debug$S")
742 ArrayRef<uint8_t> RelocatedDebugContents =
743 relocateDebugChunk(Alloc, DebugChunk);
744 if (RelocatedDebugContents.empty())
747 DebugSubsectionArray Subsections;
748 BinaryStreamReader Reader(RelocatedDebugContents, support::little);
749 ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
751 DebugStringTableSubsectionRef CVStrTab;
752 DebugChecksumsSubsectionRef Checksums;
753 for (const DebugSubsectionRecord &SS : Subsections) {
755 case DebugSubsectionKind::StringTable:
756 ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
758 case DebugSubsectionKind::FileChecksums:
759 ExitOnErr(Checksums.initialize(SS.getRecordData()));
761 case DebugSubsectionKind::Lines:
762 // We can add the relocated line table directly to the PDB without
763 // modification because the file checksum offsets will stay the same.
764 File->ModuleDBI->addDebugSubsection(SS);
766 case DebugSubsectionKind::Symbols:
767 if (Config->DebugGHashes) {
768 mergeSymbolRecords(Alloc, File, Builder.getGsiBuilder(), IndexMap,
769 GlobalIDTable, SS.getRecordData());
771 mergeSymbolRecords(Alloc, File, Builder.getGsiBuilder(), IndexMap,
772 IDTable, SS.getRecordData());
776 // FIXME: Process the rest of the subsections.
781 if (Checksums.valid()) {
782 // Make a new file checksum table that refers to offsets in the PDB-wide
783 // string table. Generally the string table subsection appears after the
784 // checksum table, so we have to do this after looping over all the
786 if (!CVStrTab.valid())
787 fatal(".debug$S sections must have both a string table subsection "
788 "and a checksum subsection table or neither");
789 auto NewChecksums = make_unique<DebugChecksumsSubsection>(PDBStrTab);
790 for (FileChecksumEntry &FC : Checksums) {
791 StringRef FileName = ExitOnErr(CVStrTab.getString(FC.FileNameOffset));
792 ExitOnErr(Builder.getDbiBuilder().addModuleSourceFile(*File->ModuleDBI,
794 NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
796 File->ModuleDBI->addDebugSubsection(std::move(NewChecksums));
801 static PublicSym32 createPublic(Defined *Def) {
802 PublicSym32 Pub(SymbolKind::S_PUB32);
803 Pub.Name = Def->getName();
804 if (auto *D = dyn_cast<DefinedCOFF>(Def)) {
805 if (D->getCOFFSymbol().isFunctionDefinition())
806 Pub.Flags = PublicSymFlags::Function;
807 } else if (isa<DefinedImportThunk>(Def)) {
808 Pub.Flags = PublicSymFlags::Function;
811 OutputSection *OS = Def->getChunk()->getOutputSection();
812 assert(OS && "all publics should be in final image");
813 Pub.Offset = Def->getRVA() - OS->getRVA();
814 Pub.Segment = OS->SectionIndex;
818 // Add all object files to the PDB. Merge .debug$T sections into IpiData and
820 void PDBLinker::addObjectsToPDB() {
821 for (ObjFile *File : ObjFile::Instances)
824 Builder.getStringTableBuilder().setStrings(PDBStrTab);
826 // Construct TPI and IPI stream contents.
827 if (Config->DebugGHashes) {
828 addTypeInfo(Builder.getTpiBuilder(), GlobalTypeTable);
829 addTypeInfo(Builder.getIpiBuilder(), GlobalIDTable);
831 addTypeInfo(Builder.getTpiBuilder(), TypeTable);
832 addTypeInfo(Builder.getIpiBuilder(), IDTable);
835 // Compute the public and global symbols.
836 auto &GsiBuilder = Builder.getGsiBuilder();
837 std::vector<PublicSym32> Publics;
838 Symtab->forEachSymbol([&Publics](Symbol *S) {
839 // Only emit defined, live symbols that have a chunk.
840 auto *Def = dyn_cast<Defined>(S);
841 if (Def && Def->isLive() && Def->getChunk())
842 Publics.push_back(createPublic(Def));
845 if (!Publics.empty()) {
846 // Sort the public symbols and add them to the stream.
847 std::sort(Publics.begin(), Publics.end(),
848 [](const PublicSym32 &L, const PublicSym32 &R) {
849 return L.Name < R.Name;
851 for (const PublicSym32 &Pub : Publics)
852 GsiBuilder.addPublicSymbol(Pub);
856 static void addCommonLinkerModuleSymbols(StringRef Path,
857 pdb::DbiModuleDescriptorBuilder &Mod,
858 BumpPtrAllocator &Allocator) {
859 ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
860 Compile3Sym CS(SymbolRecordKind::Compile3Sym);
861 EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
863 ONS.Name = "* Linker *";
866 CS.Machine = Config->is64() ? CPUType::X64 : CPUType::Intel80386;
867 // Interestingly, if we set the string to 0.0.0.0, then when trying to view
868 // local variables WinDbg emits an error that private symbols are not present.
869 // By setting this to a valid MSVC linker version string, local variables are
870 // displayed properly. As such, even though it is not representative of
871 // LLVM's version information, we need this for compatibility.
872 CS.Flags = CompileSym3Flags::None;
873 CS.VersionBackendBuild = 25019;
874 CS.VersionBackendMajor = 14;
875 CS.VersionBackendMinor = 10;
876 CS.VersionBackendQFE = 0;
878 // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
879 // linker module (which is by definition a backend), so we don't need to do
880 // anything here. Also, it seems we can use "LLVM Linker" for the linker name
881 // without any problems. Only the backend version has to be hardcoded to a
883 CS.VersionFrontendBuild = 0;
884 CS.VersionFrontendMajor = 0;
885 CS.VersionFrontendMinor = 0;
886 CS.VersionFrontendQFE = 0;
887 CS.Version = "LLVM Linker";
888 CS.setLanguage(SourceLanguage::Link);
890 ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
891 std::string ArgStr = llvm::join(Args, " ");
892 EBS.Fields.push_back("cwd");
894 sys::fs::current_path(cwd);
895 EBS.Fields.push_back(cwd);
896 EBS.Fields.push_back("exe");
897 SmallString<64> exe = Config->Argv[0];
898 llvm::sys::fs::make_absolute(exe);
899 EBS.Fields.push_back(exe);
900 EBS.Fields.push_back("pdb");
901 EBS.Fields.push_back(Path);
902 EBS.Fields.push_back("cmd");
903 EBS.Fields.push_back(ArgStr);
904 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
905 ONS, Allocator, CodeViewContainer::Pdb));
906 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
907 CS, Allocator, CodeViewContainer::Pdb));
908 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
909 EBS, Allocator, CodeViewContainer::Pdb));
912 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
914 BumpPtrAllocator &Allocator) {
915 SectionSym Sym(SymbolRecordKind::SectionSym);
916 Sym.Alignment = 12; // 2^12 = 4KB
917 Sym.Characteristics = OS.getCharacteristics();
918 Sym.Length = OS.getVirtualSize();
919 Sym.Name = OS.getName();
920 Sym.Rva = OS.getRVA();
921 Sym.SectionNumber = OS.SectionIndex;
922 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
923 Sym, Allocator, CodeViewContainer::Pdb));
926 // Creates a PDB file.
927 void coff::createPDB(SymbolTable *Symtab,
928 ArrayRef<OutputSection *> OutputSections,
929 ArrayRef<uint8_t> SectionTable,
930 const llvm::codeview::DebugInfo &BuildId) {
931 PDBLinker PDB(Symtab);
932 PDB.initialize(BuildId);
933 PDB.addObjectsToPDB();
934 PDB.addSections(OutputSections, SectionTable);
938 void PDBLinker::initialize(const llvm::codeview::DebugInfo &BuildId) {
939 ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
941 // Create streams in MSF for predefined streams, namely
942 // PDB, TPI, DBI and IPI.
943 for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
944 ExitOnErr(Builder.getMsfBuilder().addStream(0));
946 // Add an Info stream.
947 auto &InfoBuilder = Builder.getInfoBuilder();
948 InfoBuilder.setAge(BuildId.PDB70.Age);
951 memcpy(&uuid, &BuildId.PDB70.Signature, sizeof(uuid));
952 InfoBuilder.setGuid(uuid);
953 InfoBuilder.setSignature(time(nullptr));
954 InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
956 // Add an empty DBI stream.
957 pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
958 DbiBuilder.setAge(BuildId.PDB70.Age);
959 DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
960 ExitOnErr(DbiBuilder.addDbgStream(pdb::DbgHeaderType::NewFPO, {}));
963 void PDBLinker::addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
964 OutputSection *OS, Chunk *C) {
965 pdb::SectionContrib SC;
966 memset(&SC, 0, sizeof(SC));
967 SC.ISect = OS->SectionIndex;
968 SC.Off = C->getRVA() - OS->getRVA();
969 SC.Size = C->getSize();
970 if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
971 SC.Characteristics = SecChunk->Header->Characteristics;
972 SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
973 ArrayRef<uint8_t> Contents = SecChunk->getContents();
975 ArrayRef<char> CharContents = makeArrayRef(
976 reinterpret_cast<const char *>(Contents.data()), Contents.size());
977 CRC.update(CharContents);
978 SC.DataCrc = CRC.getCRC();
980 SC.Characteristics = OS->getCharacteristics();
981 // FIXME: When we start creating DBI for import libraries, use those here.
982 SC.Imod = LinkerModule.getModuleIndex();
984 SC.RelocCrc = 0; // FIXME
985 Builder.getDbiBuilder().addSectionContrib(SC);
988 void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
989 ArrayRef<uint8_t> SectionTable) {
990 // It's not entirely clear what this is, but the * Linker * module uses it.
991 pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
992 NativePath = Config->PDBPath;
993 sys::fs::make_absolute(NativePath);
994 sys::path::native(NativePath, sys::path::Style::windows);
995 uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
996 auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
997 LinkerModule.setPdbFilePathNI(PdbFilePathNI);
998 addCommonLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
1000 // Add section contributions. They must be ordered by ascending RVA.
1001 for (OutputSection *OS : OutputSections) {
1002 addLinkerModuleSectionSymbol(LinkerModule, *OS, Alloc);
1003 for (Chunk *C : OS->getChunks())
1004 addSectionContrib(LinkerModule, OS, C);
1007 // Add Section Map stream.
1008 ArrayRef<object::coff_section> Sections = {
1009 (const object::coff_section *)SectionTable.data(),
1010 SectionTable.size() / sizeof(object::coff_section)};
1011 SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
1012 DbiBuilder.setSectionMap(SectionMap);
1014 // Add COFF section header stream.
1016 DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
1019 void PDBLinker::commit() {
1021 ExitOnErr(Builder.commit(Config->PDBPath));