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