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