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 
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
20 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
21 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
22 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
23 #include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
24 #include "llvm/DebugInfo/CodeView/DebugSubsectionVisitor.h"
25 #include "llvm/DebugInfo/CodeView/EnumTables.h"
26 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
27 
28 using namespace llvm;
29 using namespace llvm::codeview;
30 using namespace llvm::CodeViewYAML;
31 using namespace llvm::CodeViewYAML::detail;
32 using namespace llvm::yaml;
33 
34 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceFileChecksumEntry)
35 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineEntry)
36 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceColumnEntry)
37 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineBlock)
38 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineInfo)
39 LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeSite)
40 LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeInfo)
41 LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
42 
43 LLVM_YAML_DECLARE_SCALAR_TRAITS(HexFormattedString, false)
44 LLVM_YAML_DECLARE_ENUM_TRAITS(DebugSubsectionKind)
45 LLVM_YAML_DECLARE_ENUM_TRAITS(FileChecksumKind)
46 LLVM_YAML_DECLARE_BITSET_TRAITS(LineFlags)
47 
48 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceLineEntry)
49 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceColumnEntry)
50 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceFileChecksumEntry)
51 LLVM_YAML_DECLARE_MAPPING_TRAITS(SourceLineBlock)
52 LLVM_YAML_DECLARE_MAPPING_TRAITS(InlineeSite)
53 
54 namespace llvm {
55 namespace CodeViewYAML {
56 namespace detail {
57 struct YAMLSubsectionBase {
58   explicit YAMLSubsectionBase(DebugSubsectionKind Kind) : Kind(Kind) {}
59   DebugSubsectionKind Kind;
60   virtual ~YAMLSubsectionBase() {}
61 
62   virtual void map(IO &IO) = 0;
63   virtual std::unique_ptr<DebugSubsection>
64   toCodeViewSubsection(DebugStringTableSubsection *UseStrings,
65                        DebugChecksumsSubsection *UseChecksums) const = 0;
66 };
67 }
68 }
69 }
70 
71 namespace {
72 struct YAMLChecksumsSubsection : public YAMLSubsectionBase {
73   YAMLChecksumsSubsection()
74       : YAMLSubsectionBase(DebugSubsectionKind::FileChecksums) {}
75 
76   void map(IO &IO) override;
77   std::unique_ptr<DebugSubsection>
78   toCodeViewSubsection(DebugStringTableSubsection *Strings,
79                        DebugChecksumsSubsection *Checksums) const override;
80   static Expected<std::shared_ptr<YAMLChecksumsSubsection>>
81   fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings,
82                          const DebugChecksumsSubsectionRef &FC);
83 
84   std::vector<SourceFileChecksumEntry> Checksums;
85 };
86 
87 struct YAMLLinesSubsection : public YAMLSubsectionBase {
88   YAMLLinesSubsection() : YAMLSubsectionBase(DebugSubsectionKind::Lines) {}
89 
90   void map(IO &IO) override;
91   std::unique_ptr<DebugSubsection>
92   toCodeViewSubsection(DebugStringTableSubsection *Strings,
93                        DebugChecksumsSubsection *Checksums) const override;
94   static Expected<std::shared_ptr<YAMLLinesSubsection>>
95   fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings,
96                          const DebugChecksumsSubsectionRef &Checksums,
97                          const DebugLinesSubsectionRef &Lines);
98 
99   SourceLineInfo Lines;
100 };
101 
102 struct YAMLInlineeLinesSubsection : public YAMLSubsectionBase {
103   YAMLInlineeLinesSubsection()
104       : YAMLSubsectionBase(DebugSubsectionKind::InlineeLines) {}
105 
106   void map(IO &IO) override;
107   std::unique_ptr<DebugSubsection>
108   toCodeViewSubsection(DebugStringTableSubsection *Strings,
109                        DebugChecksumsSubsection *Checksums) const override;
110   static Expected<std::shared_ptr<YAMLInlineeLinesSubsection>>
111   fromCodeViewSubsection(const DebugStringTableSubsectionRef &Strings,
112                          const DebugChecksumsSubsectionRef &Checksums,
113                          const DebugInlineeLinesSubsectionRef &Lines);
114 
115   InlineeInfo InlineeLines;
116 };
117 }
118 
119 void ScalarBitSetTraits<LineFlags>::bitset(IO &io, LineFlags &Flags) {
120   io.bitSetCase(Flags, "HasColumnInfo", LF_HaveColumns);
121   io.enumFallback<Hex16>(Flags);
122 }
123 
124 void ScalarEnumerationTraits<FileChecksumKind>::enumeration(
125     IO &io, FileChecksumKind &Kind) {
126   io.enumCase(Kind, "None", FileChecksumKind::None);
127   io.enumCase(Kind, "MD5", FileChecksumKind::MD5);
128   io.enumCase(Kind, "SHA1", FileChecksumKind::SHA1);
129   io.enumCase(Kind, "SHA256", FileChecksumKind::SHA256);
130 }
131 
132 void ScalarTraits<HexFormattedString>::output(const HexFormattedString &Value,
133                                               void *ctx, raw_ostream &Out) {
134   StringRef Bytes(reinterpret_cast<const char *>(Value.Bytes.data()),
135                   Value.Bytes.size());
136   Out << toHex(Bytes);
137 }
138 
139 StringRef ScalarTraits<HexFormattedString>::input(StringRef Scalar, void *ctxt,
140                                                   HexFormattedString &Value) {
141   std::string H = fromHex(Scalar);
142   Value.Bytes.assign(H.begin(), H.end());
143   return StringRef();
144 }
145 
146 void MappingTraits<SourceLineEntry>::mapping(IO &IO, SourceLineEntry &Obj) {
147   IO.mapRequired("Offset", Obj.Offset);
148   IO.mapRequired("LineStart", Obj.LineStart);
149   IO.mapRequired("IsStatement", Obj.IsStatement);
150   IO.mapRequired("EndDelta", Obj.EndDelta);
151 }
152 
153 void MappingTraits<SourceColumnEntry>::mapping(IO &IO, SourceColumnEntry &Obj) {
154   IO.mapRequired("StartColumn", Obj.StartColumn);
155   IO.mapRequired("EndColumn", Obj.EndColumn);
156 }
157 
158 void MappingTraits<SourceLineBlock>::mapping(IO &IO, SourceLineBlock &Obj) {
159   IO.mapRequired("FileName", Obj.FileName);
160   IO.mapRequired("Lines", Obj.Lines);
161   IO.mapRequired("Columns", Obj.Columns);
162 }
163 
164 void MappingTraits<SourceFileChecksumEntry>::mapping(
165     IO &IO, SourceFileChecksumEntry &Obj) {
166   IO.mapRequired("FileName", Obj.FileName);
167   IO.mapRequired("Kind", Obj.Kind);
168   IO.mapRequired("Checksum", Obj.ChecksumBytes);
169 }
170 
171 void MappingTraits<InlineeSite>::mapping(IO &IO, InlineeSite &Obj) {
172   IO.mapRequired("FileName", Obj.FileName);
173   IO.mapRequired("LineNum", Obj.SourceLineNum);
174   IO.mapRequired("Inlinee", Obj.Inlinee);
175   IO.mapOptional("ExtraFiles", Obj.ExtraFiles);
176 }
177 
178 void YAMLChecksumsSubsection::map(IO &IO) {
179   IO.mapTag("!FileChecksums", true);
180   IO.mapRequired("Checksums", Checksums);
181 }
182 
183 void YAMLLinesSubsection::map(IO &IO) {
184   IO.mapTag("!Lines", true);
185   IO.mapRequired("CodeSize", Lines.CodeSize);
186 
187   IO.mapRequired("Flags", Lines.Flags);
188   IO.mapRequired("RelocOffset", Lines.RelocOffset);
189   IO.mapRequired("RelocSegment", Lines.RelocSegment);
190   IO.mapRequired("Blocks", Lines.Blocks);
191 }
192 
193 void YAMLInlineeLinesSubsection::map(IO &IO) {
194   IO.mapTag("!InlineeLines", true);
195   IO.mapRequired("HasExtraFiles", InlineeLines.HasExtraFiles);
196   IO.mapRequired("Sites", InlineeLines.Sites);
197 }
198 
199 void MappingTraits<YAMLDebugSubsection>::mapping(
200     IO &IO, YAMLDebugSubsection &Subsection) {
201   if (!IO.outputting()) {
202     if (IO.mapTag("!FileChecksums")) {
203       auto SS = std::make_shared<YAMLChecksumsSubsection>();
204       Subsection.Subsection = SS;
205     } else if (IO.mapTag("!Lines")) {
206       Subsection.Subsection = std::make_shared<YAMLLinesSubsection>();
207     } else if (IO.mapTag("!InlineeLines")) {
208       Subsection.Subsection = std::make_shared<YAMLInlineeLinesSubsection>();
209     } else {
210       llvm_unreachable("Unexpected subsection tag!");
211     }
212   }
213   Subsection.Subsection->map(IO);
214 }
215 
216 static Expected<const YAMLChecksumsSubsection &>
217 findChecksums(ArrayRef<YAMLDebugSubsection> Subsections) {
218   for (const auto &SS : Subsections) {
219     if (SS.Subsection->Kind == DebugSubsectionKind::FileChecksums) {
220       return static_cast<const YAMLChecksumsSubsection &>(*SS.Subsection);
221     }
222   }
223   return make_error<CodeViewError>(cv_error_code::no_records);
224 }
225 
226 std::unique_ptr<DebugSubsection> YAMLChecksumsSubsection::toCodeViewSubsection(
227     DebugStringTableSubsection *UseStrings,
228     DebugChecksumsSubsection *UseChecksums) const {
229   assert(UseStrings && !UseChecksums);
230   auto Result = llvm::make_unique<DebugChecksumsSubsection>(*UseStrings);
231   for (const auto &CS : Checksums) {
232     Result->addChecksum(CS.FileName, CS.Kind, CS.ChecksumBytes.Bytes);
233   }
234   return std::move(Result);
235 }
236 
237 std::unique_ptr<DebugSubsection> YAMLLinesSubsection::toCodeViewSubsection(
238     DebugStringTableSubsection *UseStrings,
239     DebugChecksumsSubsection *UseChecksums) const {
240   assert(UseStrings && UseChecksums);
241   auto Result =
242       llvm::make_unique<DebugLinesSubsection>(*UseChecksums, *UseStrings);
243   Result->setCodeSize(Lines.CodeSize);
244   Result->setRelocationAddress(Lines.RelocSegment, Lines.RelocOffset);
245   Result->setFlags(Lines.Flags);
246   for (const auto &LC : Lines.Blocks) {
247     Result->createBlock(LC.FileName);
248     if (Result->hasColumnInfo()) {
249       for (const auto &Item : zip(LC.Lines, LC.Columns)) {
250         auto &L = std::get<0>(Item);
251         auto &C = std::get<1>(Item);
252         uint32_t LE = L.LineStart + L.EndDelta;
253         Result->addLineAndColumnInfo(L.Offset,
254                                      LineInfo(L.LineStart, LE, L.IsStatement),
255                                      C.StartColumn, C.EndColumn);
256       }
257     } else {
258       for (const auto &L : LC.Lines) {
259         uint32_t LE = L.LineStart + L.EndDelta;
260         Result->addLineInfo(L.Offset, LineInfo(L.LineStart, LE, L.IsStatement));
261       }
262     }
263   }
264   return llvm::cast<DebugSubsection>(std::move(Result));
265 }
266 
267 std::unique_ptr<DebugSubsection>
268 YAMLInlineeLinesSubsection::toCodeViewSubsection(
269     DebugStringTableSubsection *UseStrings,
270     DebugChecksumsSubsection *UseChecksums) const {
271   assert(UseChecksums);
272   auto Result = llvm::make_unique<DebugInlineeLinesSubsection>(
273       *UseChecksums, InlineeLines.HasExtraFiles);
274 
275   for (const auto &Site : InlineeLines.Sites) {
276     Result->addInlineSite(TypeIndex(Site.Inlinee), Site.FileName,
277                           Site.SourceLineNum);
278     if (!InlineeLines.HasExtraFiles)
279       continue;
280 
281     for (auto EF : Site.ExtraFiles) {
282       Result->addExtraFile(EF);
283     }
284   }
285   return llvm::cast<DebugSubsection>(std::move(Result));
286 }
287 
288 static Expected<SourceFileChecksumEntry>
289 convertOneChecksum(const DebugStringTableSubsectionRef &Strings,
290                    const FileChecksumEntry &CS) {
291   auto ExpectedString = Strings.getString(CS.FileNameOffset);
292   if (!ExpectedString)
293     return ExpectedString.takeError();
294 
295   SourceFileChecksumEntry Result;
296   Result.ChecksumBytes.Bytes = CS.Checksum;
297   Result.Kind = CS.Kind;
298   Result.FileName = *ExpectedString;
299   return Result;
300 }
301 
302 static Expected<StringRef>
303 getFileName(const DebugStringTableSubsectionRef &Strings,
304             const DebugChecksumsSubsectionRef &Checksums, uint32_t FileID) {
305   auto Iter = Checksums.getArray().at(FileID);
306   if (Iter == Checksums.getArray().end())
307     return make_error<CodeViewError>(cv_error_code::no_records);
308   uint32_t Offset = Iter->FileNameOffset;
309   return Strings.getString(Offset);
310 }
311 
312 Expected<std::shared_ptr<YAMLChecksumsSubsection>>
313 YAMLChecksumsSubsection::fromCodeViewSubsection(
314     const DebugStringTableSubsectionRef &Strings,
315     const DebugChecksumsSubsectionRef &FC) {
316   auto Result = std::make_shared<YAMLChecksumsSubsection>();
317 
318   for (const auto &CS : FC) {
319     auto ConvertedCS = convertOneChecksum(Strings, CS);
320     if (!ConvertedCS)
321       return ConvertedCS.takeError();
322     Result->Checksums.push_back(*ConvertedCS);
323   }
324   return Result;
325 }
326 
327 Expected<std::shared_ptr<YAMLLinesSubsection>>
328 YAMLLinesSubsection::fromCodeViewSubsection(
329     const DebugStringTableSubsectionRef &Strings,
330     const DebugChecksumsSubsectionRef &Checksums,
331     const DebugLinesSubsectionRef &Lines) {
332   auto Result = std::make_shared<YAMLLinesSubsection>();
333   Result->Lines.CodeSize = Lines.header()->CodeSize;
334   Result->Lines.RelocOffset = Lines.header()->RelocOffset;
335   Result->Lines.RelocSegment = Lines.header()->RelocSegment;
336   Result->Lines.Flags = static_cast<LineFlags>(uint16_t(Lines.header()->Flags));
337   for (const auto &L : Lines) {
338     SourceLineBlock Block;
339     auto EF = getFileName(Strings, Checksums, L.NameIndex);
340     if (!EF)
341       return EF.takeError();
342     Block.FileName = *EF;
343     if (Lines.hasColumnInfo()) {
344       for (const auto &C : L.Columns) {
345         SourceColumnEntry SCE;
346         SCE.EndColumn = C.EndColumn;
347         SCE.StartColumn = C.StartColumn;
348         Block.Columns.push_back(SCE);
349       }
350     }
351     for (const auto &LN : L.LineNumbers) {
352       SourceLineEntry SLE;
353       LineInfo LI(LN.Flags);
354       SLE.Offset = LN.Offset;
355       SLE.LineStart = LI.getStartLine();
356       SLE.EndDelta = LI.getLineDelta();
357       SLE.IsStatement = LI.isStatement();
358       Block.Lines.push_back(SLE);
359     }
360     Result->Lines.Blocks.push_back(Block);
361   }
362   return Result;
363 }
364 
365 Expected<std::shared_ptr<YAMLInlineeLinesSubsection>>
366 YAMLInlineeLinesSubsection::fromCodeViewSubsection(
367     const DebugStringTableSubsectionRef &Strings,
368     const DebugChecksumsSubsectionRef &Checksums,
369     const DebugInlineeLinesSubsectionRef &Lines) {
370   auto Result = std::make_shared<YAMLInlineeLinesSubsection>();
371 
372   Result->InlineeLines.HasExtraFiles = Lines.hasExtraFiles();
373   for (const auto &IL : Lines) {
374     InlineeSite Site;
375     auto ExpF = getFileName(Strings, Checksums, IL.Header->FileID);
376     if (!ExpF)
377       return ExpF.takeError();
378     Site.FileName = *ExpF;
379     Site.Inlinee = IL.Header->Inlinee.getIndex();
380     Site.SourceLineNum = IL.Header->SourceLineNum;
381     if (Lines.hasExtraFiles()) {
382       for (const auto EF : IL.ExtraFiles) {
383         auto ExpF2 = getFileName(Strings, Checksums, EF);
384         if (!ExpF2)
385           return ExpF2.takeError();
386         Site.ExtraFiles.push_back(*ExpF2);
387       }
388     }
389     Result->InlineeLines.Sites.push_back(Site);
390   }
391   return Result;
392 }
393 
394 Expected<std::vector<std::unique_ptr<DebugSubsection>>>
395 llvm::CodeViewYAML::convertSubsectionList(
396     ArrayRef<YAMLDebugSubsection> Subsections,
397     DebugStringTableSubsection &Strings) {
398   std::vector<std::unique_ptr<DebugSubsection>> Result;
399   if (Subsections.empty())
400     return Result;
401 
402   auto Checksums = findChecksums(Subsections);
403   if (!Checksums)
404     return Checksums.takeError();
405   auto ChecksumsBase = Checksums->toCodeViewSubsection(&Strings, nullptr);
406   DebugChecksumsSubsection &CS =
407       llvm::cast<DebugChecksumsSubsection>(*ChecksumsBase);
408   for (const auto &SS : Subsections) {
409     // We've already converted the checksums subsection, don't do it
410     // twice.
411     std::unique_ptr<DebugSubsection> CVS;
412     if (SS.Subsection->Kind == DebugSubsectionKind::FileChecksums)
413       CVS = std::move(ChecksumsBase);
414     else
415       CVS = SS.Subsection->toCodeViewSubsection(&Strings, &CS);
416     Result.push_back(std::move(CVS));
417   }
418   return std::move(Result);
419 }
420 
421 namespace {
422 struct SubsectionConversionVisitor : public DebugSubsectionVisitor {
423   explicit SubsectionConversionVisitor(
424       const DebugStringTableSubsectionRef &Strings,
425       const DebugChecksumsSubsectionRef &Checksums)
426       : Strings(Strings), Checksums(Checksums) {}
427 
428   Error visitUnknown(DebugUnknownSubsectionRef &Unknown) override;
429   Error visitLines(DebugLinesSubsectionRef &Lines) override;
430   Error visitFileChecksums(DebugChecksumsSubsectionRef &Checksums) override;
431   Error visitInlineeLines(DebugInlineeLinesSubsectionRef &Inlinees) override;
432 
433   YAMLDebugSubsection Subsection;
434 
435 private:
436   const DebugStringTableSubsectionRef &Strings;
437   const DebugChecksumsSubsectionRef &Checksums;
438 };
439 
440 Error SubsectionConversionVisitor::visitUnknown(
441     DebugUnknownSubsectionRef &Unknown) {
442   return make_error<CodeViewError>(cv_error_code::operation_unsupported);
443 }
444 
445 Error SubsectionConversionVisitor::visitLines(DebugLinesSubsectionRef &Lines) {
446   auto Result =
447       YAMLLinesSubsection::fromCodeViewSubsection(Strings, Checksums, Lines);
448   if (!Result)
449     return Result.takeError();
450   Subsection.Subsection = *Result;
451   return Error::success();
452 }
453 
454 Error SubsectionConversionVisitor::visitFileChecksums(
455     DebugChecksumsSubsectionRef &Checksums) {
456   auto Result =
457       YAMLChecksumsSubsection::fromCodeViewSubsection(Strings, Checksums);
458   if (!Result)
459     return Result.takeError();
460   Subsection.Subsection = *Result;
461   return Error::success();
462 }
463 
464 Error SubsectionConversionVisitor::visitInlineeLines(
465     DebugInlineeLinesSubsectionRef &Inlinees) {
466   auto Result = YAMLInlineeLinesSubsection::fromCodeViewSubsection(
467       Strings, Checksums, Inlinees);
468   if (!Result)
469     return Result.takeError();
470   Subsection.Subsection = *Result;
471   return Error::success();
472 }
473 }
474 
475 Expected<YAMLDebugSubsection> YAMLDebugSubsection::fromCodeViewSubection(
476     const DebugStringTableSubsectionRef &Strings,
477     const DebugChecksumsSubsectionRef &Checksums,
478     const DebugSubsectionRecord &SS) {
479   SubsectionConversionVisitor V(Strings, Checksums);
480   if (auto EC = visitDebugSubsection(SS, V))
481     return std::move(EC);
482 
483   return V.Subsection;
484 }
485