1 //===- PDB.cpp ------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "PDB.h" 10 #include "Chunks.h" 11 #include "Config.h" 12 #include "DebugTypes.h" 13 #include "Driver.h" 14 #include "SymbolTable.h" 15 #include "Symbols.h" 16 #include "TypeMerger.h" 17 #include "Writer.h" 18 #include "lld/Common/ErrorHandler.h" 19 #include "lld/Common/Timer.h" 20 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h" 21 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h" 22 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h" 23 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h" 24 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h" 25 #include "llvm/DebugInfo/CodeView/RecordName.h" 26 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h" 27 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h" 28 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h" 29 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.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/Object/CVDebugRecord.h" 49 #include "llvm/Support/BinaryByteStream.h" 50 #include "llvm/Support/CRC.h" 51 #include "llvm/Support/Endian.h" 52 #include "llvm/Support/Errc.h" 53 #include "llvm/Support/FormatAdapters.h" 54 #include "llvm/Support/FormatVariadic.h" 55 #include "llvm/Support/Path.h" 56 #include "llvm/Support/ScopedPrinter.h" 57 #include <memory> 58 59 using namespace llvm; 60 using namespace llvm::codeview; 61 using namespace lld; 62 using namespace lld::coff; 63 64 using llvm::object::coff_section; 65 using llvm::pdb::StringTableFixup; 66 67 static ExitOnError exitOnErr; 68 69 static Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root()); 70 static Timer addObjectsTimer("Add Objects", totalPdbLinkTimer); 71 Timer lld::coff::loadGHashTimer("Global Type Hashing", addObjectsTimer); 72 Timer lld::coff::mergeGHashTimer("GHash Type Merging", addObjectsTimer); 73 static Timer typeMergingTimer("Type Merging", addObjectsTimer); 74 static Timer symbolMergingTimer("Symbol Merging", addObjectsTimer); 75 static Timer publicsLayoutTimer("Publics Stream Layout", totalPdbLinkTimer); 76 static Timer tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer); 77 static Timer diskCommitTimer("Commit to Disk", totalPdbLinkTimer); 78 79 namespace { 80 class DebugSHandler; 81 82 class PDBLinker { 83 friend DebugSHandler; 84 85 public: 86 PDBLinker(SymbolTable *symtab) 87 : symtab(symtab), builder(bAlloc), tMerger(bAlloc) { 88 // This isn't strictly necessary, but link.exe usually puts an empty string 89 // as the first "valid" string in the string table, so we do the same in 90 // order to maintain as much byte-for-byte compatibility as possible. 91 pdbStrTab.insert(""); 92 } 93 94 /// Emit the basic PDB structure: initial streams, headers, etc. 95 void initialize(llvm::codeview::DebugInfo *buildId); 96 97 /// Add natvis files specified on the command line. 98 void addNatvisFiles(); 99 100 /// Add named streams specified on the command line. 101 void addNamedStreams(); 102 103 /// Link CodeView from each object file in the symbol table into the PDB. 104 void addObjectsToPDB(); 105 106 /// Add every live, defined public symbol to the PDB. 107 void addPublicsToPDB(); 108 109 /// Link info for each import file in the symbol table into the PDB. 110 void addImportFilesToPDB(ArrayRef<OutputSection *> outputSections); 111 112 void createModuleDBI(ObjFile *file); 113 114 /// Link CodeView from a single object file into the target (output) PDB. 115 /// When a precompiled headers object is linked, its TPI map might be provided 116 /// externally. 117 void addDebug(TpiSource *source); 118 119 void addDebugSymbols(TpiSource *source); 120 121 // Analyze the symbol records to separate module symbols from global symbols, 122 // find string references, and calculate how large the symbol stream will be 123 // in the PDB. 124 void analyzeSymbolSubsection(SectionChunk *debugChunk, 125 uint32_t &moduleSymOffset, 126 uint32_t &nextRelocIndex, 127 std::vector<StringTableFixup> &stringTableFixups, 128 BinaryStreamRef symData); 129 130 // Write all module symbols from all all live debug symbol subsections of the 131 // given object file into the given stream writer. 132 Error writeAllModuleSymbolRecords(ObjFile *file, BinaryStreamWriter &writer); 133 134 // Callback to copy and relocate debug symbols during PDB file writing. 135 static Error commitSymbolsForObject(void *ctx, void *obj, 136 BinaryStreamWriter &writer); 137 138 // Copy the symbol record, relocate it, and fix the alignment if necessary. 139 // Rewrite type indices in the record. Replace unrecognized symbol records 140 // with S_SKIP records. 141 void writeSymbolRecord(SectionChunk *debugChunk, 142 ArrayRef<uint8_t> sectionContents, CVSymbol sym, 143 size_t alignedSize, uint32_t &nextRelocIndex, 144 std::vector<uint8_t> &storage); 145 146 /// Add the section map and section contributions to the PDB. 147 void addSections(ArrayRef<OutputSection *> outputSections, 148 ArrayRef<uint8_t> sectionTable); 149 150 /// Write the PDB to disk and store the Guid generated for it in *Guid. 151 void commit(codeview::GUID *guid); 152 153 // Print statistics regarding the final PDB 154 void printStats(); 155 156 private: 157 SymbolTable *symtab; 158 159 pdb::PDBFileBuilder builder; 160 161 TypeMerger tMerger; 162 163 /// PDBs use a single global string table for filenames in the file checksum 164 /// table. 165 DebugStringTableSubsection pdbStrTab; 166 167 llvm::SmallString<128> nativePath; 168 169 // For statistics 170 uint64_t globalSymbols = 0; 171 uint64_t moduleSymbols = 0; 172 uint64_t publicSymbols = 0; 173 uint64_t nbTypeRecords = 0; 174 uint64_t nbTypeRecordsBytes = 0; 175 }; 176 177 /// Represents an unrelocated DEBUG_S_FRAMEDATA subsection. 178 struct UnrelocatedFpoData { 179 SectionChunk *debugChunk = nullptr; 180 ArrayRef<uint8_t> subsecData; 181 uint32_t relocIndex = 0; 182 }; 183 184 /// The size of the magic bytes at the beginning of a symbol section or stream. 185 enum : uint32_t { kSymbolStreamMagicSize = 4 }; 186 187 class DebugSHandler { 188 PDBLinker &linker; 189 190 /// The object file whose .debug$S sections we're processing. 191 ObjFile &file; 192 193 /// The result of merging type indices. 194 TpiSource *source; 195 196 /// The DEBUG_S_STRINGTABLE subsection. These strings are referred to by 197 /// index from other records in the .debug$S section. All of these strings 198 /// need to be added to the global PDB string table, and all references to 199 /// these strings need to have their indices re-written to refer to the 200 /// global PDB string table. 201 DebugStringTableSubsectionRef cvStrTab; 202 203 /// The DEBUG_S_FILECHKSMS subsection. As above, these are referred to 204 /// by other records in the .debug$S section and need to be merged into the 205 /// PDB. 206 DebugChecksumsSubsectionRef checksums; 207 208 /// The DEBUG_S_FRAMEDATA subsection(s). There can be more than one of 209 /// these and they need not appear in any specific order. However, they 210 /// contain string table references which need to be re-written, so we 211 /// collect them all here and re-write them after all subsections have been 212 /// discovered and processed. 213 std::vector<UnrelocatedFpoData> frameDataSubsecs; 214 215 /// List of string table references in symbol records. Later they will be 216 /// applied to the symbols during PDB writing. 217 std::vector<StringTableFixup> stringTableFixups; 218 219 /// Sum of the size of all module symbol records across all .debug$S sections. 220 /// Includes record realignment and the size of the symbol stream magic 221 /// prefix. 222 uint32_t moduleStreamSize = kSymbolStreamMagicSize; 223 224 /// Next relocation index in the current .debug$S section. Resets every 225 /// handleDebugS call. 226 uint32_t nextRelocIndex = 0; 227 228 void advanceRelocIndex(SectionChunk *debugChunk, ArrayRef<uint8_t> subsec); 229 230 void addUnrelocatedSubsection(SectionChunk *debugChunk, 231 const DebugSubsectionRecord &ss); 232 233 void addFrameDataSubsection(SectionChunk *debugChunk, 234 const DebugSubsectionRecord &ss); 235 236 void recordStringTableReferences(CVSymbol sym, uint32_t symOffset); 237 238 public: 239 DebugSHandler(PDBLinker &linker, ObjFile &file, TpiSource *source) 240 : linker(linker), file(file), source(source) {} 241 242 void handleDebugS(SectionChunk *debugChunk); 243 244 void finish(); 245 }; 246 } 247 248 // Visual Studio's debugger requires absolute paths in various places in the 249 // PDB to work without additional configuration: 250 // https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box 251 static void pdbMakeAbsolute(SmallVectorImpl<char> &fileName) { 252 // The default behavior is to produce paths that are valid within the context 253 // of the machine that you perform the link on. If the linker is running on 254 // a POSIX system, we will output absolute POSIX paths. If the linker is 255 // running on a Windows system, we will output absolute Windows paths. If the 256 // user desires any other kind of behavior, they should explicitly pass 257 // /pdbsourcepath, in which case we will treat the exact string the user 258 // passed in as the gospel and not normalize, canonicalize it. 259 if (sys::path::is_absolute(fileName, sys::path::Style::windows) || 260 sys::path::is_absolute(fileName, sys::path::Style::posix)) 261 return; 262 263 // It's not absolute in any path syntax. Relative paths necessarily refer to 264 // the local file system, so we can make it native without ending up with a 265 // nonsensical path. 266 if (config->pdbSourcePath.empty()) { 267 sys::path::native(fileName); 268 sys::fs::make_absolute(fileName); 269 return; 270 } 271 272 // Try to guess whether /PDBSOURCEPATH is a unix path or a windows path. 273 // Since PDB's are more of a Windows thing, we make this conservative and only 274 // decide that it's a unix path if we're fairly certain. Specifically, if 275 // it starts with a forward slash. 276 SmallString<128> absoluteFileName = config->pdbSourcePath; 277 sys::path::Style guessedStyle = absoluteFileName.startswith("/") 278 ? sys::path::Style::posix 279 : sys::path::Style::windows; 280 sys::path::append(absoluteFileName, guessedStyle, fileName); 281 sys::path::native(absoluteFileName, guessedStyle); 282 sys::path::remove_dots(absoluteFileName, true, guessedStyle); 283 284 fileName = std::move(absoluteFileName); 285 } 286 287 static void addTypeInfo(pdb::TpiStreamBuilder &tpiBuilder, 288 TypeCollection &typeTable) { 289 // Start the TPI or IPI stream header. 290 tpiBuilder.setVersionHeader(pdb::PdbTpiV80); 291 292 // Flatten the in memory type table and hash each type. 293 typeTable.ForEachRecord([&](TypeIndex ti, const CVType &type) { 294 auto hash = pdb::hashTypeRecord(type); 295 if (auto e = hash.takeError()) 296 fatal("type hashing error"); 297 tpiBuilder.addTypeRecord(type.RecordData, *hash); 298 }); 299 } 300 301 static void addGHashTypeInfo(pdb::PDBFileBuilder &builder) { 302 // Start the TPI or IPI stream header. 303 builder.getTpiBuilder().setVersionHeader(pdb::PdbTpiV80); 304 builder.getIpiBuilder().setVersionHeader(pdb::PdbTpiV80); 305 for_each(TpiSource::instances, [&](TpiSource *source) { 306 builder.getTpiBuilder().addTypeRecords(source->mergedTpi.recs, 307 source->mergedTpi.recSizes, 308 source->mergedTpi.recHashes); 309 builder.getIpiBuilder().addTypeRecords(source->mergedIpi.recs, 310 source->mergedIpi.recSizes, 311 source->mergedIpi.recHashes); 312 }); 313 } 314 315 static void 316 recordStringTableReferences(CVSymbol sym, uint32_t symOffset, 317 std::vector<StringTableFixup> &stringTableFixups) { 318 // For now we only handle S_FILESTATIC, but we may need the same logic for 319 // S_DEFRANGE and S_DEFRANGE_SUBFIELD. However, I cannot seem to generate any 320 // PDBs that contain these types of records, so because of the uncertainty 321 // they are omitted here until we can prove that it's necessary. 322 switch (sym.kind()) { 323 case SymbolKind::S_FILESTATIC: { 324 // FileStaticSym::ModFileOffset 325 uint32_t ref = *reinterpret_cast<const ulittle32_t *>(&sym.data()[8]); 326 stringTableFixups.push_back({ref, symOffset + 8}); 327 break; 328 } 329 case SymbolKind::S_DEFRANGE: 330 case SymbolKind::S_DEFRANGE_SUBFIELD: 331 log("Not fixing up string table reference in S_DEFRANGE / " 332 "S_DEFRANGE_SUBFIELD record"); 333 break; 334 default: 335 break; 336 } 337 } 338 339 static SymbolKind symbolKind(ArrayRef<uint8_t> recordData) { 340 const RecordPrefix *prefix = 341 reinterpret_cast<const RecordPrefix *>(recordData.data()); 342 return static_cast<SymbolKind>(uint16_t(prefix->RecordKind)); 343 } 344 345 /// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32 346 static void translateIdSymbols(MutableArrayRef<uint8_t> &recordData, 347 TypeMerger &tMerger, TpiSource *source) { 348 RecordPrefix *prefix = reinterpret_cast<RecordPrefix *>(recordData.data()); 349 350 SymbolKind kind = symbolKind(recordData); 351 352 if (kind == SymbolKind::S_PROC_ID_END) { 353 prefix->RecordKind = SymbolKind::S_END; 354 return; 355 } 356 357 // In an object file, GPROC32_ID has an embedded reference which refers to the 358 // single object file type index namespace. This has already been translated 359 // to the PDB file's ID stream index space, but we need to convert this to a 360 // symbol that refers to the type stream index space. So we remap again from 361 // ID index space to type index space. 362 if (kind == SymbolKind::S_GPROC32_ID || kind == SymbolKind::S_LPROC32_ID) { 363 SmallVector<TiReference, 1> refs; 364 auto content = recordData.drop_front(sizeof(RecordPrefix)); 365 CVSymbol sym(recordData); 366 discoverTypeIndicesInSymbol(sym, refs); 367 assert(refs.size() == 1); 368 assert(refs.front().Count == 1); 369 370 TypeIndex *ti = 371 reinterpret_cast<TypeIndex *>(content.data() + refs[0].Offset); 372 // `ti` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in 373 // the IPI stream, whose `FunctionType` member refers to the TPI stream. 374 // Note that LF_FUNC_ID and LF_MFUNC_ID have the same record layout, and 375 // in both cases we just need the second type index. 376 if (!ti->isSimple() && !ti->isNoneType()) { 377 if (config->debugGHashes) { 378 auto idToType = tMerger.funcIdToType.find(*ti); 379 if (idToType == tMerger.funcIdToType.end()) { 380 warn(formatv("S_[GL]PROC32_ID record in {0} refers to PDB item " 381 "index {1:X} which is not a LF_[M]FUNC_ID record", 382 source->file->getName(), ti->getIndex())); 383 *ti = TypeIndex(SimpleTypeKind::NotTranslated); 384 } else { 385 *ti = idToType->second; 386 } 387 } else { 388 CVType funcIdData = tMerger.getIDTable().getType(*ti); 389 ArrayRef<uint8_t> tiBuf = funcIdData.data().slice(8, 4); 390 assert(tiBuf.size() == 4 && "corrupt LF_[M]FUNC_ID record"); 391 *ti = *reinterpret_cast<const TypeIndex *>(tiBuf.data()); 392 } 393 } 394 395 kind = (kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32 396 : SymbolKind::S_LPROC32; 397 prefix->RecordKind = uint16_t(kind); 398 } 399 } 400 401 namespace { 402 struct ScopeRecord { 403 ulittle32_t ptrParent; 404 ulittle32_t ptrEnd; 405 }; 406 } // namespace 407 408 /// Given a pointer to a symbol record that opens a scope, return a pointer to 409 /// the scope fields. 410 static ScopeRecord *getSymbolScopeFields(void *sym) { 411 return reinterpret_cast<ScopeRecord *>(reinterpret_cast<char *>(sym) + 412 sizeof(RecordPrefix)); 413 } 414 415 // To open a scope, push the offset of the current symbol record onto the 416 // stack. 417 static void scopeStackOpen(SmallVectorImpl<uint32_t> &stack, 418 std::vector<uint8_t> &storage) { 419 stack.push_back(storage.size()); 420 } 421 422 // To close a scope, update the record that opened the scope. 423 static void scopeStackClose(SmallVectorImpl<uint32_t> &stack, 424 std::vector<uint8_t> &storage, 425 uint32_t storageBaseOffset, ObjFile *file) { 426 if (stack.empty()) { 427 warn("symbol scopes are not balanced in " + file->getName()); 428 return; 429 } 430 431 // Update ptrEnd of the record that opened the scope to point to the 432 // current record, if we are writing into the module symbol stream. 433 uint32_t offOpen = stack.pop_back_val(); 434 uint32_t offEnd = storageBaseOffset + storage.size(); 435 uint32_t offParent = stack.empty() ? 0 : (stack.back() + storageBaseOffset); 436 ScopeRecord *scopeRec = getSymbolScopeFields(&(storage)[offOpen]); 437 scopeRec->ptrParent = offParent; 438 scopeRec->ptrEnd = offEnd; 439 } 440 441 static bool symbolGoesInModuleStream(const CVSymbol &sym, 442 unsigned symbolScopeDepth) { 443 switch (sym.kind()) { 444 case SymbolKind::S_GDATA32: 445 case SymbolKind::S_CONSTANT: 446 case SymbolKind::S_GTHREAD32: 447 // We really should not be seeing S_PROCREF and S_LPROCREF in the first place 448 // since they are synthesized by the linker in response to S_GPROC32 and 449 // S_LPROC32, but if we do see them, don't put them in the module stream I 450 // guess. 451 case SymbolKind::S_PROCREF: 452 case SymbolKind::S_LPROCREF: 453 return false; 454 // S_UDT records go in the module stream if it is not a global S_UDT. 455 case SymbolKind::S_UDT: 456 return symbolScopeDepth > 0; 457 // S_GDATA32 does not go in the module stream, but S_LDATA32 does. 458 case SymbolKind::S_LDATA32: 459 case SymbolKind::S_LTHREAD32: 460 default: 461 return true; 462 } 463 } 464 465 static bool symbolGoesInGlobalsStream(const CVSymbol &sym, 466 unsigned symbolScopeDepth) { 467 switch (sym.kind()) { 468 case SymbolKind::S_CONSTANT: 469 case SymbolKind::S_GDATA32: 470 case SymbolKind::S_GTHREAD32: 471 case SymbolKind::S_GPROC32: 472 case SymbolKind::S_LPROC32: 473 case SymbolKind::S_GPROC32_ID: 474 case SymbolKind::S_LPROC32_ID: 475 // We really should not be seeing S_PROCREF and S_LPROCREF in the first place 476 // since they are synthesized by the linker in response to S_GPROC32 and 477 // S_LPROC32, but if we do see them, copy them straight through. 478 case SymbolKind::S_PROCREF: 479 case SymbolKind::S_LPROCREF: 480 return true; 481 // Records that go in the globals stream, unless they are function-local. 482 case SymbolKind::S_UDT: 483 case SymbolKind::S_LDATA32: 484 case SymbolKind::S_LTHREAD32: 485 return symbolScopeDepth == 0; 486 default: 487 return false; 488 } 489 } 490 491 static void addGlobalSymbol(pdb::GSIStreamBuilder &builder, uint16_t modIndex, 492 unsigned symOffset, 493 std::vector<uint8_t> &symStorage) { 494 CVSymbol sym(makeArrayRef(symStorage)); 495 switch (sym.kind()) { 496 case SymbolKind::S_CONSTANT: 497 case SymbolKind::S_UDT: 498 case SymbolKind::S_GDATA32: 499 case SymbolKind::S_GTHREAD32: 500 case SymbolKind::S_LTHREAD32: 501 case SymbolKind::S_LDATA32: 502 case SymbolKind::S_PROCREF: 503 case SymbolKind::S_LPROCREF: { 504 // sym is a temporary object, so we have to copy and reallocate the record 505 // to stabilize it. 506 uint8_t *mem = bAlloc.Allocate<uint8_t>(sym.length()); 507 memcpy(mem, sym.data().data(), sym.length()); 508 builder.addGlobalSymbol(CVSymbol(makeArrayRef(mem, sym.length()))); 509 break; 510 } 511 case SymbolKind::S_GPROC32: 512 case SymbolKind::S_LPROC32: { 513 SymbolRecordKind k = SymbolRecordKind::ProcRefSym; 514 if (sym.kind() == SymbolKind::S_LPROC32) 515 k = SymbolRecordKind::LocalProcRef; 516 ProcRefSym ps(k); 517 ps.Module = modIndex; 518 // For some reason, MSVC seems to add one to this value. 519 ++ps.Module; 520 ps.Name = getSymbolName(sym); 521 ps.SumName = 0; 522 ps.SymOffset = symOffset; 523 builder.addGlobalSymbol(ps); 524 break; 525 } 526 default: 527 llvm_unreachable("Invalid symbol kind!"); 528 } 529 } 530 531 // Check if the given symbol record was padded for alignment. If so, zero out 532 // the padding bytes and update the record prefix with the new size. 533 static void fixRecordAlignment(MutableArrayRef<uint8_t> recordBytes, 534 size_t oldSize) { 535 size_t alignedSize = recordBytes.size(); 536 if (oldSize == alignedSize) 537 return; 538 reinterpret_cast<RecordPrefix *>(recordBytes.data())->RecordLen = 539 alignedSize - 2; 540 memset(recordBytes.data() + oldSize, 0, alignedSize - oldSize); 541 } 542 543 // Replace any record with a skip record of the same size. This is useful when 544 // we have reserved size for a symbol record, but type index remapping fails. 545 static void replaceWithSkipRecord(MutableArrayRef<uint8_t> recordBytes) { 546 memset(recordBytes.data(), 0, recordBytes.size()); 547 auto *prefix = reinterpret_cast<RecordPrefix *>(recordBytes.data()); 548 prefix->RecordKind = SymbolKind::S_SKIP; 549 prefix->RecordLen = recordBytes.size() - 2; 550 } 551 552 // Copy the symbol record, relocate it, and fix the alignment if necessary. 553 // Rewrite type indices in the record. Replace unrecognized symbol records with 554 // S_SKIP records. 555 void PDBLinker::writeSymbolRecord(SectionChunk *debugChunk, 556 ArrayRef<uint8_t> sectionContents, 557 CVSymbol sym, size_t alignedSize, 558 uint32_t &nextRelocIndex, 559 std::vector<uint8_t> &storage) { 560 // Allocate space for the new record at the end of the storage. 561 storage.resize(storage.size() + alignedSize); 562 auto recordBytes = MutableArrayRef<uint8_t>(storage).take_back(alignedSize); 563 564 // Copy the symbol record and relocate it. 565 debugChunk->writeAndRelocateSubsection(sectionContents, sym.data(), 566 nextRelocIndex, recordBytes.data()); 567 fixRecordAlignment(recordBytes, sym.length()); 568 569 // Re-map all the type index references. 570 TpiSource *source = debugChunk->file->debugTypesObj; 571 if (!source->remapTypesInSymbolRecord(recordBytes)) { 572 log("ignoring unknown symbol record with kind 0x" + utohexstr(sym.kind())); 573 replaceWithSkipRecord(recordBytes); 574 } 575 576 // An object file may have S_xxx_ID symbols, but these get converted to 577 // "real" symbols in a PDB. 578 translateIdSymbols(recordBytes, tMerger, source); 579 } 580 581 void PDBLinker::analyzeSymbolSubsection( 582 SectionChunk *debugChunk, uint32_t &moduleSymOffset, 583 uint32_t &nextRelocIndex, std::vector<StringTableFixup> &stringTableFixups, 584 BinaryStreamRef symData) { 585 ObjFile *file = debugChunk->file; 586 uint32_t moduleSymStart = moduleSymOffset; 587 588 uint32_t scopeLevel = 0; 589 std::vector<uint8_t> storage; 590 ArrayRef<uint8_t> sectionContents = debugChunk->getContents(); 591 592 ArrayRef<uint8_t> symsBuffer; 593 cantFail(symData.readBytes(0, symData.getLength(), symsBuffer)); 594 595 if (symsBuffer.empty()) 596 warn("empty symbols subsection in " + file->getName()); 597 598 Error ec = forEachCodeViewRecord<CVSymbol>( 599 symsBuffer, [&](CVSymbol sym) -> llvm::Error { 600 // Track the current scope. 601 if (symbolOpensScope(sym.kind())) 602 ++scopeLevel; 603 else if (symbolEndsScope(sym.kind())) 604 --scopeLevel; 605 606 uint32_t alignedSize = 607 alignTo(sym.length(), alignOf(CodeViewContainer::Pdb)); 608 609 // Copy global records. Some global records (mainly procedures) 610 // reference the current offset into the module stream. 611 if (symbolGoesInGlobalsStream(sym, scopeLevel)) { 612 storage.clear(); 613 writeSymbolRecord(debugChunk, sectionContents, sym, alignedSize, 614 nextRelocIndex, storage); 615 addGlobalSymbol(builder.getGsiBuilder(), 616 file->moduleDBI->getModuleIndex(), moduleSymOffset, 617 storage); 618 ++globalSymbols; 619 } 620 621 // Update the module stream offset and record any string table index 622 // references. There are very few of these and they will be rewritten 623 // later during PDB writing. 624 if (symbolGoesInModuleStream(sym, scopeLevel)) { 625 recordStringTableReferences(sym, moduleSymOffset, stringTableFixups); 626 moduleSymOffset += alignedSize; 627 ++moduleSymbols; 628 } 629 630 return Error::success(); 631 }); 632 633 // If we encountered corrupt records, ignore the whole subsection. If we wrote 634 // any partial records, undo that. For globals, we just keep what we have and 635 // continue. 636 if (ec) { 637 warn("corrupt symbol records in " + file->getName()); 638 moduleSymOffset = moduleSymStart; 639 consumeError(std::move(ec)); 640 } 641 } 642 643 Error PDBLinker::writeAllModuleSymbolRecords(ObjFile *file, 644 BinaryStreamWriter &writer) { 645 std::vector<uint8_t> storage; 646 SmallVector<uint32_t, 4> scopes; 647 648 // Visit all live .debug$S sections a second time, and write them to the PDB. 649 for (SectionChunk *debugChunk : file->getDebugChunks()) { 650 if (!debugChunk->live || debugChunk->getSize() == 0 || 651 debugChunk->getSectionName() != ".debug$S") 652 continue; 653 654 ArrayRef<uint8_t> sectionContents = debugChunk->getContents(); 655 auto contents = 656 SectionChunk::consumeDebugMagic(sectionContents, ".debug$S"); 657 DebugSubsectionArray subsections; 658 BinaryStreamReader reader(contents, support::little); 659 exitOnErr(reader.readArray(subsections, contents.size())); 660 661 uint32_t nextRelocIndex = 0; 662 for (const DebugSubsectionRecord &ss : subsections) { 663 if (ss.kind() != DebugSubsectionKind::Symbols) 664 continue; 665 666 uint32_t moduleSymStart = writer.getOffset(); 667 scopes.clear(); 668 storage.clear(); 669 ArrayRef<uint8_t> symsBuffer; 670 BinaryStreamRef sr = ss.getRecordData(); 671 cantFail(sr.readBytes(0, sr.getLength(), symsBuffer)); 672 auto ec = forEachCodeViewRecord<CVSymbol>( 673 symsBuffer, [&](CVSymbol sym) -> llvm::Error { 674 // Track the current scope. Only update records in the postmerge 675 // pass. 676 if (symbolOpensScope(sym.kind())) 677 scopeStackOpen(scopes, storage); 678 else if (symbolEndsScope(sym.kind())) 679 scopeStackClose(scopes, storage, moduleSymStart, file); 680 681 // Copy, relocate, and rewrite each module symbol. 682 if (symbolGoesInModuleStream(sym, scopes.size())) { 683 uint32_t alignedSize = 684 alignTo(sym.length(), alignOf(CodeViewContainer::Pdb)); 685 writeSymbolRecord(debugChunk, sectionContents, sym, alignedSize, 686 nextRelocIndex, storage); 687 } 688 return Error::success(); 689 }); 690 691 // If we encounter corrupt records in the second pass, ignore them. We 692 // already warned about them in the first analysis pass. 693 if (ec) { 694 consumeError(std::move(ec)); 695 storage.clear(); 696 } 697 698 // Writing bytes has a very high overhead, so write the entire subsection 699 // at once. 700 // TODO: Consider buffering symbols for the entire object file to reduce 701 // overhead even further. 702 if (Error e = writer.writeBytes(storage)) 703 return e; 704 } 705 } 706 707 return Error::success(); 708 } 709 710 Error PDBLinker::commitSymbolsForObject(void *ctx, void *obj, 711 BinaryStreamWriter &writer) { 712 return static_cast<PDBLinker *>(ctx)->writeAllModuleSymbolRecords( 713 static_cast<ObjFile *>(obj), writer); 714 } 715 716 static pdb::SectionContrib createSectionContrib(const Chunk *c, uint32_t modi) { 717 OutputSection *os = c ? c->getOutputSection() : nullptr; 718 pdb::SectionContrib sc; 719 memset(&sc, 0, sizeof(sc)); 720 sc.ISect = os ? os->sectionIndex : llvm::pdb::kInvalidStreamIndex; 721 sc.Off = c && os ? c->getRVA() - os->getRVA() : 0; 722 sc.Size = c ? c->getSize() : -1; 723 if (auto *secChunk = dyn_cast_or_null<SectionChunk>(c)) { 724 sc.Characteristics = secChunk->header->Characteristics; 725 sc.Imod = secChunk->file->moduleDBI->getModuleIndex(); 726 ArrayRef<uint8_t> contents = secChunk->getContents(); 727 JamCRC crc(0); 728 crc.update(contents); 729 sc.DataCrc = crc.getCRC(); 730 } else { 731 sc.Characteristics = os ? os->header.Characteristics : 0; 732 sc.Imod = modi; 733 } 734 sc.RelocCrc = 0; // FIXME 735 736 return sc; 737 } 738 739 static uint32_t 740 translateStringTableIndex(uint32_t objIndex, 741 const DebugStringTableSubsectionRef &objStrTable, 742 DebugStringTableSubsection &pdbStrTable) { 743 auto expectedString = objStrTable.getString(objIndex); 744 if (!expectedString) { 745 warn("Invalid string table reference"); 746 consumeError(expectedString.takeError()); 747 return 0; 748 } 749 750 return pdbStrTable.insert(*expectedString); 751 } 752 753 void DebugSHandler::handleDebugS(SectionChunk *debugChunk) { 754 // Note that we are processing the *unrelocated* section contents. They will 755 // be relocated later during PDB writing. 756 ArrayRef<uint8_t> contents = debugChunk->getContents(); 757 contents = SectionChunk::consumeDebugMagic(contents, ".debug$S"); 758 DebugSubsectionArray subsections; 759 BinaryStreamReader reader(contents, support::little); 760 exitOnErr(reader.readArray(subsections, contents.size())); 761 debugChunk->sortRelocations(); 762 763 // Reset the relocation index, since this is a new section. 764 nextRelocIndex = 0; 765 766 for (const DebugSubsectionRecord &ss : subsections) { 767 // Ignore subsections with the 'ignore' bit. Some versions of the Visual C++ 768 // runtime have subsections with this bit set. 769 if (uint32_t(ss.kind()) & codeview::SubsectionIgnoreFlag) 770 continue; 771 772 switch (ss.kind()) { 773 case DebugSubsectionKind::StringTable: { 774 assert(!cvStrTab.valid() && 775 "Encountered multiple string table subsections!"); 776 exitOnErr(cvStrTab.initialize(ss.getRecordData())); 777 break; 778 } 779 case DebugSubsectionKind::FileChecksums: 780 assert(!checksums.valid() && 781 "Encountered multiple checksum subsections!"); 782 exitOnErr(checksums.initialize(ss.getRecordData())); 783 break; 784 case DebugSubsectionKind::Lines: 785 case DebugSubsectionKind::InlineeLines: 786 addUnrelocatedSubsection(debugChunk, ss); 787 break; 788 case DebugSubsectionKind::FrameData: 789 addFrameDataSubsection(debugChunk, ss); 790 break; 791 case DebugSubsectionKind::Symbols: 792 linker.analyzeSymbolSubsection(debugChunk, moduleStreamSize, 793 nextRelocIndex, stringTableFixups, 794 ss.getRecordData()); 795 break; 796 797 case DebugSubsectionKind::CrossScopeImports: 798 case DebugSubsectionKind::CrossScopeExports: 799 // These appear to relate to cross-module optimization, so we might use 800 // these for ThinLTO. 801 break; 802 803 case DebugSubsectionKind::ILLines: 804 case DebugSubsectionKind::FuncMDTokenMap: 805 case DebugSubsectionKind::TypeMDTokenMap: 806 case DebugSubsectionKind::MergedAssemblyInput: 807 // These appear to relate to .Net assembly info. 808 break; 809 810 case DebugSubsectionKind::CoffSymbolRVA: 811 // Unclear what this is for. 812 break; 813 814 default: 815 warn("ignoring unknown debug$S subsection kind 0x" + 816 utohexstr(uint32_t(ss.kind())) + " in file " + toString(&file)); 817 break; 818 } 819 } 820 } 821 822 void DebugSHandler::advanceRelocIndex(SectionChunk *sc, 823 ArrayRef<uint8_t> subsec) { 824 ptrdiff_t vaBegin = subsec.data() - sc->getContents().data(); 825 assert(vaBegin > 0); 826 auto relocs = sc->getRelocs(); 827 for (; nextRelocIndex < relocs.size(); ++nextRelocIndex) { 828 if (relocs[nextRelocIndex].VirtualAddress >= vaBegin) 829 break; 830 } 831 } 832 833 namespace { 834 /// Wrapper class for unrelocated line and inlinee line subsections, which 835 /// require only relocation and type index remapping to add to the PDB. 836 class UnrelocatedDebugSubsection : public DebugSubsection { 837 public: 838 UnrelocatedDebugSubsection(DebugSubsectionKind k, SectionChunk *debugChunk, 839 ArrayRef<uint8_t> subsec, uint32_t relocIndex) 840 : DebugSubsection(k), debugChunk(debugChunk), subsec(subsec), 841 relocIndex(relocIndex) {} 842 843 Error commit(BinaryStreamWriter &writer) const override; 844 uint32_t calculateSerializedSize() const override { return subsec.size(); } 845 846 SectionChunk *debugChunk; 847 ArrayRef<uint8_t> subsec; 848 uint32_t relocIndex; 849 }; 850 } // namespace 851 852 Error UnrelocatedDebugSubsection::commit(BinaryStreamWriter &writer) const { 853 std::vector<uint8_t> relocatedBytes(subsec.size()); 854 uint32_t tmpRelocIndex = relocIndex; 855 debugChunk->writeAndRelocateSubsection(debugChunk->getContents(), subsec, 856 tmpRelocIndex, relocatedBytes.data()); 857 858 // Remap type indices in inlinee line records in place. Skip the remapping if 859 // there is no type source info. 860 if (kind() == DebugSubsectionKind::InlineeLines && 861 debugChunk->file->debugTypesObj) { 862 TpiSource *source = debugChunk->file->debugTypesObj; 863 DebugInlineeLinesSubsectionRef inlineeLines; 864 BinaryStreamReader storageReader(relocatedBytes, support::little); 865 exitOnErr(inlineeLines.initialize(storageReader)); 866 for (const InlineeSourceLine &line : inlineeLines) { 867 TypeIndex &inlinee = *const_cast<TypeIndex *>(&line.Header->Inlinee); 868 if (!source->remapTypeIndex(inlinee, TiRefKind::IndexRef)) { 869 log("bad inlinee line record in " + debugChunk->file->getName() + 870 " with bad inlinee index 0x" + utohexstr(inlinee.getIndex())); 871 } 872 } 873 } 874 875 return writer.writeBytes(relocatedBytes); 876 } 877 878 void DebugSHandler::addUnrelocatedSubsection(SectionChunk *debugChunk, 879 const DebugSubsectionRecord &ss) { 880 ArrayRef<uint8_t> subsec; 881 BinaryStreamRef sr = ss.getRecordData(); 882 cantFail(sr.readBytes(0, sr.getLength(), subsec)); 883 advanceRelocIndex(debugChunk, subsec); 884 file.moduleDBI->addDebugSubsection( 885 std::make_shared<UnrelocatedDebugSubsection>(ss.kind(), debugChunk, 886 subsec, nextRelocIndex)); 887 } 888 889 void DebugSHandler::addFrameDataSubsection(SectionChunk *debugChunk, 890 const DebugSubsectionRecord &ss) { 891 // We need to re-write string table indices here, so save off all 892 // frame data subsections until we've processed the entire list of 893 // subsections so that we can be sure we have the string table. 894 ArrayRef<uint8_t> subsec; 895 BinaryStreamRef sr = ss.getRecordData(); 896 cantFail(sr.readBytes(0, sr.getLength(), subsec)); 897 advanceRelocIndex(debugChunk, subsec); 898 frameDataSubsecs.push_back({debugChunk, subsec, nextRelocIndex}); 899 } 900 901 static Expected<StringRef> 902 getFileName(const DebugStringTableSubsectionRef &strings, 903 const DebugChecksumsSubsectionRef &checksums, uint32_t fileID) { 904 auto iter = checksums.getArray().at(fileID); 905 if (iter == checksums.getArray().end()) 906 return make_error<CodeViewError>(cv_error_code::no_records); 907 uint32_t offset = iter->FileNameOffset; 908 return strings.getString(offset); 909 } 910 911 void DebugSHandler::finish() { 912 pdb::DbiStreamBuilder &dbiBuilder = linker.builder.getDbiBuilder(); 913 914 // If we found any symbol records for the module symbol stream, defer them. 915 if (moduleStreamSize > kSymbolStreamMagicSize) 916 file.moduleDBI->addUnmergedSymbols(&file, moduleStreamSize - 917 kSymbolStreamMagicSize); 918 919 // We should have seen all debug subsections across the entire object file now 920 // which means that if a StringTable subsection and Checksums subsection were 921 // present, now is the time to handle them. 922 if (!cvStrTab.valid()) { 923 if (checksums.valid()) 924 fatal(".debug$S sections with a checksums subsection must also contain a " 925 "string table subsection"); 926 927 if (!stringTableFixups.empty()) 928 warn("No StringTable subsection was encountered, but there are string " 929 "table references"); 930 return; 931 } 932 933 // Handle FPO data. Each subsection begins with a single image base 934 // relocation, which is then added to the RvaStart of each frame data record 935 // when it is added to the PDB. The string table indices for the FPO program 936 // must also be rewritten to use the PDB string table. 937 for (const UnrelocatedFpoData &subsec : frameDataSubsecs) { 938 // Relocate the first four bytes of the subection and reinterpret them as a 939 // 32 bit integer. 940 SectionChunk *debugChunk = subsec.debugChunk; 941 ArrayRef<uint8_t> subsecData = subsec.subsecData; 942 uint32_t relocIndex = subsec.relocIndex; 943 auto unrelocatedRvaStart = subsecData.take_front(sizeof(uint32_t)); 944 uint8_t relocatedRvaStart[sizeof(uint32_t)]; 945 debugChunk->writeAndRelocateSubsection(debugChunk->getContents(), 946 unrelocatedRvaStart, relocIndex, 947 &relocatedRvaStart[0]); 948 uint32_t rvaStart; 949 memcpy(&rvaStart, &relocatedRvaStart[0], sizeof(uint32_t)); 950 951 // Copy each frame data record, add in rvaStart, translate string table 952 // indices, and add the record to the PDB. 953 DebugFrameDataSubsectionRef fds; 954 BinaryStreamReader reader(subsecData, support::little); 955 exitOnErr(fds.initialize(reader)); 956 for (codeview::FrameData fd : fds) { 957 fd.RvaStart += rvaStart; 958 fd.FrameFunc = 959 translateStringTableIndex(fd.FrameFunc, cvStrTab, linker.pdbStrTab); 960 dbiBuilder.addNewFpoData(fd); 961 } 962 } 963 964 // Translate the fixups and pass them off to the module builder so they will 965 // be applied during writing. 966 for (StringTableFixup &ref : stringTableFixups) { 967 ref.StrTabOffset = 968 translateStringTableIndex(ref.StrTabOffset, cvStrTab, linker.pdbStrTab); 969 } 970 file.moduleDBI->setStringTableFixups(std::move(stringTableFixups)); 971 972 // Make a new file checksum table that refers to offsets in the PDB-wide 973 // string table. Generally the string table subsection appears after the 974 // checksum table, so we have to do this after looping over all the 975 // subsections. The new checksum table must have the exact same layout and 976 // size as the original. Otherwise, the file references in the line and 977 // inlinee line tables will be incorrect. 978 auto newChecksums = std::make_unique<DebugChecksumsSubsection>(linker.pdbStrTab); 979 for (FileChecksumEntry &fc : checksums) { 980 SmallString<128> filename = 981 exitOnErr(cvStrTab.getString(fc.FileNameOffset)); 982 pdbMakeAbsolute(filename); 983 exitOnErr(dbiBuilder.addModuleSourceFile(*file.moduleDBI, filename)); 984 newChecksums->addChecksum(filename, fc.Kind, fc.Checksum); 985 } 986 assert(checksums.getArray().getUnderlyingStream().getLength() == 987 newChecksums->calculateSerializedSize() && 988 "file checksum table must have same layout"); 989 990 file.moduleDBI->addDebugSubsection(std::move(newChecksums)); 991 } 992 993 static void warnUnusable(InputFile *f, Error e) { 994 if (!config->warnDebugInfoUnusable) { 995 consumeError(std::move(e)); 996 return; 997 } 998 auto msg = "Cannot use debug info for '" + toString(f) + "' [LNK4099]"; 999 if (e) 1000 warn(msg + "\n>>> failed to load reference " + toString(std::move(e))); 1001 else 1002 warn(msg); 1003 } 1004 1005 // Allocate memory for a .debug$S / .debug$F section and relocate it. 1006 static ArrayRef<uint8_t> relocateDebugChunk(SectionChunk &debugChunk) { 1007 uint8_t *buffer = bAlloc.Allocate<uint8_t>(debugChunk.getSize()); 1008 assert(debugChunk.getOutputSectionIdx() == 0 && 1009 "debug sections should not be in output sections"); 1010 debugChunk.writeTo(buffer); 1011 return makeArrayRef(buffer, debugChunk.getSize()); 1012 } 1013 1014 void PDBLinker::addDebugSymbols(TpiSource *source) { 1015 // If this TpiSource doesn't have an object file, it must be from a type 1016 // server PDB. Type server PDBs do not contain symbols, so stop here. 1017 if (!source->file) 1018 return; 1019 1020 ScopedTimer t(symbolMergingTimer); 1021 pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder(); 1022 DebugSHandler dsh(*this, *source->file, source); 1023 // Now do all live .debug$S and .debug$F sections. 1024 for (SectionChunk *debugChunk : source->file->getDebugChunks()) { 1025 if (!debugChunk->live || debugChunk->getSize() == 0) 1026 continue; 1027 1028 bool isDebugS = debugChunk->getSectionName() == ".debug$S"; 1029 bool isDebugF = debugChunk->getSectionName() == ".debug$F"; 1030 if (!isDebugS && !isDebugF) 1031 continue; 1032 1033 if (isDebugS) { 1034 dsh.handleDebugS(debugChunk); 1035 } else if (isDebugF) { 1036 // Handle old FPO data .debug$F sections. These are relatively rare. 1037 ArrayRef<uint8_t> relocatedDebugContents = 1038 relocateDebugChunk(*debugChunk); 1039 FixedStreamArray<object::FpoData> fpoRecords; 1040 BinaryStreamReader reader(relocatedDebugContents, support::little); 1041 uint32_t count = relocatedDebugContents.size() / sizeof(object::FpoData); 1042 exitOnErr(reader.readArray(fpoRecords, count)); 1043 1044 // These are already relocated and don't refer to the string table, so we 1045 // can just copy it. 1046 for (const object::FpoData &fd : fpoRecords) 1047 dbiBuilder.addOldFpoData(fd); 1048 } 1049 } 1050 1051 // Do any post-processing now that all .debug$S sections have been processed. 1052 dsh.finish(); 1053 } 1054 1055 // Add a module descriptor for every object file. We need to put an absolute 1056 // path to the object into the PDB. If this is a plain object, we make its 1057 // path absolute. If it's an object in an archive, we make the archive path 1058 // absolute. 1059 void PDBLinker::createModuleDBI(ObjFile *file) { 1060 pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder(); 1061 SmallString<128> objName; 1062 1063 bool inArchive = !file->parentName.empty(); 1064 objName = inArchive ? file->parentName : file->getName(); 1065 pdbMakeAbsolute(objName); 1066 StringRef modName = inArchive ? file->getName() : StringRef(objName); 1067 1068 file->moduleDBI = &exitOnErr(dbiBuilder.addModuleInfo(modName)); 1069 file->moduleDBI->setObjFileName(objName); 1070 file->moduleDBI->setMergeSymbolsCallback(this, &commitSymbolsForObject); 1071 1072 ArrayRef<Chunk *> chunks = file->getChunks(); 1073 uint32_t modi = file->moduleDBI->getModuleIndex(); 1074 1075 for (Chunk *c : chunks) { 1076 auto *secChunk = dyn_cast<SectionChunk>(c); 1077 if (!secChunk || !secChunk->live) 1078 continue; 1079 pdb::SectionContrib sc = createSectionContrib(secChunk, modi); 1080 file->moduleDBI->setFirstSectionContrib(sc); 1081 break; 1082 } 1083 } 1084 1085 void PDBLinker::addDebug(TpiSource *source) { 1086 // Before we can process symbol substreams from .debug$S, we need to process 1087 // type information, file checksums, and the string table. Add type info to 1088 // the PDB first, so that we can get the map from object file type and item 1089 // indices to PDB type and item indices. If we are using ghashes, types have 1090 // already been merged. 1091 if (!config->debugGHashes) { 1092 ScopedTimer t(typeMergingTimer); 1093 if (Error e = source->mergeDebugT(&tMerger)) { 1094 // If type merging failed, ignore the symbols. 1095 warnUnusable(source->file, std::move(e)); 1096 return; 1097 } 1098 } 1099 1100 // If type merging failed, ignore the symbols. 1101 Error typeError = std::move(source->typeMergingError); 1102 if (typeError) { 1103 warnUnusable(source->file, std::move(typeError)); 1104 return; 1105 } 1106 1107 addDebugSymbols(source); 1108 } 1109 1110 static pdb::BulkPublic createPublic(Defined *def) { 1111 pdb::BulkPublic pub; 1112 pub.Name = def->getName().data(); 1113 pub.NameLen = def->getName().size(); 1114 1115 PublicSymFlags flags = PublicSymFlags::None; 1116 if (auto *d = dyn_cast<DefinedCOFF>(def)) { 1117 if (d->getCOFFSymbol().isFunctionDefinition()) 1118 flags = PublicSymFlags::Function; 1119 } else if (isa<DefinedImportThunk>(def)) { 1120 flags = PublicSymFlags::Function; 1121 } 1122 pub.setFlags(flags); 1123 1124 OutputSection *os = def->getChunk()->getOutputSection(); 1125 assert(os && "all publics should be in final image"); 1126 pub.Offset = def->getRVA() - os->getRVA(); 1127 pub.Segment = os->sectionIndex; 1128 return pub; 1129 } 1130 1131 // Add all object files to the PDB. Merge .debug$T sections into IpiData and 1132 // TpiData. 1133 void PDBLinker::addObjectsToPDB() { 1134 ScopedTimer t1(addObjectsTimer); 1135 1136 // Create module descriptors 1137 for_each(ObjFile::instances, [&](ObjFile *obj) { createModuleDBI(obj); }); 1138 1139 // Reorder dependency type sources to come first. 1140 TpiSource::sortDependencies(); 1141 1142 // Merge type information from input files using global type hashing. 1143 if (config->debugGHashes) 1144 tMerger.mergeTypesWithGHash(); 1145 1146 // Merge dependencies and then regular objects. 1147 for_each(TpiSource::dependencySources, 1148 [&](TpiSource *source) { addDebug(source); }); 1149 for_each(TpiSource::objectSources, 1150 [&](TpiSource *source) { addDebug(source); }); 1151 1152 builder.getStringTableBuilder().setStrings(pdbStrTab); 1153 t1.stop(); 1154 1155 // Construct TPI and IPI stream contents. 1156 ScopedTimer t2(tpiStreamLayoutTimer); 1157 // Collect all the merged types. 1158 if (config->debugGHashes) { 1159 addGHashTypeInfo(builder); 1160 } else { 1161 addTypeInfo(builder.getTpiBuilder(), tMerger.getTypeTable()); 1162 addTypeInfo(builder.getIpiBuilder(), tMerger.getIDTable()); 1163 } 1164 t2.stop(); 1165 1166 if (config->showSummary) { 1167 for_each(TpiSource::instances, [&](TpiSource *source) { 1168 nbTypeRecords += source->nbTypeRecords; 1169 nbTypeRecordsBytes += source->nbTypeRecordsBytes; 1170 }); 1171 } 1172 } 1173 1174 void PDBLinker::addPublicsToPDB() { 1175 ScopedTimer t3(publicsLayoutTimer); 1176 // Compute the public symbols. 1177 auto &gsiBuilder = builder.getGsiBuilder(); 1178 std::vector<pdb::BulkPublic> publics; 1179 symtab->forEachSymbol([&publics](Symbol *s) { 1180 // Only emit external, defined, live symbols that have a chunk. Static, 1181 // non-external symbols do not appear in the symbol table. 1182 auto *def = dyn_cast<Defined>(s); 1183 if (def && def->isLive() && def->getChunk()) 1184 publics.push_back(createPublic(def)); 1185 }); 1186 1187 if (!publics.empty()) { 1188 publicSymbols = publics.size(); 1189 gsiBuilder.addPublicSymbols(std::move(publics)); 1190 } 1191 } 1192 1193 void PDBLinker::printStats() { 1194 if (!config->showSummary) 1195 return; 1196 1197 SmallString<256> buffer; 1198 raw_svector_ostream stream(buffer); 1199 1200 stream << center_justify("Summary", 80) << '\n' 1201 << std::string(80, '-') << '\n'; 1202 1203 auto print = [&](uint64_t v, StringRef s) { 1204 stream << format_decimal(v, 15) << " " << s << '\n'; 1205 }; 1206 1207 print(ObjFile::instances.size(), 1208 "Input OBJ files (expanded from all cmd-line inputs)"); 1209 print(TpiSource::countTypeServerPDBs(), "PDB type server dependencies"); 1210 print(TpiSource::countPrecompObjs(), "Precomp OBJ dependencies"); 1211 print(nbTypeRecords, "Input type records"); 1212 print(nbTypeRecordsBytes, "Input type records bytes"); 1213 print(builder.getTpiBuilder().getRecordCount(), "Merged TPI records"); 1214 print(builder.getIpiBuilder().getRecordCount(), "Merged IPI records"); 1215 print(pdbStrTab.size(), "Output PDB strings"); 1216 print(globalSymbols, "Global symbol records"); 1217 print(moduleSymbols, "Module symbol records"); 1218 print(publicSymbols, "Public symbol records"); 1219 1220 auto printLargeInputTypeRecs = [&](StringRef name, 1221 ArrayRef<uint32_t> recCounts, 1222 TypeCollection &records) { 1223 // Figure out which type indices were responsible for the most duplicate 1224 // bytes in the input files. These should be frequently emitted LF_CLASS and 1225 // LF_FIELDLIST records. 1226 struct TypeSizeInfo { 1227 uint32_t typeSize; 1228 uint32_t dupCount; 1229 TypeIndex typeIndex; 1230 uint64_t totalInputSize() const { return uint64_t(dupCount) * typeSize; } 1231 bool operator<(const TypeSizeInfo &rhs) const { 1232 if (totalInputSize() == rhs.totalInputSize()) 1233 return typeIndex < rhs.typeIndex; 1234 return totalInputSize() < rhs.totalInputSize(); 1235 } 1236 }; 1237 SmallVector<TypeSizeInfo, 0> tsis; 1238 for (auto e : enumerate(recCounts)) { 1239 TypeIndex typeIndex = TypeIndex::fromArrayIndex(e.index()); 1240 uint32_t typeSize = records.getType(typeIndex).length(); 1241 uint32_t dupCount = e.value(); 1242 tsis.push_back({typeSize, dupCount, typeIndex}); 1243 } 1244 1245 if (!tsis.empty()) { 1246 stream << "\nTop 10 types responsible for the most " << name 1247 << " input:\n"; 1248 stream << " index total bytes count size\n"; 1249 llvm::sort(tsis); 1250 unsigned i = 0; 1251 for (const auto &tsi : reverse(tsis)) { 1252 stream << formatv(" {0,10:X}: {1,14:N} = {2,5:N} * {3,6:N}\n", 1253 tsi.typeIndex.getIndex(), tsi.totalInputSize(), 1254 tsi.dupCount, tsi.typeSize); 1255 if (++i >= 10) 1256 break; 1257 } 1258 stream 1259 << "Run llvm-pdbutil to print details about a particular record:\n"; 1260 stream << formatv("llvm-pdbutil dump -{0}s -{0}-index {1:X} {2}\n", 1261 (name == "TPI" ? "type" : "id"), 1262 tsis.back().typeIndex.getIndex(), config->pdbPath); 1263 } 1264 }; 1265 1266 if (!config->debugGHashes) { 1267 // FIXME: Reimplement for ghash. 1268 printLargeInputTypeRecs("TPI", tMerger.tpiCounts, tMerger.getTypeTable()); 1269 printLargeInputTypeRecs("IPI", tMerger.ipiCounts, tMerger.getIDTable()); 1270 } 1271 1272 message(buffer); 1273 } 1274 1275 void PDBLinker::addNatvisFiles() { 1276 for (StringRef file : config->natvisFiles) { 1277 ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr = 1278 MemoryBuffer::getFile(file); 1279 if (!dataOrErr) { 1280 warn("Cannot open input file: " + file); 1281 continue; 1282 } 1283 builder.addInjectedSource(file, std::move(*dataOrErr)); 1284 } 1285 } 1286 1287 void PDBLinker::addNamedStreams() { 1288 for (const auto &streamFile : config->namedStreams) { 1289 const StringRef stream = streamFile.getKey(), file = streamFile.getValue(); 1290 ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr = 1291 MemoryBuffer::getFile(file); 1292 if (!dataOrErr) { 1293 warn("Cannot open input file: " + file); 1294 continue; 1295 } 1296 exitOnErr(builder.addNamedStream(stream, (*dataOrErr)->getBuffer())); 1297 } 1298 } 1299 1300 static codeview::CPUType toCodeViewMachine(COFF::MachineTypes machine) { 1301 switch (machine) { 1302 case COFF::IMAGE_FILE_MACHINE_AMD64: 1303 return codeview::CPUType::X64; 1304 case COFF::IMAGE_FILE_MACHINE_ARM: 1305 return codeview::CPUType::ARM7; 1306 case COFF::IMAGE_FILE_MACHINE_ARM64: 1307 return codeview::CPUType::ARM64; 1308 case COFF::IMAGE_FILE_MACHINE_ARMNT: 1309 return codeview::CPUType::ARMNT; 1310 case COFF::IMAGE_FILE_MACHINE_I386: 1311 return codeview::CPUType::Intel80386; 1312 default: 1313 llvm_unreachable("Unsupported CPU Type"); 1314 } 1315 } 1316 1317 // Mimic MSVC which surrounds arguments containing whitespace with quotes. 1318 // Double double-quotes are handled, so that the resulting string can be 1319 // executed again on the cmd-line. 1320 static std::string quote(ArrayRef<StringRef> args) { 1321 std::string r; 1322 r.reserve(256); 1323 for (StringRef a : args) { 1324 if (!r.empty()) 1325 r.push_back(' '); 1326 bool hasWS = a.find(' ') != StringRef::npos; 1327 bool hasQ = a.find('"') != StringRef::npos; 1328 if (hasWS || hasQ) 1329 r.push_back('"'); 1330 if (hasQ) { 1331 SmallVector<StringRef, 4> s; 1332 a.split(s, '"'); 1333 r.append(join(s, "\"\"")); 1334 } else { 1335 r.append(std::string(a)); 1336 } 1337 if (hasWS || hasQ) 1338 r.push_back('"'); 1339 } 1340 return r; 1341 } 1342 1343 static void fillLinkerVerRecord(Compile3Sym &cs) { 1344 cs.Machine = toCodeViewMachine(config->machine); 1345 // Interestingly, if we set the string to 0.0.0.0, then when trying to view 1346 // local variables WinDbg emits an error that private symbols are not present. 1347 // By setting this to a valid MSVC linker version string, local variables are 1348 // displayed properly. As such, even though it is not representative of 1349 // LLVM's version information, we need this for compatibility. 1350 cs.Flags = CompileSym3Flags::None; 1351 cs.VersionBackendBuild = 25019; 1352 cs.VersionBackendMajor = 14; 1353 cs.VersionBackendMinor = 10; 1354 cs.VersionBackendQFE = 0; 1355 1356 // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the 1357 // linker module (which is by definition a backend), so we don't need to do 1358 // anything here. Also, it seems we can use "LLVM Linker" for the linker name 1359 // without any problems. Only the backend version has to be hardcoded to a 1360 // magic number. 1361 cs.VersionFrontendBuild = 0; 1362 cs.VersionFrontendMajor = 0; 1363 cs.VersionFrontendMinor = 0; 1364 cs.VersionFrontendQFE = 0; 1365 cs.Version = "LLVM Linker"; 1366 cs.setLanguage(SourceLanguage::Link); 1367 } 1368 1369 static void addCommonLinkerModuleSymbols(StringRef path, 1370 pdb::DbiModuleDescriptorBuilder &mod) { 1371 ObjNameSym ons(SymbolRecordKind::ObjNameSym); 1372 EnvBlockSym ebs(SymbolRecordKind::EnvBlockSym); 1373 Compile3Sym cs(SymbolRecordKind::Compile3Sym); 1374 fillLinkerVerRecord(cs); 1375 1376 ons.Name = "* Linker *"; 1377 ons.Signature = 0; 1378 1379 ArrayRef<StringRef> args = makeArrayRef(config->argv).drop_front(); 1380 std::string argStr = quote(args); 1381 ebs.Fields.push_back("cwd"); 1382 SmallString<64> cwd; 1383 if (config->pdbSourcePath.empty()) 1384 sys::fs::current_path(cwd); 1385 else 1386 cwd = config->pdbSourcePath; 1387 ebs.Fields.push_back(cwd); 1388 ebs.Fields.push_back("exe"); 1389 SmallString<64> exe = config->argv[0]; 1390 pdbMakeAbsolute(exe); 1391 ebs.Fields.push_back(exe); 1392 ebs.Fields.push_back("pdb"); 1393 ebs.Fields.push_back(path); 1394 ebs.Fields.push_back("cmd"); 1395 ebs.Fields.push_back(argStr); 1396 mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1397 ons, bAlloc, CodeViewContainer::Pdb)); 1398 mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1399 cs, bAlloc, CodeViewContainer::Pdb)); 1400 mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1401 ebs, bAlloc, CodeViewContainer::Pdb)); 1402 } 1403 1404 static void addLinkerModuleCoffGroup(PartialSection *sec, 1405 pdb::DbiModuleDescriptorBuilder &mod, 1406 OutputSection &os) { 1407 // If there's a section, there's at least one chunk 1408 assert(!sec->chunks.empty()); 1409 const Chunk *firstChunk = *sec->chunks.begin(); 1410 const Chunk *lastChunk = *sec->chunks.rbegin(); 1411 1412 // Emit COFF group 1413 CoffGroupSym cgs(SymbolRecordKind::CoffGroupSym); 1414 cgs.Name = sec->name; 1415 cgs.Segment = os.sectionIndex; 1416 cgs.Offset = firstChunk->getRVA() - os.getRVA(); 1417 cgs.Size = lastChunk->getRVA() + lastChunk->getSize() - firstChunk->getRVA(); 1418 cgs.Characteristics = sec->characteristics; 1419 1420 // Somehow .idata sections & sections groups in the debug symbol stream have 1421 // the "write" flag set. However the section header for the corresponding 1422 // .idata section doesn't have it. 1423 if (cgs.Name.startswith(".idata")) 1424 cgs.Characteristics |= llvm::COFF::IMAGE_SCN_MEM_WRITE; 1425 1426 mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1427 cgs, bAlloc, CodeViewContainer::Pdb)); 1428 } 1429 1430 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &mod, 1431 OutputSection &os) { 1432 SectionSym sym(SymbolRecordKind::SectionSym); 1433 sym.Alignment = 12; // 2^12 = 4KB 1434 sym.Characteristics = os.header.Characteristics; 1435 sym.Length = os.getVirtualSize(); 1436 sym.Name = os.name; 1437 sym.Rva = os.getRVA(); 1438 sym.SectionNumber = os.sectionIndex; 1439 mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1440 sym, bAlloc, CodeViewContainer::Pdb)); 1441 1442 // Skip COFF groups in MinGW because it adds a significant footprint to the 1443 // PDB, due to each function being in its own section 1444 if (config->mingw) 1445 return; 1446 1447 // Output COFF groups for individual chunks of this section. 1448 for (PartialSection *sec : os.contribSections) { 1449 addLinkerModuleCoffGroup(sec, mod, os); 1450 } 1451 } 1452 1453 // Add all import files as modules to the PDB. 1454 void PDBLinker::addImportFilesToPDB(ArrayRef<OutputSection *> outputSections) { 1455 if (ImportFile::instances.empty()) 1456 return; 1457 1458 std::map<std::string, llvm::pdb::DbiModuleDescriptorBuilder *> dllToModuleDbi; 1459 1460 for (ImportFile *file : ImportFile::instances) { 1461 if (!file->live) 1462 continue; 1463 1464 if (!file->thunkSym) 1465 continue; 1466 1467 if (!file->thunkLive) 1468 continue; 1469 1470 std::string dll = StringRef(file->dllName).lower(); 1471 llvm::pdb::DbiModuleDescriptorBuilder *&mod = dllToModuleDbi[dll]; 1472 if (!mod) { 1473 pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder(); 1474 SmallString<128> libPath = file->parentName; 1475 pdbMakeAbsolute(libPath); 1476 sys::path::native(libPath); 1477 1478 // Name modules similar to MSVC's link.exe. 1479 // The first module is the simple dll filename 1480 llvm::pdb::DbiModuleDescriptorBuilder &firstMod = 1481 exitOnErr(dbiBuilder.addModuleInfo(file->dllName)); 1482 firstMod.setObjFileName(libPath); 1483 pdb::SectionContrib sc = 1484 createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex); 1485 firstMod.setFirstSectionContrib(sc); 1486 1487 // The second module is where the import stream goes. 1488 mod = &exitOnErr(dbiBuilder.addModuleInfo("Import:" + file->dllName)); 1489 mod->setObjFileName(libPath); 1490 } 1491 1492 DefinedImportThunk *thunk = cast<DefinedImportThunk>(file->thunkSym); 1493 Chunk *thunkChunk = thunk->getChunk(); 1494 OutputSection *thunkOS = thunkChunk->getOutputSection(); 1495 1496 ObjNameSym ons(SymbolRecordKind::ObjNameSym); 1497 Compile3Sym cs(SymbolRecordKind::Compile3Sym); 1498 Thunk32Sym ts(SymbolRecordKind::Thunk32Sym); 1499 ScopeEndSym es(SymbolRecordKind::ScopeEndSym); 1500 1501 ons.Name = file->dllName; 1502 ons.Signature = 0; 1503 1504 fillLinkerVerRecord(cs); 1505 1506 ts.Name = thunk->getName(); 1507 ts.Parent = 0; 1508 ts.End = 0; 1509 ts.Next = 0; 1510 ts.Thunk = ThunkOrdinal::Standard; 1511 ts.Length = thunkChunk->getSize(); 1512 ts.Segment = thunkOS->sectionIndex; 1513 ts.Offset = thunkChunk->getRVA() - thunkOS->getRVA(); 1514 1515 mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1516 ons, bAlloc, CodeViewContainer::Pdb)); 1517 mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol( 1518 cs, bAlloc, CodeViewContainer::Pdb)); 1519 1520 CVSymbol newSym = codeview::SymbolSerializer::writeOneSymbol( 1521 ts, bAlloc, CodeViewContainer::Pdb); 1522 1523 // Write ptrEnd for the S_THUNK32. 1524 ScopeRecord *thunkSymScope = 1525 getSymbolScopeFields(const_cast<uint8_t *>(newSym.data().data())); 1526 1527 mod->addSymbol(newSym); 1528 1529 newSym = codeview::SymbolSerializer::writeOneSymbol(es, bAlloc, 1530 CodeViewContainer::Pdb); 1531 thunkSymScope->ptrEnd = mod->getNextSymbolOffset(); 1532 1533 mod->addSymbol(newSym); 1534 1535 pdb::SectionContrib sc = 1536 createSectionContrib(thunk->getChunk(), mod->getModuleIndex()); 1537 mod->setFirstSectionContrib(sc); 1538 } 1539 } 1540 1541 // Creates a PDB file. 1542 void lld::coff::createPDB(SymbolTable *symtab, 1543 ArrayRef<OutputSection *> outputSections, 1544 ArrayRef<uint8_t> sectionTable, 1545 llvm::codeview::DebugInfo *buildId) { 1546 ScopedTimer t1(totalPdbLinkTimer); 1547 PDBLinker pdb(symtab); 1548 1549 pdb.initialize(buildId); 1550 pdb.addObjectsToPDB(); 1551 pdb.addImportFilesToPDB(outputSections); 1552 pdb.addSections(outputSections, sectionTable); 1553 pdb.addNatvisFiles(); 1554 pdb.addNamedStreams(); 1555 pdb.addPublicsToPDB(); 1556 1557 ScopedTimer t2(diskCommitTimer); 1558 codeview::GUID guid; 1559 pdb.commit(&guid); 1560 memcpy(&buildId->PDB70.Signature, &guid, 16); 1561 1562 t2.stop(); 1563 t1.stop(); 1564 pdb.printStats(); 1565 } 1566 1567 void PDBLinker::initialize(llvm::codeview::DebugInfo *buildId) { 1568 exitOnErr(builder.initialize(4096)); // 4096 is blocksize 1569 1570 buildId->Signature.CVSignature = OMF::Signature::PDB70; 1571 // Signature is set to a hash of the PDB contents when the PDB is done. 1572 memset(buildId->PDB70.Signature, 0, 16); 1573 buildId->PDB70.Age = 1; 1574 1575 // Create streams in MSF for predefined streams, namely 1576 // PDB, TPI, DBI and IPI. 1577 for (int i = 0; i < (int)pdb::kSpecialStreamCount; ++i) 1578 exitOnErr(builder.getMsfBuilder().addStream(0)); 1579 1580 // Add an Info stream. 1581 auto &infoBuilder = builder.getInfoBuilder(); 1582 infoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70); 1583 infoBuilder.setHashPDBContentsToGUID(true); 1584 1585 // Add an empty DBI stream. 1586 pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder(); 1587 dbiBuilder.setAge(buildId->PDB70.Age); 1588 dbiBuilder.setVersionHeader(pdb::PdbDbiV70); 1589 dbiBuilder.setMachineType(config->machine); 1590 // Technically we are not link.exe 14.11, but there are known cases where 1591 // debugging tools on Windows expect Microsoft-specific version numbers or 1592 // they fail to work at all. Since we know we produce PDBs that are 1593 // compatible with LINK 14.11, we set that version number here. 1594 dbiBuilder.setBuildNumber(14, 11); 1595 } 1596 1597 void PDBLinker::addSections(ArrayRef<OutputSection *> outputSections, 1598 ArrayRef<uint8_t> sectionTable) { 1599 // It's not entirely clear what this is, but the * Linker * module uses it. 1600 pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder(); 1601 nativePath = config->pdbPath; 1602 pdbMakeAbsolute(nativePath); 1603 uint32_t pdbFilePathNI = dbiBuilder.addECName(nativePath); 1604 auto &linkerModule = exitOnErr(dbiBuilder.addModuleInfo("* Linker *")); 1605 linkerModule.setPdbFilePathNI(pdbFilePathNI); 1606 addCommonLinkerModuleSymbols(nativePath, linkerModule); 1607 1608 // Add section contributions. They must be ordered by ascending RVA. 1609 for (OutputSection *os : outputSections) { 1610 addLinkerModuleSectionSymbol(linkerModule, *os); 1611 for (Chunk *c : os->chunks) { 1612 pdb::SectionContrib sc = 1613 createSectionContrib(c, linkerModule.getModuleIndex()); 1614 builder.getDbiBuilder().addSectionContrib(sc); 1615 } 1616 } 1617 1618 // The * Linker * first section contrib is only used along with /INCREMENTAL, 1619 // to provide trampolines thunks for incremental function patching. Set this 1620 // as "unused" because LLD doesn't support /INCREMENTAL link. 1621 pdb::SectionContrib sc = 1622 createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex); 1623 linkerModule.setFirstSectionContrib(sc); 1624 1625 // Add Section Map stream. 1626 ArrayRef<object::coff_section> sections = { 1627 (const object::coff_section *)sectionTable.data(), 1628 sectionTable.size() / sizeof(object::coff_section)}; 1629 dbiBuilder.createSectionMap(sections); 1630 1631 // Add COFF section header stream. 1632 exitOnErr( 1633 dbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, sectionTable)); 1634 } 1635 1636 void PDBLinker::commit(codeview::GUID *guid) { 1637 ExitOnError exitOnErr((config->pdbPath + ": ").str()); 1638 // Write to a file. 1639 exitOnErr(builder.commit(config->pdbPath, guid)); 1640 } 1641 1642 static uint32_t getSecrelReloc() { 1643 switch (config->machine) { 1644 case AMD64: 1645 return COFF::IMAGE_REL_AMD64_SECREL; 1646 case I386: 1647 return COFF::IMAGE_REL_I386_SECREL; 1648 case ARMNT: 1649 return COFF::IMAGE_REL_ARM_SECREL; 1650 case ARM64: 1651 return COFF::IMAGE_REL_ARM64_SECREL; 1652 default: 1653 llvm_unreachable("unknown machine type"); 1654 } 1655 } 1656 1657 // Try to find a line table for the given offset Addr into the given chunk C. 1658 // If a line table was found, the line table, the string and checksum tables 1659 // that are used to interpret the line table, and the offset of Addr in the line 1660 // table are stored in the output arguments. Returns whether a line table was 1661 // found. 1662 static bool findLineTable(const SectionChunk *c, uint32_t addr, 1663 DebugStringTableSubsectionRef &cvStrTab, 1664 DebugChecksumsSubsectionRef &checksums, 1665 DebugLinesSubsectionRef &lines, 1666 uint32_t &offsetInLinetable) { 1667 ExitOnError exitOnErr; 1668 uint32_t secrelReloc = getSecrelReloc(); 1669 1670 for (SectionChunk *dbgC : c->file->getDebugChunks()) { 1671 if (dbgC->getSectionName() != ".debug$S") 1672 continue; 1673 1674 // Build a mapping of SECREL relocations in dbgC that refer to `c`. 1675 DenseMap<uint32_t, uint32_t> secrels; 1676 for (const coff_relocation &r : dbgC->getRelocs()) { 1677 if (r.Type != secrelReloc) 1678 continue; 1679 1680 if (auto *s = dyn_cast_or_null<DefinedRegular>( 1681 c->file->getSymbols()[r.SymbolTableIndex])) 1682 if (s->getChunk() == c) 1683 secrels[r.VirtualAddress] = s->getValue(); 1684 } 1685 1686 ArrayRef<uint8_t> contents = 1687 SectionChunk::consumeDebugMagic(dbgC->getContents(), ".debug$S"); 1688 DebugSubsectionArray subsections; 1689 BinaryStreamReader reader(contents, support::little); 1690 exitOnErr(reader.readArray(subsections, contents.size())); 1691 1692 for (const DebugSubsectionRecord &ss : subsections) { 1693 switch (ss.kind()) { 1694 case DebugSubsectionKind::StringTable: { 1695 assert(!cvStrTab.valid() && 1696 "Encountered multiple string table subsections!"); 1697 exitOnErr(cvStrTab.initialize(ss.getRecordData())); 1698 break; 1699 } 1700 case DebugSubsectionKind::FileChecksums: 1701 assert(!checksums.valid() && 1702 "Encountered multiple checksum subsections!"); 1703 exitOnErr(checksums.initialize(ss.getRecordData())); 1704 break; 1705 case DebugSubsectionKind::Lines: { 1706 ArrayRef<uint8_t> bytes; 1707 auto ref = ss.getRecordData(); 1708 exitOnErr(ref.readLongestContiguousChunk(0, bytes)); 1709 size_t offsetInDbgC = bytes.data() - dbgC->getContents().data(); 1710 1711 // Check whether this line table refers to C. 1712 auto i = secrels.find(offsetInDbgC); 1713 if (i == secrels.end()) 1714 break; 1715 1716 // Check whether this line table covers Addr in C. 1717 DebugLinesSubsectionRef linesTmp; 1718 exitOnErr(linesTmp.initialize(BinaryStreamReader(ref))); 1719 uint32_t offsetInC = i->second + linesTmp.header()->RelocOffset; 1720 if (addr < offsetInC || addr >= offsetInC + linesTmp.header()->CodeSize) 1721 break; 1722 1723 assert(!lines.header() && 1724 "Encountered multiple line tables for function!"); 1725 exitOnErr(lines.initialize(BinaryStreamReader(ref))); 1726 offsetInLinetable = addr - offsetInC; 1727 break; 1728 } 1729 default: 1730 break; 1731 } 1732 1733 if (cvStrTab.valid() && checksums.valid() && lines.header()) 1734 return true; 1735 } 1736 } 1737 1738 return false; 1739 } 1740 1741 // Use CodeView line tables to resolve a file and line number for the given 1742 // offset into the given chunk and return them, or None if a line table was 1743 // not found. 1744 Optional<std::pair<StringRef, uint32_t>> 1745 lld::coff::getFileLineCodeView(const SectionChunk *c, uint32_t addr) { 1746 ExitOnError exitOnErr; 1747 1748 DebugStringTableSubsectionRef cvStrTab; 1749 DebugChecksumsSubsectionRef checksums; 1750 DebugLinesSubsectionRef lines; 1751 uint32_t offsetInLinetable; 1752 1753 if (!findLineTable(c, addr, cvStrTab, checksums, lines, offsetInLinetable)) 1754 return None; 1755 1756 Optional<uint32_t> nameIndex; 1757 Optional<uint32_t> lineNumber; 1758 for (LineColumnEntry &entry : lines) { 1759 for (const LineNumberEntry &ln : entry.LineNumbers) { 1760 LineInfo li(ln.Flags); 1761 if (ln.Offset > offsetInLinetable) { 1762 if (!nameIndex) { 1763 nameIndex = entry.NameIndex; 1764 lineNumber = li.getStartLine(); 1765 } 1766 StringRef filename = 1767 exitOnErr(getFileName(cvStrTab, checksums, *nameIndex)); 1768 return std::make_pair(filename, *lineNumber); 1769 } 1770 nameIndex = entry.NameIndex; 1771 lineNumber = li.getStartLine(); 1772 } 1773 } 1774 if (!nameIndex) 1775 return None; 1776 StringRef filename = exitOnErr(getFileName(cvStrTab, checksums, *nameIndex)); 1777 return std::make_pair(filename, *lineNumber); 1778 } 1779