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