1 //===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//
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/CodeViewYAMLTypes.h"
16 #include "llvm/ADT/APSInt.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/BinaryFormat/COFF.h"
20 #include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
21 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
22 #include "llvm/DebugInfo/CodeView/CodeView.h"
23 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
24 #include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
25 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
26 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
27 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
28 #include "llvm/Support/Allocator.h"
29 #include "llvm/Support/BinaryStreamReader.h"
30 #include "llvm/Support/BinaryStreamWriter.h"
31 #include "llvm/Support/Endian.h"
32 #include "llvm/Support/Error.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include "llvm/Support/YAMLTraits.h"
35 #include "llvm/Support/raw_ostream.h"
36 #include <algorithm>
37 #include <cassert>
38 #include <cstdint>
39 #include <vector>
40
41 using namespace llvm;
42 using namespace llvm::codeview;
43 using namespace llvm::CodeViewYAML;
44 using namespace llvm::CodeViewYAML::detail;
45 using namespace llvm::yaml;
46
47 LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
48 LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
49 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
50
51 LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)
52 LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)
53
54 LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)
55 LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)
56 LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)
57 LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)
58 LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)
59 LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)
60 LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)
61 LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)
62 LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)
63 LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)
64 LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)
65
66 LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)
67 LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)
68 LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)
69 LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)
70 LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)
71
72 LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)
73 LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)
74
75 namespace llvm {
76 namespace CodeViewYAML {
77 namespace detail {
78
79 struct LeafRecordBase {
80 TypeLeafKind Kind;
81
LeafRecordBasellvm::CodeViewYAML::detail::LeafRecordBase82 explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}
83 virtual ~LeafRecordBase() = default;
84
85 virtual void map(yaml::IO &io) = 0;
86 virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;
87 virtual Error fromCodeViewRecord(CVType Type) = 0;
88 };
89
90 template <typename T> struct LeafRecordImpl : public LeafRecordBase {
LeafRecordImplllvm::CodeViewYAML::detail::LeafRecordImpl91 explicit LeafRecordImpl(TypeLeafKind K)
92 : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
93
94 void map(yaml::IO &io) override;
95
fromCodeViewRecordllvm::CodeViewYAML::detail::LeafRecordImpl96 Error fromCodeViewRecord(CVType Type) override {
97 return TypeDeserializer::deserializeAs<T>(Type, Record);
98 }
99
toCodeViewRecordllvm::CodeViewYAML::detail::LeafRecordImpl100 CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
101 TS.writeLeafType(Record);
102 return CVType(Kind, TS.records().back());
103 }
104
105 mutable T Record;
106 };
107
108 template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {
LeafRecordImplllvm::CodeViewYAML::detail::LeafRecordImpl109 explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}
110
111 void map(yaml::IO &io) override;
112 CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;
113 Error fromCodeViewRecord(CVType Type) override;
114
115 std::vector<MemberRecord> Members;
116 };
117
118 struct MemberRecordBase {
119 TypeLeafKind Kind;
120
MemberRecordBasellvm::CodeViewYAML::detail::MemberRecordBase121 explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}
122 virtual ~MemberRecordBase() = default;
123
124 virtual void map(yaml::IO &io) = 0;
125 virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;
126 };
127
128 template <typename T> struct MemberRecordImpl : public MemberRecordBase {
MemberRecordImplllvm::CodeViewYAML::detail::MemberRecordImpl129 explicit MemberRecordImpl(TypeLeafKind K)
130 : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
131
132 void map(yaml::IO &io) override;
133
writeTollvm::CodeViewYAML::detail::MemberRecordImpl134 void writeTo(ContinuationRecordBuilder &CRB) override {
135 CRB.writeMemberType(Record);
136 }
137
138 mutable T Record;
139 };
140
141 } // end namespace detail
142 } // end namespace CodeViewYAML
143 } // end namespace llvm
144
output(const GUID & G,void *,llvm::raw_ostream & OS)145 void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {
146 OS << G;
147 }
148
input(StringRef Scalar,void * Ctx,GUID & S)149 StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {
150 if (Scalar.size() != 38)
151 return "GUID strings are 38 characters long";
152 if (Scalar[0] != '{' || Scalar[37] != '}')
153 return "GUID is not enclosed in {}";
154 if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
155 Scalar[24] != '-')
156 return "GUID sections are not properly delineated with dashes";
157
158 uint8_t *OutBuffer = S.Guid;
159 for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
160 if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
161 ++Iter;
162 continue;
163 }
164 uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);
165 Value |= llvm::hexDigitValue(*Iter++);
166 *OutBuffer++ = Value;
167 }
168
169 return "";
170 }
171
output(const TypeIndex & S,void *,raw_ostream & OS)172 void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
173 raw_ostream &OS) {
174 OS << S.getIndex();
175 }
176
input(StringRef Scalar,void * Ctx,TypeIndex & S)177 StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,
178 TypeIndex &S) {
179 uint32_t I;
180 StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);
181 S.setIndex(I);
182 return Result;
183 }
184
output(const APSInt & S,void *,raw_ostream & OS)185 void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {
186 S.print(OS, S.isSigned());
187 }
188
input(StringRef Scalar,void * Ctx,APSInt & S)189 StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {
190 S = APSInt(Scalar);
191 return "";
192 }
193
enumeration(IO & io,TypeLeafKind & Value)194 void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
195 TypeLeafKind &Value) {
196 #define CV_TYPE(name, val) io.enumCase(Value, #name, name);
197 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
198 #undef CV_TYPE
199 }
200
enumeration(IO & IO,PointerToMemberRepresentation & Value)201 void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(
202 IO &IO, PointerToMemberRepresentation &Value) {
203 IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
204 IO.enumCase(Value, "SingleInheritanceData",
205 PointerToMemberRepresentation::SingleInheritanceData);
206 IO.enumCase(Value, "MultipleInheritanceData",
207 PointerToMemberRepresentation::MultipleInheritanceData);
208 IO.enumCase(Value, "VirtualInheritanceData",
209 PointerToMemberRepresentation::VirtualInheritanceData);
210 IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);
211 IO.enumCase(Value, "SingleInheritanceFunction",
212 PointerToMemberRepresentation::SingleInheritanceFunction);
213 IO.enumCase(Value, "MultipleInheritanceFunction",
214 PointerToMemberRepresentation::MultipleInheritanceFunction);
215 IO.enumCase(Value, "VirtualInheritanceFunction",
216 PointerToMemberRepresentation::VirtualInheritanceFunction);
217 IO.enumCase(Value, "GeneralFunction",
218 PointerToMemberRepresentation::GeneralFunction);
219 }
220
enumeration(IO & IO,VFTableSlotKind & Kind)221 void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(
222 IO &IO, VFTableSlotKind &Kind) {
223 IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);
224 IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);
225 IO.enumCase(Kind, "This", VFTableSlotKind::This);
226 IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);
227 IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);
228 IO.enumCase(Kind, "Near", VFTableSlotKind::Near);
229 IO.enumCase(Kind, "Far", VFTableSlotKind::Far);
230 }
231
enumeration(IO & IO,CallingConvention & Value)232 void ScalarEnumerationTraits<CallingConvention>::enumeration(
233 IO &IO, CallingConvention &Value) {
234 IO.enumCase(Value, "NearC", CallingConvention::NearC);
235 IO.enumCase(Value, "FarC", CallingConvention::FarC);
236 IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);
237 IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);
238 IO.enumCase(Value, "NearFast", CallingConvention::NearFast);
239 IO.enumCase(Value, "FarFast", CallingConvention::FarFast);
240 IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);
241 IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);
242 IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);
243 IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);
244 IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);
245 IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);
246 IO.enumCase(Value, "Generic", CallingConvention::Generic);
247 IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);
248 IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);
249 IO.enumCase(Value, "SHCall", CallingConvention::SHCall);
250 IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);
251 IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);
252 IO.enumCase(Value, "TriCall", CallingConvention::TriCall);
253 IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);
254 IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);
255 IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);
256 IO.enumCase(Value, "Inline", CallingConvention::Inline);
257 IO.enumCase(Value, "NearVector", CallingConvention::NearVector);
258 }
259
enumeration(IO & IO,PointerKind & Kind)260 void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,
261 PointerKind &Kind) {
262 IO.enumCase(Kind, "Near16", PointerKind::Near16);
263 IO.enumCase(Kind, "Far16", PointerKind::Far16);
264 IO.enumCase(Kind, "Huge16", PointerKind::Huge16);
265 IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);
266 IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);
267 IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);
268 IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);
269 IO.enumCase(Kind, "BasedOnSegmentAddress",
270 PointerKind::BasedOnSegmentAddress);
271 IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);
272 IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);
273 IO.enumCase(Kind, "Near32", PointerKind::Near32);
274 IO.enumCase(Kind, "Far32", PointerKind::Far32);
275 IO.enumCase(Kind, "Near64", PointerKind::Near64);
276 }
277
enumeration(IO & IO,PointerMode & Mode)278 void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,
279 PointerMode &Mode) {
280 IO.enumCase(Mode, "Pointer", PointerMode::Pointer);
281 IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);
282 IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);
283 IO.enumCase(Mode, "PointerToMemberFunction",
284 PointerMode::PointerToMemberFunction);
285 IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);
286 }
287
enumeration(IO & IO,HfaKind & Value)288 void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {
289 IO.enumCase(Value, "None", HfaKind::None);
290 IO.enumCase(Value, "Float", HfaKind::Float);
291 IO.enumCase(Value, "Double", HfaKind::Double);
292 IO.enumCase(Value, "Other", HfaKind::Other);
293 }
294
enumeration(IO & IO,MemberAccess & Access)295 void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,
296 MemberAccess &Access) {
297 IO.enumCase(Access, "None", MemberAccess::None);
298 IO.enumCase(Access, "Private", MemberAccess::Private);
299 IO.enumCase(Access, "Protected", MemberAccess::Protected);
300 IO.enumCase(Access, "Public", MemberAccess::Public);
301 }
302
enumeration(IO & IO,MethodKind & Kind)303 void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,
304 MethodKind &Kind) {
305 IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);
306 IO.enumCase(Kind, "Virtual", MethodKind::Virtual);
307 IO.enumCase(Kind, "Static", MethodKind::Static);
308 IO.enumCase(Kind, "Friend", MethodKind::Friend);
309 IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);
310 IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);
311 IO.enumCase(Kind, "PureIntroducingVirtual",
312 MethodKind::PureIntroducingVirtual);
313 }
314
enumeration(IO & IO,WindowsRTClassKind & Value)315 void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(
316 IO &IO, WindowsRTClassKind &Value) {
317 IO.enumCase(Value, "None", WindowsRTClassKind::None);
318 IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);
319 IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);
320 IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);
321 }
322
enumeration(IO & IO,LabelType & Value)323 void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {
324 IO.enumCase(Value, "Near", LabelType::Near);
325 IO.enumCase(Value, "Far", LabelType::Far);
326 }
327
bitset(IO & IO,PointerOptions & Options)328 void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
329 PointerOptions &Options) {
330 IO.bitSetCase(Options, "None", PointerOptions::None);
331 IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
332 IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
333 IO.bitSetCase(Options, "Const", PointerOptions::Const);
334 IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
335 IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
336 IO.bitSetCase(Options, "WinRTSmartPointer",
337 PointerOptions::WinRTSmartPointer);
338 }
339
bitset(IO & IO,ModifierOptions & Options)340 void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
341 ModifierOptions &Options) {
342 IO.bitSetCase(Options, "None", ModifierOptions::None);
343 IO.bitSetCase(Options, "Const", ModifierOptions::Const);
344 IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
345 IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);
346 }
347
bitset(IO & IO,FunctionOptions & Options)348 void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,
349 FunctionOptions &Options) {
350 IO.bitSetCase(Options, "None", FunctionOptions::None);
351 IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
352 IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
353 IO.bitSetCase(Options, "ConstructorWithVirtualBases",
354 FunctionOptions::ConstructorWithVirtualBases);
355 }
356
bitset(IO & IO,ClassOptions & Options)357 void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {
358 IO.bitSetCase(Options, "None", ClassOptions::None);
359 IO.bitSetCase(Options, "HasConstructorOrDestructor",
360 ClassOptions::HasConstructorOrDestructor);
361 IO.bitSetCase(Options, "HasOverloadedOperator",
362 ClassOptions::HasOverloadedOperator);
363 IO.bitSetCase(Options, "Nested", ClassOptions::Nested);
364 IO.bitSetCase(Options, "ContainsNestedClass",
365 ClassOptions::ContainsNestedClass);
366 IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",
367 ClassOptions::HasOverloadedAssignmentOperator);
368 IO.bitSetCase(Options, "HasConversionOperator",
369 ClassOptions::HasConversionOperator);
370 IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);
371 IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);
372 IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);
373 IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);
374 IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);
375 }
376
bitset(IO & IO,MethodOptions & Options)377 void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {
378 IO.bitSetCase(Options, "None", MethodOptions::None);
379 IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);
380 IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);
381 IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);
382 IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);
383 IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
384 }
385
mapping(IO & IO,MemberPointerInfo & MPI)386 void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
387 IO.mapRequired("ContainingType", MPI.ContainingType);
388 IO.mapRequired("Representation", MPI.Representation);
389 }
390
391 namespace llvm {
392 namespace CodeViewYAML {
393 namespace detail {
394
map(IO & IO)395 template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {
396 IO.mapRequired("ModifiedType", Record.ModifiedType);
397 IO.mapRequired("Modifiers", Record.Modifiers);
398 }
399
map(IO & IO)400 template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {
401 IO.mapRequired("ReturnType", Record.ReturnType);
402 IO.mapRequired("CallConv", Record.CallConv);
403 IO.mapRequired("Options", Record.Options);
404 IO.mapRequired("ParameterCount", Record.ParameterCount);
405 IO.mapRequired("ArgumentList", Record.ArgumentList);
406 }
407
map(IO & IO)408 template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {
409 IO.mapRequired("ReturnType", Record.ReturnType);
410 IO.mapRequired("ClassType", Record.ClassType);
411 IO.mapRequired("ThisType", Record.ThisType);
412 IO.mapRequired("CallConv", Record.CallConv);
413 IO.mapRequired("Options", Record.Options);
414 IO.mapRequired("ParameterCount", Record.ParameterCount);
415 IO.mapRequired("ArgumentList", Record.ArgumentList);
416 IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);
417 }
418
map(IO & IO)419 template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {
420 IO.mapRequired("Mode", Record.Mode);
421 }
422
map(IO & IO)423 template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {
424 IO.mapRequired("ClassType", Record.ClassType);
425 IO.mapRequired("FunctionType", Record.FunctionType);
426 IO.mapRequired("Name", Record.Name);
427 }
428
map(IO & IO)429 template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {
430 IO.mapRequired("ArgIndices", Record.ArgIndices);
431 }
432
map(IO & IO)433 template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {
434 IO.mapRequired("StringIndices", Record.StringIndices);
435 }
436
map(IO & IO)437 template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {
438 IO.mapRequired("ReferentType", Record.ReferentType);
439 IO.mapRequired("Attrs", Record.Attrs);
440 IO.mapOptional("MemberInfo", Record.MemberInfo);
441 }
442
map(IO & IO)443 template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {
444 IO.mapRequired("ElementType", Record.ElementType);
445 IO.mapRequired("IndexType", Record.IndexType);
446 IO.mapRequired("Size", Record.Size);
447 IO.mapRequired("Name", Record.Name);
448 }
449
map(IO & IO)450 void LeafRecordImpl<FieldListRecord>::map(IO &IO) {
451 IO.mapRequired("FieldList", Members);
452 }
453
454 } // end namespace detail
455 } // end namespace CodeViewYAML
456 } // end namespace llvm
457
458 namespace {
459
460 class MemberRecordConversionVisitor : public TypeVisitorCallbacks {
461 public:
MemberRecordConversionVisitor(std::vector<MemberRecord> & Records)462 explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)
463 : Records(Records) {}
464
465 #define TYPE_RECORD(EnumName, EnumVal, Name)
466 #define MEMBER_RECORD(EnumName, EnumVal, Name) \
467 Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
468 return visitKnownMemberImpl(Record); \
469 }
470 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
471 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
472 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
473 private:
visitKnownMemberImpl(T & Record)474 template <typename T> Error visitKnownMemberImpl(T &Record) {
475 TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());
476 auto Impl = std::make_shared<MemberRecordImpl<T>>(K);
477 Impl->Record = Record;
478 Records.push_back(MemberRecord{Impl});
479 return Error::success();
480 }
481
482 std::vector<MemberRecord> &Records;
483 };
484
485 } // end anonymous namespace
486
fromCodeViewRecord(CVType Type)487 Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {
488 MemberRecordConversionVisitor V(Members);
489 return visitMemberRecordStream(Type.content(), V);
490 }
491
toCodeViewRecord(AppendingTypeTableBuilder & TS) const492 CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(
493 AppendingTypeTableBuilder &TS) const {
494 ContinuationRecordBuilder CRB;
495 CRB.begin(ContinuationRecordKind::FieldList);
496 for (const auto &Member : Members) {
497 Member.Member->writeTo(CRB);
498 }
499 TS.insertRecord(CRB);
500 return CVType(Kind, TS.records().back());
501 }
502
mapping(IO & io,OneMethodRecord & Record)503 void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {
504 io.mapRequired("Type", Record.Type);
505 io.mapRequired("Attrs", Record.Attrs.Attrs);
506 io.mapRequired("VFTableOffset", Record.VFTableOffset);
507 io.mapRequired("Name", Record.Name);
508 }
509
510 namespace llvm {
511 namespace CodeViewYAML {
512 namespace detail {
513
map(IO & IO)514 template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {
515 IO.mapRequired("MemberCount", Record.MemberCount);
516 IO.mapRequired("Options", Record.Options);
517 IO.mapRequired("FieldList", Record.FieldList);
518 IO.mapRequired("Name", Record.Name);
519 IO.mapRequired("UniqueName", Record.UniqueName);
520 IO.mapRequired("DerivationList", Record.DerivationList);
521 IO.mapRequired("VTableShape", Record.VTableShape);
522 IO.mapRequired("Size", Record.Size);
523 }
524
map(IO & IO)525 template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {
526 IO.mapRequired("MemberCount", Record.MemberCount);
527 IO.mapRequired("Options", Record.Options);
528 IO.mapRequired("FieldList", Record.FieldList);
529 IO.mapRequired("Name", Record.Name);
530 IO.mapRequired("UniqueName", Record.UniqueName);
531 IO.mapRequired("Size", Record.Size);
532 }
533
map(IO & IO)534 template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {
535 IO.mapRequired("NumEnumerators", Record.MemberCount);
536 IO.mapRequired("Options", Record.Options);
537 IO.mapRequired("FieldList", Record.FieldList);
538 IO.mapRequired("Name", Record.Name);
539 IO.mapRequired("UniqueName", Record.UniqueName);
540 IO.mapRequired("UnderlyingType", Record.UnderlyingType);
541 }
542
map(IO & IO)543 template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {
544 IO.mapRequired("Type", Record.Type);
545 IO.mapRequired("BitSize", Record.BitSize);
546 IO.mapRequired("BitOffset", Record.BitOffset);
547 }
548
map(IO & IO)549 template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {
550 IO.mapRequired("Slots", Record.Slots);
551 }
552
map(IO & IO)553 template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {
554 IO.mapRequired("Guid", Record.Guid);
555 IO.mapRequired("Age", Record.Age);
556 IO.mapRequired("Name", Record.Name);
557 }
558
map(IO & IO)559 template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {
560 IO.mapRequired("Id", Record.Id);
561 IO.mapRequired("String", Record.String);
562 }
563
map(IO & IO)564 template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {
565 IO.mapRequired("ParentScope", Record.ParentScope);
566 IO.mapRequired("FunctionType", Record.FunctionType);
567 IO.mapRequired("Name", Record.Name);
568 }
569
map(IO & IO)570 template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {
571 IO.mapRequired("UDT", Record.UDT);
572 IO.mapRequired("SourceFile", Record.SourceFile);
573 IO.mapRequired("LineNumber", Record.LineNumber);
574 }
575
map(IO & IO)576 template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {
577 IO.mapRequired("UDT", Record.UDT);
578 IO.mapRequired("SourceFile", Record.SourceFile);
579 IO.mapRequired("LineNumber", Record.LineNumber);
580 IO.mapRequired("Module", Record.Module);
581 }
582
map(IO & IO)583 template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {
584 IO.mapRequired("ArgIndices", Record.ArgIndices);
585 }
586
map(IO & IO)587 template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {
588 IO.mapRequired("CompleteClass", Record.CompleteClass);
589 IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);
590 IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);
591 IO.mapRequired("MethodNames", Record.MethodNames);
592 }
593
map(IO & IO)594 template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {
595 IO.mapRequired("Methods", Record.Methods);
596 }
597
map(IO & IO)598 template <> void LeafRecordImpl<PrecompRecord>::map(IO &IO) {
599 IO.mapRequired("StartTypeIndex", Record.StartTypeIndex);
600 IO.mapRequired("TypesCount", Record.TypesCount);
601 IO.mapRequired("Signature", Record.Signature);
602 IO.mapRequired("PrecompFilePath", Record.PrecompFilePath);
603 }
604
map(IO & IO)605 template <> void LeafRecordImpl<EndPrecompRecord>::map(IO &IO) {
606 IO.mapRequired("Signature", Record.Signature);
607 }
608
map(IO & IO)609 template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {
610 MappingTraits<OneMethodRecord>::mapping(IO, Record);
611 }
612
map(IO & IO)613 template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {
614 IO.mapRequired("NumOverloads", Record.NumOverloads);
615 IO.mapRequired("MethodList", Record.MethodList);
616 IO.mapRequired("Name", Record.Name);
617 }
618
map(IO & IO)619 template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {
620 IO.mapRequired("Type", Record.Type);
621 IO.mapRequired("Name", Record.Name);
622 }
623
map(IO & IO)624 template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {
625 IO.mapRequired("Attrs", Record.Attrs.Attrs);
626 IO.mapRequired("Type", Record.Type);
627 IO.mapRequired("FieldOffset", Record.FieldOffset);
628 IO.mapRequired("Name", Record.Name);
629 }
630
map(IO & IO)631 template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {
632 IO.mapRequired("Attrs", Record.Attrs.Attrs);
633 IO.mapRequired("Type", Record.Type);
634 IO.mapRequired("Name", Record.Name);
635 }
636
map(IO & IO)637 template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {
638 IO.mapRequired("Attrs", Record.Attrs.Attrs);
639 IO.mapRequired("Value", Record.Value);
640 IO.mapRequired("Name", Record.Name);
641 }
642
map(IO & IO)643 template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {
644 IO.mapRequired("Type", Record.Type);
645 }
646
map(IO & IO)647 template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {
648 IO.mapRequired("Attrs", Record.Attrs.Attrs);
649 IO.mapRequired("Type", Record.Type);
650 IO.mapRequired("Offset", Record.Offset);
651 }
652
map(IO & IO)653 template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {
654 IO.mapRequired("Attrs", Record.Attrs.Attrs);
655 IO.mapRequired("BaseType", Record.BaseType);
656 IO.mapRequired("VBPtrType", Record.VBPtrType);
657 IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);
658 IO.mapRequired("VTableIndex", Record.VTableIndex);
659 }
660
map(IO & IO)661 template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {
662 IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);
663 }
664
665 } // end namespace detail
666 } // end namespace CodeViewYAML
667 } // end namespace llvm
668
669 template <typename T>
fromCodeViewRecordImpl(CVType Type)670 static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
671 LeafRecord Result;
672
673 auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
674 if (auto EC = Impl->fromCodeViewRecord(Type))
675 return std::move(EC);
676 Result.Leaf = Impl;
677 return Result;
678 }
679
fromCodeViewRecord(CVType Type)680 Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {
681 #define TYPE_RECORD(EnumName, EnumVal, ClassName) \
682 case EnumName: \
683 return fromCodeViewRecordImpl<ClassName##Record>(Type);
684 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
685 TYPE_RECORD(EnumName, EnumVal, ClassName)
686 #define MEMBER_RECORD(EnumName, EnumVal, ClassName)
687 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
688 switch (Type.kind()) {
689 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
690 default:
691 llvm_unreachable("Unknown leaf kind!");
692 }
693 return make_error<CodeViewError>(cv_error_code::corrupt_record);
694 }
695
696 CVType
toCodeViewRecord(AppendingTypeTableBuilder & Serializer) const697 LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {
698 return Leaf->toCodeViewRecord(Serializer);
699 }
700
701 namespace llvm {
702 namespace yaml {
703
704 template <> struct MappingTraits<LeafRecordBase> {
mappingllvm::yaml::MappingTraits705 static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }
706 };
707
708 template <> struct MappingTraits<MemberRecordBase> {
mappingllvm::yaml::MappingTraits709 static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }
710 };
711
712 } // end namespace yaml
713 } // end namespace llvm
714
715 template <typename ConcreteType>
mapLeafRecordImpl(IO & IO,const char * Class,TypeLeafKind Kind,LeafRecord & Obj)716 static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
717 LeafRecord &Obj) {
718 if (!IO.outputting())
719 Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);
720
721 if (Kind == LF_FIELDLIST)
722 Obj.Leaf->map(IO);
723 else
724 IO.mapRequired(Class, *Obj.Leaf);
725 }
726
mapping(IO & IO,LeafRecord & Obj)727 void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {
728 TypeLeafKind Kind;
729 if (IO.outputting())
730 Kind = Obj.Leaf->Kind;
731 IO.mapRequired("Kind", Kind);
732
733 #define TYPE_RECORD(EnumName, EnumVal, ClassName) \
734 case EnumName: \
735 mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \
736 break;
737 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
738 TYPE_RECORD(EnumName, EnumVal, ClassName)
739 #define MEMBER_RECORD(EnumName, EnumVal, ClassName)
740 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
741 switch (Kind) {
742 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
743 default: { llvm_unreachable("Unknown leaf kind!"); }
744 }
745 }
746
747 template <typename ConcreteType>
mapMemberRecordImpl(IO & IO,const char * Class,TypeLeafKind Kind,MemberRecord & Obj)748 static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
749 MemberRecord &Obj) {
750 if (!IO.outputting())
751 Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);
752
753 IO.mapRequired(Class, *Obj.Member);
754 }
755
mapping(IO & IO,MemberRecord & Obj)756 void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {
757 TypeLeafKind Kind;
758 if (IO.outputting())
759 Kind = Obj.Member->Kind;
760 IO.mapRequired("Kind", Kind);
761
762 #define MEMBER_RECORD(EnumName, EnumVal, ClassName) \
763 case EnumName: \
764 mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \
765 break;
766 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
767 MEMBER_RECORD(EnumName, EnumVal, ClassName)
768 #define TYPE_RECORD(EnumName, EnumVal, ClassName)
769 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
770 switch (Kind) {
771 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
772 default: { llvm_unreachable("Unknown member kind!"); }
773 }
774 }
775
776 std::vector<LeafRecord>
fromDebugT(ArrayRef<uint8_t> DebugTorP,StringRef SectionName)777 llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugTorP,
778 StringRef SectionName) {
779 ExitOnError Err("Invalid " + std::string(SectionName) + " section!");
780 BinaryStreamReader Reader(DebugTorP, support::little);
781 CVTypeArray Types;
782 uint32_t Magic;
783
784 Err(Reader.readInteger(Magic));
785 assert(Magic == COFF::DEBUG_SECTION_MAGIC &&
786 "Invalid .debug$T or .debug$P section!");
787
788 std::vector<LeafRecord> Result;
789 Err(Reader.readArray(Types, Reader.bytesRemaining()));
790 for (const auto &T : Types) {
791 auto CVT = Err(LeafRecord::fromCodeViewRecord(T));
792 Result.push_back(CVT);
793 }
794 return Result;
795 }
796
toDebugT(ArrayRef<LeafRecord> Leafs,BumpPtrAllocator & Alloc,StringRef SectionName)797 ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,
798 BumpPtrAllocator &Alloc,
799 StringRef SectionName) {
800 AppendingTypeTableBuilder TS(Alloc);
801 uint32_t Size = sizeof(uint32_t);
802 for (const auto &Leaf : Leafs) {
803 CVType T = Leaf.Leaf->toCodeViewRecord(TS);
804 Size += T.length();
805 assert(T.length() % 4 == 0 && "Improper type record alignment!");
806 }
807 uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);
808 MutableArrayRef<uint8_t> Output(ResultBuffer, Size);
809 BinaryStreamWriter Writer(Output, support::little);
810 ExitOnError Err("Error writing type record to " + std::string(SectionName) +
811 " section");
812 Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));
813 for (const auto &R : TS.records()) {
814 Err(Writer.writeBytes(R));
815 }
816 assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!");
817 return Output;
818 }
819