1 //===- CodeViewYAMLDebugSections.cpp - CodeView YAMLIO debug sections -----===// 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 // This file defines classes for handling the YAML representation of CodeView 10 // Debug Info. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h" 15 #include "llvm/ADT/STLExtras.h" 16 #include "llvm/ADT/StringExtras.h" 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/BinaryFormat/COFF.h" 19 #include "llvm/DebugInfo/CodeView/CodeView.h" 20 #include "llvm/DebugInfo/CodeView/CodeViewError.h" 21 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h" 22 #include "llvm/DebugInfo/CodeView/DebugCrossExSubsection.h" 23 #include "llvm/DebugInfo/CodeView/DebugCrossImpSubsection.h" 24 #include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h" 25 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h" 26 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h" 27 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h" 28 #include "llvm/DebugInfo/CodeView/DebugSubsection.h" 29 #include "llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h" 30 #include "llvm/DebugInfo/CodeView/DebugSymbolRVASubsection.h" 31 #include "llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h" 32 #include "llvm/DebugInfo/CodeView/Line.h" 33 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h" 34 #include "llvm/DebugInfo/CodeView/TypeIndex.h" 35 #include "llvm/ObjectYAML/CodeViewYAMLSymbols.h" 36 #include "llvm/Support/Allocator.h" 37 #include "llvm/Support/BinaryStreamReader.h" 38 #include "llvm/Support/Endian.h" 39 #include "llvm/Support/Error.h" 40 #include "llvm/Support/ErrorHandling.h" 41 #include "llvm/Support/YAMLTraits.h" 42 #include "llvm/Support/raw_ostream.h" 43 #include <algorithm> 44 #include <cassert> 45 #include <cstdint> 46 #include <memory> 47 #include <string> 48 #include <tuple> 49 #include <vector> 50 51 using namespace llvm; 52 using namespace llvm::codeview; 53 using namespace llvm::CodeViewYAML; 54 using namespace llvm::CodeViewYAML::detail; 55 using namespace llvm::yaml; 56 57 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceFileChecksumEntry) 58 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineEntry) 59 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceColumnEntry) 60 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineBlock) 61 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineInfo) 62 LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeSite) 63 LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeInfo) 64 LLVM_YAML_IS_SEQUENCE_VECTOR(CrossModuleExport) 65 LLVM_YAML_IS_SEQUENCE_VECTOR(YAMLCrossModuleImport) 66 LLVM_YAML_IS_SEQUENCE_VECTOR(YAMLFrameData) 67 68 LLVM_YAML_DECLARE_SCALAR_TRAITS(HexFormattedString, QuotingType::None) 69 LLVM_YAML_DECLARE_ENUM_TRAITS(DebugSubsectionKind) 70 LLVM_YAML_DECLARE_ENUM_TRAITS(FileChecksumKind) 71 LLVM_YAML_DECLARE_BITSET_TRAITS(LineFlags) 72 73 LLVM_YAML_DECLARE_MAPPING_TRAITS(CrossModuleExport) 74 LLVM_YAML_DECLARE_MAPPING_TRAITS(YAMLFrameData) 75 LLVM_YAML_DECLARE_MAPPING_TRAITS(YAMLCrossModuleImport) 76 LLVM_YAML_DECLARE_MAPPING_TRAITS(CrossModuleImportItem) 77 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceLineEntry) 78 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceColumnEntry) 79 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceFileChecksumEntry) 80 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceLineBlock) 81 LLVM_YAML_DECLARE_MAPPING_TRAITS(InlineeSite) 82 83 namespace llvm { 84 namespace CodeViewYAML { 85 namespace detail { 86 87 struct YAMLSubsectionBase { 88 explicit YAMLSubsectionBase(DebugSubsectionKind Kind) : Kind(Kind) {} 89 virtual ~YAMLSubsectionBase() = default; 90 91 virtual void map(IO &IO) = 0; 92 virtual std::shared_ptr<DebugSubsection> 93 toCodeViewSubsection(BumpPtrAllocator &Allocator, 94 const codeview::StringsAndChecksums &SC) const = 0; 95 96 DebugSubsectionKind Kind; 97 }; 98 99 } // end namespace detail 100 } // end namespace CodeViewYAML 101 } // end namespace llvm 102 103 namespace { 104 105 struct YAMLChecksumsSubsection : public YAMLSubsectionBase { 106 YAMLChecksumsSubsection() 107 : YAMLSubsectionBase(DebugSubsectionKind::FileChecksums) {} 108 109 void map(IO &IO) override; 110 std::shared_ptr<DebugSubsection> 111 toCodeViewSubsection(BumpPtrAllocator &Allocator, 112 const codeview::StringsAndChecksums &SC) const override; 113 static Expected<std::shared_ptr<YAMLChecksumsSubsection>> 114 fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings, 115 const DebugChecksumsSubsectionRef &FC); 116 117 std::vector<SourceFileChecksumEntry> Checksums; 118 }; 119 120 struct YAMLLinesSubsection : public YAMLSubsectionBase { 121 YAMLLinesSubsection() : YAMLSubsectionBase(DebugSubsectionKind::Lines) {} 122 123 void map(IO &IO) override; 124 std::shared_ptr<DebugSubsection> 125 toCodeViewSubsection(BumpPtrAllocator &Allocator, 126 const codeview::StringsAndChecksums &SC) const override; 127 static Expected<std::shared_ptr<YAMLLinesSubsection>> 128 fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings, 129 const DebugChecksumsSubsectionRef &Checksums, 130 const DebugLinesSubsectionRef &Lines); 131 132 SourceLineInfo Lines; 133 }; 134 135 struct YAMLInlineeLinesSubsection : public YAMLSubsectionBase { 136 YAMLInlineeLinesSubsection() 137 : YAMLSubsectionBase(DebugSubsectionKind::InlineeLines) {} 138 139 void map(IO &IO) override; 140 std::shared_ptr<DebugSubsection> 141 toCodeViewSubsection(BumpPtrAllocator &Allocator, 142 const codeview::StringsAndChecksums &SC) const override; 143 static Expected<std::shared_ptr<YAMLInlineeLinesSubsection>> 144 fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings, 145 const DebugChecksumsSubsectionRef &Checksums, 146 const DebugInlineeLinesSubsectionRef &Lines); 147 148 InlineeInfo InlineeLines; 149 }; 150 151 struct YAMLCrossModuleExportsSubsection : public YAMLSubsectionBase { 152 YAMLCrossModuleExportsSubsection() 153 : YAMLSubsectionBase(DebugSubsectionKind::CrossScopeExports) {} 154 155 void map(IO &IO) override; 156 std::shared_ptr<DebugSubsection> 157 toCodeViewSubsection(BumpPtrAllocator &Allocator, 158 const codeview::StringsAndChecksums &SC) const override; 159 static Expected<std::shared_ptr<YAMLCrossModuleExportsSubsection>> 160 fromCodeViewSubsection(const DebugCrossModuleExportsSubsectionRef &Exports); 161 162 std::vector<CrossModuleExport> Exports; 163 }; 164 165 struct YAMLCrossModuleImportsSubsection : public YAMLSubsectionBase { 166 YAMLCrossModuleImportsSubsection() 167 : YAMLSubsectionBase(DebugSubsectionKind::CrossScopeImports) {} 168 169 void map(IO &IO) override; 170 std::shared_ptr<DebugSubsection> 171 toCodeViewSubsection(BumpPtrAllocator &Allocator, 172 const codeview::StringsAndChecksums &SC) const override; 173 static Expected<std::shared_ptr<YAMLCrossModuleImportsSubsection>> 174 fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings, 175 const DebugCrossModuleImportsSubsectionRef &Imports); 176 177 std::vector<YAMLCrossModuleImport> Imports; 178 }; 179 180 struct YAMLSymbolsSubsection : public YAMLSubsectionBase { 181 YAMLSymbolsSubsection() : YAMLSubsectionBase(DebugSubsectionKind::Symbols) {} 182 183 void map(IO &IO) override; 184 std::shared_ptr<DebugSubsection> 185 toCodeViewSubsection(BumpPtrAllocator &Allocator, 186 const codeview::StringsAndChecksums &SC) const override; 187 static Expected<std::shared_ptr<YAMLSymbolsSubsection>> 188 fromCodeViewSubsection(const DebugSymbolsSubsectionRef &Symbols); 189 190 std::vector<CodeViewYAML::SymbolRecord> Symbols; 191 }; 192 193 struct YAMLStringTableSubsection : public YAMLSubsectionBase { 194 YAMLStringTableSubsection() 195 : YAMLSubsectionBase(DebugSubsectionKind::StringTable) {} 196 197 void map(IO &IO) override; 198 std::shared_ptr<DebugSubsection> 199 toCodeViewSubsection(BumpPtrAllocator &Allocator, 200 const codeview::StringsAndChecksums &SC) const override; 201 static Expected<std::shared_ptr<YAMLStringTableSubsection>> 202 fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings); 203 204 std::vector<StringRef> Strings; 205 }; 206 207 struct YAMLFrameDataSubsection : public YAMLSubsectionBase { 208 YAMLFrameDataSubsection() 209 : YAMLSubsectionBase(DebugSubsectionKind::FrameData) {} 210 211 void map(IO &IO) override; 212 std::shared_ptr<DebugSubsection> 213 toCodeViewSubsection(BumpPtrAllocator &Allocator, 214 const codeview::StringsAndChecksums &SC) const override; 215 static Expected<std::shared_ptr<YAMLFrameDataSubsection>> 216 fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings, 217 const DebugFrameDataSubsectionRef &Frames); 218 219 std::vector<YAMLFrameData> Frames; 220 }; 221 222 struct YAMLCoffSymbolRVASubsection : public YAMLSubsectionBase { 223 YAMLCoffSymbolRVASubsection() 224 : YAMLSubsectionBase(DebugSubsectionKind::CoffSymbolRVA) {} 225 226 void map(IO &IO) override; 227 std::shared_ptr<DebugSubsection> 228 toCodeViewSubsection(BumpPtrAllocator &Allocator, 229 const codeview::StringsAndChecksums &SC) const override; 230 static Expected<std::shared_ptr<YAMLCoffSymbolRVASubsection>> 231 fromCodeViewSubsection(const DebugSymbolRVASubsectionRef &RVAs); 232 233 std::vector<uint32_t> RVAs; 234 }; 235 236 } // end anonymous namespace 237 238 void ScalarBitSetTraits<LineFlags>::bitset(IO &io, LineFlags &Flags) { 239 io.bitSetCase(Flags, "HasColumnInfo", LF_HaveColumns); 240 io.enumFallback<Hex16>(Flags); 241 } 242 243 void ScalarEnumerationTraits<FileChecksumKind>::enumeration( 244 IO &io, FileChecksumKind &Kind) { 245 io.enumCase(Kind, "None", FileChecksumKind::None); 246 io.enumCase(Kind, "MD5", FileChecksumKind::MD5); 247 io.enumCase(Kind, "SHA1", FileChecksumKind::SHA1); 248 io.enumCase(Kind, "SHA256", FileChecksumKind::SHA256); 249 } 250 251 void ScalarTraits<HexFormattedString>::output(const HexFormattedString &Value, 252 void *ctx, raw_ostream &Out) { 253 StringRef Bytes(reinterpret_cast<const char *>(Value.Bytes.data()), 254 Value.Bytes.size()); 255 Out << toHex(Bytes); 256 } 257 258 StringRef ScalarTraits<HexFormattedString>::input(StringRef Scalar, void *ctxt, 259 HexFormattedString &Value) { 260 std::string H = fromHex(Scalar); 261 Value.Bytes.assign(H.begin(), H.end()); 262 return StringRef(); 263 } 264 265 void MappingTraits<SourceLineEntry>::mapping(IO &IO, SourceLineEntry &Obj) { 266 IO.mapRequired("Offset", Obj.Offset); 267 IO.mapRequired("LineStart", Obj.LineStart); 268 IO.mapRequired("IsStatement", Obj.IsStatement); 269 IO.mapRequired("EndDelta", Obj.EndDelta); 270 } 271 272 void MappingTraits<SourceColumnEntry>::mapping(IO &IO, SourceColumnEntry &Obj) { 273 IO.mapRequired("StartColumn", Obj.StartColumn); 274 IO.mapRequired("EndColumn", Obj.EndColumn); 275 } 276 277 void MappingTraits<SourceLineBlock>::mapping(IO &IO, SourceLineBlock &Obj) { 278 IO.mapRequired("FileName", Obj.FileName); 279 IO.mapRequired("Lines", Obj.Lines); 280 IO.mapRequired("Columns", Obj.Columns); 281 } 282 283 void MappingTraits<CrossModuleExport>::mapping(IO &IO, CrossModuleExport &Obj) { 284 IO.mapRequired("LocalId", Obj.Local); 285 IO.mapRequired("GlobalId", Obj.Global); 286 } 287 288 void MappingTraits<YAMLCrossModuleImport>::mapping(IO &IO, 289 YAMLCrossModuleImport &Obj) { 290 IO.mapRequired("Module", Obj.ModuleName); 291 IO.mapRequired("Imports", Obj.ImportIds); 292 } 293 294 void MappingTraits<SourceFileChecksumEntry>::mapping( 295 IO &IO, SourceFileChecksumEntry &Obj) { 296 IO.mapRequired("FileName", Obj.FileName); 297 IO.mapRequired("Kind", Obj.Kind); 298 IO.mapRequired("Checksum", Obj.ChecksumBytes); 299 } 300 301 void MappingTraits<InlineeSite>::mapping(IO &IO, InlineeSite &Obj) { 302 IO.mapRequired("FileName", Obj.FileName); 303 IO.mapRequired("LineNum", Obj.SourceLineNum); 304 IO.mapRequired("Inlinee", Obj.Inlinee); 305 IO.mapOptional("ExtraFiles", Obj.ExtraFiles); 306 } 307 308 void MappingTraits<YAMLFrameData>::mapping(IO &IO, YAMLFrameData &Obj) { 309 IO.mapRequired("CodeSize", Obj.CodeSize); 310 IO.mapRequired("FrameFunc", Obj.FrameFunc); 311 IO.mapRequired("LocalSize", Obj.LocalSize); 312 IO.mapOptional("MaxStackSize", Obj.MaxStackSize); 313 IO.mapOptional("ParamsSize", Obj.ParamsSize); 314 IO.mapOptional("PrologSize", Obj.PrologSize); 315 IO.mapOptional("RvaStart", Obj.RvaStart); 316 IO.mapOptional("SavedRegsSize", Obj.SavedRegsSize); 317 } 318 319 void YAMLChecksumsSubsection::map(IO &IO) { 320 IO.mapTag("!FileChecksums", true); 321 IO.mapRequired("Checksums", Checksums); 322 } 323 324 void YAMLLinesSubsection::map(IO &IO) { 325 IO.mapTag("!Lines", true); 326 IO.mapRequired("CodeSize", Lines.CodeSize); 327 328 IO.mapRequired("Flags", Lines.Flags); 329 IO.mapRequired("RelocOffset", Lines.RelocOffset); 330 IO.mapRequired("RelocSegment", Lines.RelocSegment); 331 IO.mapRequired("Blocks", Lines.Blocks); 332 } 333 334 void YAMLInlineeLinesSubsection::map(IO &IO) { 335 IO.mapTag("!InlineeLines", true); 336 IO.mapRequired("HasExtraFiles", InlineeLines.HasExtraFiles); 337 IO.mapRequired("Sites", InlineeLines.Sites); 338 } 339 340 void YAMLCrossModuleExportsSubsection::map(IO &IO) { 341 IO.mapTag("!CrossModuleExports", true); 342 IO.mapOptional("Exports", Exports); 343 } 344 345 void YAMLCrossModuleImportsSubsection::map(IO &IO) { 346 IO.mapTag("!CrossModuleImports", true); 347 IO.mapOptional("Imports", Imports); 348 } 349 350 void YAMLSymbolsSubsection::map(IO &IO) { 351 IO.mapTag("!Symbols", true); 352 IO.mapRequired("Records", Symbols); 353 } 354 355 void YAMLStringTableSubsection::map(IO &IO) { 356 IO.mapTag("!StringTable", true); 357 IO.mapRequired("Strings", Strings); 358 } 359 360 void YAMLFrameDataSubsection::map(IO &IO) { 361 IO.mapTag("!FrameData", true); 362 IO.mapRequired("Frames", Frames); 363 } 364 365 void YAMLCoffSymbolRVASubsection::map(IO &IO) { 366 IO.mapTag("!COFFSymbolRVAs", true); 367 IO.mapRequired("RVAs", RVAs); 368 } 369 370 void MappingTraits<YAMLDebugSubsection>::mapping( 371 IO &IO, YAMLDebugSubsection &Subsection) { 372 if (!IO.outputting()) { 373 if (IO.mapTag("!FileChecksums")) { 374 auto SS = std::make_shared<YAMLChecksumsSubsection>(); 375 Subsection.Subsection = SS; 376 } else if (IO.mapTag("!Lines")) { 377 Subsection.Subsection = std::make_shared<YAMLLinesSubsection>(); 378 } else if (IO.mapTag("!InlineeLines")) { 379 Subsection.Subsection = std::make_shared<YAMLInlineeLinesSubsection>(); 380 } else if (IO.mapTag("!CrossModuleExports")) { 381 Subsection.Subsection = 382 std::make_shared<YAMLCrossModuleExportsSubsection>(); 383 } else if (IO.mapTag("!CrossModuleImports")) { 384 Subsection.Subsection = 385 std::make_shared<YAMLCrossModuleImportsSubsection>(); 386 } else if (IO.mapTag("!Symbols")) { 387 Subsection.Subsection = std::make_shared<YAMLSymbolsSubsection>(); 388 } else if (IO.mapTag("!StringTable")) { 389 Subsection.Subsection = std::make_shared<YAMLStringTableSubsection>(); 390 } else if (IO.mapTag("!FrameData")) { 391 Subsection.Subsection = std::make_shared<YAMLFrameDataSubsection>(); 392 } else if (IO.mapTag("!COFFSymbolRVAs")) { 393 Subsection.Subsection = std::make_shared<YAMLCoffSymbolRVASubsection>(); 394 } else { 395 llvm_unreachable("Unexpected subsection tag!"); 396 } 397 } 398 Subsection.Subsection->map(IO); 399 } 400 401 std::shared_ptr<DebugSubsection> YAMLChecksumsSubsection::toCodeViewSubsection( 402 BumpPtrAllocator &Allocator, 403 const codeview::StringsAndChecksums &SC) const { 404 assert(SC.hasStrings()); 405 auto Result = std::make_shared<DebugChecksumsSubsection>(*SC.strings()); 406 for (const auto &CS : Checksums) { 407 Result->addChecksum(CS.FileName, CS.Kind, CS.ChecksumBytes.Bytes); 408 } 409 return Result; 410 } 411 412 std::shared_ptr<DebugSubsection> YAMLLinesSubsection::toCodeViewSubsection( 413 BumpPtrAllocator &Allocator, 414 const codeview::StringsAndChecksums &SC) const { 415 assert(SC.hasStrings() && SC.hasChecksums()); 416 auto Result = 417 std::make_shared<DebugLinesSubsection>(*SC.checksums(), *SC.strings()); 418 Result->setCodeSize(Lines.CodeSize); 419 Result->setRelocationAddress(Lines.RelocSegment, Lines.RelocOffset); 420 Result->setFlags(Lines.Flags); 421 for (const auto &LC : Lines.Blocks) { 422 Result->createBlock(LC.FileName); 423 if (Result->hasColumnInfo()) { 424 for (auto Item : zip(LC.Lines, LC.Columns)) { 425 auto &L = std::get<0>(Item); 426 auto &C = std::get<1>(Item); 427 uint32_t LE = L.LineStart + L.EndDelta; 428 Result->addLineAndColumnInfo(L.Offset, 429 LineInfo(L.LineStart, LE, L.IsStatement), 430 C.StartColumn, C.EndColumn); 431 } 432 } else { 433 for (const auto &L : LC.Lines) { 434 uint32_t LE = L.LineStart + L.EndDelta; 435 Result->addLineInfo(L.Offset, LineInfo(L.LineStart, LE, L.IsStatement)); 436 } 437 } 438 } 439 return Result; 440 } 441 442 std::shared_ptr<DebugSubsection> 443 YAMLInlineeLinesSubsection::toCodeViewSubsection( 444 BumpPtrAllocator &Allocator, 445 const codeview::StringsAndChecksums &SC) const { 446 assert(SC.hasChecksums()); 447 auto Result = std::make_shared<DebugInlineeLinesSubsection>( 448 *SC.checksums(), InlineeLines.HasExtraFiles); 449 450 for (const auto &Site : InlineeLines.Sites) { 451 Result->addInlineSite(TypeIndex(Site.Inlinee), Site.FileName, 452 Site.SourceLineNum); 453 if (!InlineeLines.HasExtraFiles) 454 continue; 455 456 for (auto EF : Site.ExtraFiles) { 457 Result->addExtraFile(EF); 458 } 459 } 460 return Result; 461 } 462 463 std::shared_ptr<DebugSubsection> 464 YAMLCrossModuleExportsSubsection::toCodeViewSubsection( 465 BumpPtrAllocator &Allocator, 466 const codeview::StringsAndChecksums &SC) const { 467 auto Result = std::make_shared<DebugCrossModuleExportsSubsection>(); 468 for (const auto &M : Exports) 469 Result->addMapping(M.Local, M.Global); 470 return Result; 471 } 472 473 std::shared_ptr<DebugSubsection> 474 YAMLCrossModuleImportsSubsection::toCodeViewSubsection( 475 BumpPtrAllocator &Allocator, 476 const codeview::StringsAndChecksums &SC) const { 477 assert(SC.hasStrings()); 478 479 auto Result = 480 std::make_shared<DebugCrossModuleImportsSubsection>(*SC.strings()); 481 for (const auto &M : Imports) { 482 for (const auto Id : M.ImportIds) 483 Result->addImport(M.ModuleName, Id); 484 } 485 return Result; 486 } 487 488 std::shared_ptr<DebugSubsection> YAMLSymbolsSubsection::toCodeViewSubsection( 489 BumpPtrAllocator &Allocator, 490 const codeview::StringsAndChecksums &SC) const { 491 auto Result = std::make_shared<DebugSymbolsSubsection>(); 492 for (const auto &Sym : Symbols) 493 Result->addSymbol( 494 Sym.toCodeViewSymbol(Allocator, CodeViewContainer::ObjectFile)); 495 return Result; 496 } 497 498 std::shared_ptr<DebugSubsection> 499 YAMLStringTableSubsection::toCodeViewSubsection( 500 BumpPtrAllocator &Allocator, 501 const codeview::StringsAndChecksums &SC) const { 502 auto Result = std::make_shared<DebugStringTableSubsection>(); 503 for (const auto &Str : this->Strings) 504 Result->insert(Str); 505 return Result; 506 } 507 508 std::shared_ptr<DebugSubsection> YAMLFrameDataSubsection::toCodeViewSubsection( 509 BumpPtrAllocator &Allocator, 510 const codeview::StringsAndChecksums &SC) const { 511 assert(SC.hasStrings()); 512 513 auto Result = std::make_shared<DebugFrameDataSubsection>(true); 514 for (const auto &YF : Frames) { 515 codeview::FrameData F; 516 F.CodeSize = YF.CodeSize; 517 F.Flags = YF.Flags; 518 F.LocalSize = YF.LocalSize; 519 F.MaxStackSize = YF.MaxStackSize; 520 F.ParamsSize = YF.ParamsSize; 521 F.PrologSize = YF.PrologSize; 522 F.RvaStart = YF.RvaStart; 523 F.SavedRegsSize = YF.SavedRegsSize; 524 F.FrameFunc = SC.strings()->insert(YF.FrameFunc); 525 Result->addFrameData(F); 526 } 527 return Result; 528 } 529 530 std::shared_ptr<DebugSubsection> 531 YAMLCoffSymbolRVASubsection::toCodeViewSubsection( 532 BumpPtrAllocator &Allocator, 533 const codeview::StringsAndChecksums &SC) const { 534 auto Result = std::make_shared<DebugSymbolRVASubsection>(); 535 for (const auto &RVA : RVAs) 536 Result->addRVA(RVA); 537 return Result; 538 } 539 540 static Expected<SourceFileChecksumEntry> 541 convertOneChecksum(const DebugStringTableSubsectionRef &Strings, 542 const FileChecksumEntry &CS) { 543 auto ExpectedString = Strings.getString(CS.FileNameOffset); 544 if (!ExpectedString) 545 return ExpectedString.takeError(); 546 547 SourceFileChecksumEntry Result; 548 Result.ChecksumBytes.Bytes = CS.Checksum; 549 Result.Kind = CS.Kind; 550 Result.FileName = *ExpectedString; 551 return Result; 552 } 553 554 static Expected<StringRef> 555 getFileName(const DebugStringTableSubsectionRef &Strings, 556 const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID) { 557 auto Iter = Checksums.getArray().at(FileID); 558 if (Iter == Checksums.getArray().end()) 559 return make_error<CodeViewError>(cv_error_code::no_records); 560 uint32_t Offset = Iter->FileNameOffset; 561 return Strings.getString(Offset); 562 } 563 564 Expected<std::shared_ptr<YAMLChecksumsSubsection>> 565 YAMLChecksumsSubsection::fromCodeViewSubsection( 566 const DebugStringTableSubsectionRef &Strings, 567 const DebugChecksumsSubsectionRef &FC) { 568 auto Result = std::make_shared<YAMLChecksumsSubsection>(); 569 570 for (const auto &CS : FC) { 571 auto ConvertedCS = convertOneChecksum(Strings, CS); 572 if (!ConvertedCS) 573 return ConvertedCS.takeError(); 574 Result->Checksums.push_back(*ConvertedCS); 575 } 576 return Result; 577 } 578 579 Expected<std::shared_ptr<YAMLLinesSubsection>> 580 YAMLLinesSubsection::fromCodeViewSubsection( 581 const DebugStringTableSubsectionRef &Strings, 582 const DebugChecksumsSubsectionRef &Checksums, 583 const DebugLinesSubsectionRef &Lines) { 584 auto Result = std::make_shared<YAMLLinesSubsection>(); 585 Result->Lines.CodeSize = Lines.header()->CodeSize; 586 Result->Lines.RelocOffset = Lines.header()->RelocOffset; 587 Result->Lines.RelocSegment = Lines.header()->RelocSegment; 588 Result->Lines.Flags = static_cast<LineFlags>(uint16_t(Lines.header()->Flags)); 589 for (const auto &L : Lines) { 590 SourceLineBlock Block; 591 auto EF = getFileName(Strings, Checksums, L.NameIndex); 592 if (!EF) 593 return EF.takeError(); 594 Block.FileName = *EF; 595 if (Lines.hasColumnInfo()) { 596 for (const auto &C : L.Columns) { 597 SourceColumnEntry SCE; 598 SCE.EndColumn = C.EndColumn; 599 SCE.StartColumn = C.StartColumn; 600 Block.Columns.push_back(SCE); 601 } 602 } 603 for (const auto &LN : L.LineNumbers) { 604 SourceLineEntry SLE; 605 LineInfo LI(LN.Flags); 606 SLE.Offset = LN.Offset; 607 SLE.LineStart = LI.getStartLine(); 608 SLE.EndDelta = LI.getLineDelta(); 609 SLE.IsStatement = LI.isStatement(); 610 Block.Lines.push_back(SLE); 611 } 612 Result->Lines.Blocks.push_back(Block); 613 } 614 return Result; 615 } 616 617 Expected<std::shared_ptr<YAMLInlineeLinesSubsection>> 618 YAMLInlineeLinesSubsection::fromCodeViewSubsection( 619 const DebugStringTableSubsectionRef &Strings, 620 const DebugChecksumsSubsectionRef &Checksums, 621 const DebugInlineeLinesSubsectionRef &Lines) { 622 auto Result = std::make_shared<YAMLInlineeLinesSubsection>(); 623 624 Result->InlineeLines.HasExtraFiles = Lines.hasExtraFiles(); 625 for (const auto &IL : Lines) { 626 InlineeSite Site; 627 auto ExpF = getFileName(Strings, Checksums, IL.Header->FileID); 628 if (!ExpF) 629 return ExpF.takeError(); 630 Site.FileName = *ExpF; 631 Site.Inlinee = IL.Header->Inlinee.getIndex(); 632 Site.SourceLineNum = IL.Header->SourceLineNum; 633 if (Lines.hasExtraFiles()) { 634 for (const auto EF : IL.ExtraFiles) { 635 auto ExpF2 = getFileName(Strings, Checksums, EF); 636 if (!ExpF2) 637 return ExpF2.takeError(); 638 Site.ExtraFiles.push_back(*ExpF2); 639 } 640 } 641 Result->InlineeLines.Sites.push_back(Site); 642 } 643 return Result; 644 } 645 646 Expected<std::shared_ptr<YAMLCrossModuleExportsSubsection>> 647 YAMLCrossModuleExportsSubsection::fromCodeViewSubsection( 648 const DebugCrossModuleExportsSubsectionRef &Exports) { 649 auto Result = std::make_shared<YAMLCrossModuleExportsSubsection>(); 650 Result->Exports.assign(Exports.begin(), Exports.end()); 651 return Result; 652 } 653 654 Expected<std::shared_ptr<YAMLCrossModuleImportsSubsection>> 655 YAMLCrossModuleImportsSubsection::fromCodeViewSubsection( 656 const DebugStringTableSubsectionRef &Strings, 657 const DebugCrossModuleImportsSubsectionRef &Imports) { 658 auto Result = std::make_shared<YAMLCrossModuleImportsSubsection>(); 659 for (const auto &CMI : Imports) { 660 YAMLCrossModuleImport YCMI; 661 auto ExpectedStr = Strings.getString(CMI.Header->ModuleNameOffset); 662 if (!ExpectedStr) 663 return ExpectedStr.takeError(); 664 YCMI.ModuleName = *ExpectedStr; 665 YCMI.ImportIds.assign(CMI.Imports.begin(), CMI.Imports.end()); 666 Result->Imports.push_back(YCMI); 667 } 668 return Result; 669 } 670 671 Expected<std::shared_ptr<YAMLSymbolsSubsection>> 672 YAMLSymbolsSubsection::fromCodeViewSubsection( 673 const DebugSymbolsSubsectionRef &Symbols) { 674 auto Result = std::make_shared<YAMLSymbolsSubsection>(); 675 for (const auto &Sym : Symbols) { 676 auto S = CodeViewYAML::SymbolRecord::fromCodeViewSymbol(Sym); 677 if (!S) 678 return joinErrors(make_error<CodeViewError>( 679 cv_error_code::corrupt_record, 680 "Invalid CodeView Symbol Record in SymbolRecord " 681 "subsection of .debug$S while converting to YAML!"), 682 S.takeError()); 683 684 Result->Symbols.push_back(*S); 685 } 686 return Result; 687 } 688 689 Expected<std::shared_ptr<YAMLStringTableSubsection>> 690 YAMLStringTableSubsection::fromCodeViewSubsection( 691 const DebugStringTableSubsectionRef &Strings) { 692 auto Result = std::make_shared<YAMLStringTableSubsection>(); 693 BinaryStreamReader Reader(Strings.getBuffer()); 694 StringRef S; 695 // First item is a single null string, skip it. 696 if (auto EC = Reader.readCString(S)) 697 return std::move(EC); 698 assert(S.empty()); 699 while (Reader.bytesRemaining() > 0) { 700 if (auto EC = Reader.readCString(S)) 701 return std::move(EC); 702 Result->Strings.push_back(S); 703 } 704 return Result; 705 } 706 707 Expected<std::shared_ptr<YAMLFrameDataSubsection>> 708 YAMLFrameDataSubsection::fromCodeViewSubsection( 709 const DebugStringTableSubsectionRef &Strings, 710 const DebugFrameDataSubsectionRef &Frames) { 711 auto Result = std::make_shared<YAMLFrameDataSubsection>(); 712 for (const auto &F : Frames) { 713 YAMLFrameData YF; 714 YF.CodeSize = F.CodeSize; 715 YF.Flags = F.Flags; 716 YF.LocalSize = F.LocalSize; 717 YF.MaxStackSize = F.MaxStackSize; 718 YF.ParamsSize = F.ParamsSize; 719 YF.PrologSize = F.PrologSize; 720 YF.RvaStart = F.RvaStart; 721 YF.SavedRegsSize = F.SavedRegsSize; 722 723 auto ES = Strings.getString(F.FrameFunc); 724 if (!ES) 725 return joinErrors( 726 make_error<CodeViewError>( 727 cv_error_code::no_records, 728 "Could not find string for string id while mapping FrameData!"), 729 ES.takeError()); 730 YF.FrameFunc = *ES; 731 Result->Frames.push_back(YF); 732 } 733 return Result; 734 } 735 736 Expected<std::shared_ptr<YAMLCoffSymbolRVASubsection>> 737 YAMLCoffSymbolRVASubsection::fromCodeViewSubsection( 738 const DebugSymbolRVASubsectionRef &Section) { 739 auto Result = std::make_shared<YAMLCoffSymbolRVASubsection>(); 740 for (const auto &RVA : Section) { 741 Result->RVAs.push_back(RVA); 742 } 743 return Result; 744 } 745 746 Expected<std::vector<std::shared_ptr<DebugSubsection>>> 747 llvm::CodeViewYAML::toCodeViewSubsectionList( 748 BumpPtrAllocator &Allocator, ArrayRef<YAMLDebugSubsection> Subsections, 749 const codeview::StringsAndChecksums &SC) { 750 std::vector<std::shared_ptr<DebugSubsection>> Result; 751 if (Subsections.empty()) 752 return std::move(Result); 753 754 for (const auto &SS : Subsections) { 755 std::shared_ptr<DebugSubsection> CVS; 756 CVS = SS.Subsection->toCodeViewSubsection(Allocator, SC); 757 assert(CVS != nullptr); 758 Result.push_back(std::move(CVS)); 759 } 760 return std::move(Result); 761 } 762 763 namespace { 764 765 struct SubsectionConversionVisitor : public DebugSubsectionVisitor { 766 SubsectionConversionVisitor() = default; 767 768 Error visitUnknown(DebugUnknownSubsectionRef &Unknown) override; 769 Error visitLines(DebugLinesSubsectionRef &Lines, 770 const StringsAndChecksumsRef &State) override; 771 Error visitFileChecksums(DebugChecksumsSubsectionRef &Checksums, 772 const StringsAndChecksumsRef &State) override; 773 Error visitInlineeLines(DebugInlineeLinesSubsectionRef &Inlinees, 774 const StringsAndChecksumsRef &State) override; 775 Error visitCrossModuleExports(DebugCrossModuleExportsSubsectionRef &Checksums, 776 const StringsAndChecksumsRef &State) override; 777 Error visitCrossModuleImports(DebugCrossModuleImportsSubsectionRef &Inlinees, 778 const StringsAndChecksumsRef &State) override; 779 Error visitStringTable(DebugStringTableSubsectionRef &ST, 780 const StringsAndChecksumsRef &State) override; 781 Error visitSymbols(DebugSymbolsSubsectionRef &Symbols, 782 const StringsAndChecksumsRef &State) override; 783 Error visitFrameData(DebugFrameDataSubsectionRef &Symbols, 784 const StringsAndChecksumsRef &State) override; 785 Error visitCOFFSymbolRVAs(DebugSymbolRVASubsectionRef &Symbols, 786 const StringsAndChecksumsRef &State) override; 787 788 YAMLDebugSubsection Subsection; 789 }; 790 791 } // end anonymous namespace 792 793 Error SubsectionConversionVisitor::visitUnknown( 794 DebugUnknownSubsectionRef &Unknown) { 795 return make_error<CodeViewError>(cv_error_code::operation_unsupported); 796 } 797 798 Error SubsectionConversionVisitor::visitLines( 799 DebugLinesSubsectionRef &Lines, const StringsAndChecksumsRef &State) { 800 auto Result = YAMLLinesSubsection::fromCodeViewSubsection( 801 State.strings(), State.checksums(), Lines); 802 if (!Result) 803 return Result.takeError(); 804 Subsection.Subsection = *Result; 805 return Error::success(); 806 } 807 808 Error SubsectionConversionVisitor::visitFileChecksums( 809 DebugChecksumsSubsectionRef &Checksums, 810 const StringsAndChecksumsRef &State) { 811 auto Result = YAMLChecksumsSubsection::fromCodeViewSubsection(State.strings(), 812 Checksums); 813 if (!Result) 814 return Result.takeError(); 815 Subsection.Subsection = *Result; 816 return Error::success(); 817 } 818 819 Error SubsectionConversionVisitor::visitInlineeLines( 820 DebugInlineeLinesSubsectionRef &Inlinees, 821 const StringsAndChecksumsRef &State) { 822 auto Result = YAMLInlineeLinesSubsection::fromCodeViewSubsection( 823 State.strings(), State.checksums(), Inlinees); 824 if (!Result) 825 return Result.takeError(); 826 Subsection.Subsection = *Result; 827 return Error::success(); 828 } 829 830 Error SubsectionConversionVisitor::visitCrossModuleExports( 831 DebugCrossModuleExportsSubsectionRef &Exports, 832 const StringsAndChecksumsRef &State) { 833 auto Result = 834 YAMLCrossModuleExportsSubsection::fromCodeViewSubsection(Exports); 835 if (!Result) 836 return Result.takeError(); 837 Subsection.Subsection = *Result; 838 return Error::success(); 839 } 840 841 Error SubsectionConversionVisitor::visitCrossModuleImports( 842 DebugCrossModuleImportsSubsectionRef &Imports, 843 const StringsAndChecksumsRef &State) { 844 auto Result = YAMLCrossModuleImportsSubsection::fromCodeViewSubsection( 845 State.strings(), Imports); 846 if (!Result) 847 return Result.takeError(); 848 Subsection.Subsection = *Result; 849 return Error::success(); 850 } 851 852 Error SubsectionConversionVisitor::visitStringTable( 853 DebugStringTableSubsectionRef &Strings, 854 const StringsAndChecksumsRef &State) { 855 auto Result = YAMLStringTableSubsection::fromCodeViewSubsection(Strings); 856 if (!Result) 857 return Result.takeError(); 858 Subsection.Subsection = *Result; 859 return Error::success(); 860 } 861 862 Error SubsectionConversionVisitor::visitSymbols( 863 DebugSymbolsSubsectionRef &Symbols, const StringsAndChecksumsRef &State) { 864 auto Result = YAMLSymbolsSubsection::fromCodeViewSubsection(Symbols); 865 if (!Result) 866 return Result.takeError(); 867 Subsection.Subsection = *Result; 868 return Error::success(); 869 } 870 871 Error SubsectionConversionVisitor::visitFrameData( 872 DebugFrameDataSubsectionRef &Frames, const StringsAndChecksumsRef &State) { 873 auto Result = 874 YAMLFrameDataSubsection::fromCodeViewSubsection(State.strings(), Frames); 875 if (!Result) 876 return Result.takeError(); 877 Subsection.Subsection = *Result; 878 return Error::success(); 879 } 880 881 Error SubsectionConversionVisitor::visitCOFFSymbolRVAs( 882 DebugSymbolRVASubsectionRef &RVAs, const StringsAndChecksumsRef &State) { 883 auto Result = YAMLCoffSymbolRVASubsection::fromCodeViewSubsection(RVAs); 884 if (!Result) 885 return Result.takeError(); 886 Subsection.Subsection = *Result; 887 return Error::success(); 888 } 889 890 Expected<YAMLDebugSubsection> 891 YAMLDebugSubsection::fromCodeViewSubection(const StringsAndChecksumsRef &SC, 892 const DebugSubsectionRecord &SS) { 893 SubsectionConversionVisitor V; 894 if (auto EC = visitDebugSubsection(SS, V, SC)) 895 return std::move(EC); 896 897 return V.Subsection; 898 } 899 900 std::vector<YAMLDebugSubsection> 901 llvm::CodeViewYAML::fromDebugS(ArrayRef<uint8_t> Data, 902 const StringsAndChecksumsRef &SC) { 903 BinaryStreamReader Reader(Data, support::little); 904 uint32_t Magic; 905 906 ExitOnError Err("Invalid .debug$S section!"); 907 Err(Reader.readInteger(Magic)); 908 assert(Magic == COFF::DEBUG_SECTION_MAGIC && "Invalid .debug$S section!"); 909 910 DebugSubsectionArray Subsections; 911 Err(Reader.readArray(Subsections, Reader.bytesRemaining())); 912 913 std::vector<YAMLDebugSubsection> Result; 914 915 for (const auto &SS : Subsections) { 916 auto YamlSS = Err(YAMLDebugSubsection::fromCodeViewSubection(SC, SS)); 917 Result.push_back(YamlSS); 918 } 919 return Result; 920 } 921 922 void llvm::CodeViewYAML::initializeStringsAndChecksums( 923 ArrayRef<YAMLDebugSubsection> Sections, codeview::StringsAndChecksums &SC) { 924 // String Table and Checksums subsections don't use the allocator. 925 BumpPtrAllocator Allocator; 926 927 // It's possible for checksums and strings to even appear in different debug$S 928 // sections, so we have to make this a stateful function that can build up 929 // the strings and checksums field over multiple iterations. 930 931 // File Checksums require the string table, but may become before it, so we 932 // have to scan for strings first, then scan for checksums again from the 933 // beginning. 934 if (!SC.hasStrings()) { 935 for (const auto &SS : Sections) { 936 if (SS.Subsection->Kind != DebugSubsectionKind::StringTable) 937 continue; 938 939 auto Result = SS.Subsection->toCodeViewSubsection(Allocator, SC); 940 SC.setStrings( 941 std::static_pointer_cast<DebugStringTableSubsection>(Result)); 942 break; 943 } 944 } 945 946 if (SC.hasStrings() && !SC.hasChecksums()) { 947 for (const auto &SS : Sections) { 948 if (SS.Subsection->Kind != DebugSubsectionKind::FileChecksums) 949 continue; 950 951 auto Result = SS.Subsection->toCodeViewSubsection(Allocator, SC); 952 SC.setChecksums( 953 std::static_pointer_cast<DebugChecksumsSubsection>(Result)); 954 break; 955 } 956 } 957 } 958
Indexes created Mon Jun 08 00:24:58 UTC 2026