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 {
89   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 {
107   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 {
122   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 {
137   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 {
153   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 {
167   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 {
182   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 {
195   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 {
209   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 {
224   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 
239 void ScalarBitSetTraits<LineFlags>::bitset(IO &io, LineFlags &Flags) {
240   io.bitSetCase(Flags, "HasColumnInfo", LF_HaveColumns);
241   io.enumFallback<Hex16>(Flags);
242 }
243 
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 
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 
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 
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 
273 void MappingTraits<SourceColumnEntry>::mapping(IO &IO, SourceColumnEntry &Obj) {
274   IO.mapRequired("StartColumn", Obj.StartColumn);
275   IO.mapRequired("EndColumn", Obj.EndColumn);
276 }
277 
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 
284 void MappingTraits<CrossModuleExport>::mapping(IO &IO, CrossModuleExport &Obj) {
285   IO.mapRequired("LocalId", Obj.Local);
286   IO.mapRequired("GlobalId", Obj.Global);
287 }
288 
289 void MappingTraits<YAMLCrossModuleImport>::mapping(IO &IO,
290                                                    YAMLCrossModuleImport &Obj) {
291   IO.mapRequired("Module", Obj.ModuleName);
292   IO.mapRequired("Imports", Obj.ImportIds);
293 }
294 
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 
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 
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 
320 void YAMLChecksumsSubsection::map(IO &IO) {
321   IO.mapTag("!FileChecksums", true);
322   IO.mapRequired("Checksums", Checksums);
323 }
324 
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 
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 
341 void YAMLCrossModuleExportsSubsection::map(IO &IO) {
342   IO.mapTag("!CrossModuleExports", true);
343   IO.mapOptional("Exports", Exports);
344 }
345 
346 void YAMLCrossModuleImportsSubsection::map(IO &IO) {
347   IO.mapTag("!CrossModuleImports", true);
348   IO.mapOptional("Imports", Imports);
349 }
350 
351 void YAMLSymbolsSubsection::map(IO &IO) {
352   IO.mapTag("!Symbols", true);
353   IO.mapRequired("Records", Symbols);
354 }
355 
356 void YAMLStringTableSubsection::map(IO &IO) {
357   IO.mapTag("!StringTable", true);
358   IO.mapRequired("Strings", Strings);
359 }
360 
361 void YAMLFrameDataSubsection::map(IO &IO) {
362   IO.mapTag("!FrameData", true);
363   IO.mapRequired("Frames", Frames);
364 }
365 
366 void YAMLCoffSymbolRVASubsection::map(IO &IO) {
367   IO.mapTag("!COFFSymbolRVAs", true);
368   IO.mapRequired("RVAs", RVAs);
369 }
370 
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 
402 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 
413 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>
444 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>
465 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>
475 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 
489 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>
500 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 
509 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>
532 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>
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>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>
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>>>
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 
794 Error SubsectionConversionVisitor::visitUnknown(
795     DebugUnknownSubsectionRef &Unknown) {
796   return make_error<CodeViewError>(cv_error_code::operation_unsupported);
797 }
798 
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 
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 
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 
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 
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 
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 
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 
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 
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>
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>
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 
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