1 //===- TypeRecord.h ---------------------------------------------*- C++ -*-===// 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 #ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H 11 #define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H 12 13 #include "llvm/ADT/APSInt.h" 14 #include "llvm/ADT/ArrayRef.h" 15 #include "llvm/ADT/Optional.h" 16 #include "llvm/ADT/SmallVector.h" 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/ADT/iterator_range.h" 19 #include "llvm/DebugInfo/CodeView/CVRecord.h" 20 #include "llvm/DebugInfo/CodeView/CodeView.h" 21 #include "llvm/DebugInfo/CodeView/GUID.h" 22 #include "llvm/DebugInfo/CodeView/TypeIndex.h" 23 #include "llvm/Support/BinaryStreamArray.h" 24 #include "llvm/Support/Endian.h" 25 #include <algorithm> 26 #include <cstdint> 27 #include <vector> 28 29 namespace llvm { 30 namespace codeview { 31 32 using support::little32_t; 33 using support::ulittle16_t; 34 using support::ulittle32_t; 35 36 using CVType = CVRecord<TypeLeafKind>; 37 using RemappedType = RemappedRecord<TypeLeafKind>; 38 39 struct CVMemberRecord { 40 TypeLeafKind Kind; 41 ArrayRef<uint8_t> Data; 42 }; 43 using CVTypeArray = VarStreamArray<CVType>; 44 using CVTypeRange = iterator_range<CVTypeArray::Iterator>; 45 46 /// Equvalent to CV_fldattr_t in cvinfo.h. 47 struct MemberAttributes { 48 uint16_t Attrs = 0; 49 50 enum { 51 MethodKindShift = 2, 52 }; 53 54 MemberAttributes() = default; 55 56 explicit MemberAttributes(MemberAccess Access) 57 : Attrs(static_cast<uint16_t>(Access)) {} 58 59 MemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Flags) { 60 Attrs = static_cast<uint16_t>(Access); 61 Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift); 62 Attrs |= static_cast<uint16_t>(Flags); 63 } 64 65 /// Get the access specifier. Valid for any kind of member. 66 MemberAccess getAccess() const { 67 return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask)); 68 } 69 70 /// Indicates if a method is defined with friend, virtual, static, etc. 71 MethodKind getMethodKind() const { 72 return MethodKind( 73 (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >> 74 MethodKindShift); 75 } 76 77 /// Get the flags that are not included in access control or method 78 /// properties. 79 MethodOptions getFlags() const { 80 return MethodOptions( 81 unsigned(Attrs) & 82 ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask)); 83 } 84 85 /// Is this method virtual. 86 bool isVirtual() const { 87 auto MP = getMethodKind(); 88 return MP != MethodKind::Vanilla && MP != MethodKind::Friend && 89 MP != MethodKind::Static; 90 } 91 92 /// Does this member introduce a new virtual method. 93 bool isIntroducedVirtual() const { 94 auto MP = getMethodKind(); 95 return MP == MethodKind::IntroducingVirtual || 96 MP == MethodKind::PureIntroducingVirtual; 97 } 98 }; 99 100 // Does not correspond to any tag, this is the tail of an LF_POINTER record 101 // if it represents a member pointer. 102 class MemberPointerInfo { 103 public: 104 MemberPointerInfo() = default; 105 106 MemberPointerInfo(TypeIndex ContainingType, 107 PointerToMemberRepresentation Representation) 108 : ContainingType(ContainingType), Representation(Representation) {} 109 110 TypeIndex getContainingType() const { return ContainingType; } 111 PointerToMemberRepresentation getRepresentation() const { 112 return Representation; 113 } 114 115 TypeIndex ContainingType; 116 PointerToMemberRepresentation Representation; 117 }; 118 119 class TypeRecord { 120 protected: 121 TypeRecord() = default; 122 explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {} 123 124 public: 125 TypeRecordKind getKind() const { return Kind; } 126 127 TypeRecordKind Kind; 128 }; 129 130 // LF_MODIFIER 131 class ModifierRecord : public TypeRecord { 132 public: 133 ModifierRecord() = default; 134 explicit ModifierRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 135 ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers) 136 : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType), 137 Modifiers(Modifiers) {} 138 139 TypeIndex getModifiedType() const { return ModifiedType; } 140 ModifierOptions getModifiers() const { return Modifiers; } 141 142 TypeIndex ModifiedType; 143 ModifierOptions Modifiers; 144 }; 145 146 // LF_PROCEDURE 147 class ProcedureRecord : public TypeRecord { 148 public: 149 ProcedureRecord() = default; 150 explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 151 ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv, 152 FunctionOptions Options, uint16_t ParameterCount, 153 TypeIndex ArgumentList) 154 : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType), 155 CallConv(CallConv), Options(Options), ParameterCount(ParameterCount), 156 ArgumentList(ArgumentList) {} 157 158 TypeIndex getReturnType() const { return ReturnType; } 159 CallingConvention getCallConv() const { return CallConv; } 160 FunctionOptions getOptions() const { return Options; } 161 uint16_t getParameterCount() const { return ParameterCount; } 162 TypeIndex getArgumentList() const { return ArgumentList; } 163 164 TypeIndex ReturnType; 165 CallingConvention CallConv; 166 FunctionOptions Options; 167 uint16_t ParameterCount; 168 TypeIndex ArgumentList; 169 }; 170 171 // LF_MFUNCTION 172 class MemberFunctionRecord : public TypeRecord { 173 public: 174 MemberFunctionRecord() = default; 175 explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 176 177 MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType, 178 TypeIndex ThisType, CallingConvention CallConv, 179 FunctionOptions Options, uint16_t ParameterCount, 180 TypeIndex ArgumentList, int32_t ThisPointerAdjustment) 181 : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType), 182 ClassType(ClassType), ThisType(ThisType), CallConv(CallConv), 183 Options(Options), ParameterCount(ParameterCount), 184 ArgumentList(ArgumentList), 185 ThisPointerAdjustment(ThisPointerAdjustment) {} 186 187 TypeIndex getReturnType() const { return ReturnType; } 188 TypeIndex getClassType() const { return ClassType; } 189 TypeIndex getThisType() const { return ThisType; } 190 CallingConvention getCallConv() const { return CallConv; } 191 FunctionOptions getOptions() const { return Options; } 192 uint16_t getParameterCount() const { return ParameterCount; } 193 TypeIndex getArgumentList() const { return ArgumentList; } 194 int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; } 195 196 TypeIndex ReturnType; 197 TypeIndex ClassType; 198 TypeIndex ThisType; 199 CallingConvention CallConv; 200 FunctionOptions Options; 201 uint16_t ParameterCount; 202 TypeIndex ArgumentList; 203 int32_t ThisPointerAdjustment; 204 }; 205 206 // LF_LABEL 207 class LabelRecord : public TypeRecord { 208 public: 209 LabelRecord() = default; 210 explicit LabelRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 211 212 LabelRecord(LabelType Mode) : TypeRecord(TypeRecordKind::Label), Mode(Mode) {} 213 214 LabelType Mode; 215 }; 216 217 // LF_MFUNC_ID 218 class MemberFuncIdRecord : public TypeRecord { 219 public: 220 MemberFuncIdRecord() = default; 221 explicit MemberFuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 222 MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType, 223 StringRef Name) 224 : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType), 225 FunctionType(FunctionType), Name(Name) {} 226 227 TypeIndex getClassType() const { return ClassType; } 228 TypeIndex getFunctionType() const { return FunctionType; } 229 StringRef getName() const { return Name; } 230 231 TypeIndex ClassType; 232 TypeIndex FunctionType; 233 StringRef Name; 234 }; 235 236 // LF_ARGLIST 237 class ArgListRecord : public TypeRecord { 238 public: 239 ArgListRecord() = default; 240 explicit ArgListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 241 242 ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices) 243 : TypeRecord(Kind), ArgIndices(Indices) {} 244 245 ArrayRef<TypeIndex> getIndices() const { return ArgIndices; } 246 247 std::vector<TypeIndex> ArgIndices; 248 }; 249 250 // LF_SUBSTR_LIST 251 class StringListRecord : public TypeRecord { 252 public: 253 StringListRecord() = default; 254 explicit StringListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 255 256 StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices) 257 : TypeRecord(Kind), StringIndices(Indices) {} 258 259 ArrayRef<TypeIndex> getIndices() const { return StringIndices; } 260 261 std::vector<TypeIndex> StringIndices; 262 }; 263 264 // LF_POINTER 265 class PointerRecord : public TypeRecord { 266 public: 267 static const uint32_t PointerKindShift = 0; 268 static const uint32_t PointerKindMask = 0x1F; 269 270 static const uint32_t PointerModeShift = 5; 271 static const uint32_t PointerModeMask = 0x07; 272 273 static const uint32_t PointerOptionMask = 0xFF; 274 275 static const uint32_t PointerSizeShift = 13; 276 static const uint32_t PointerSizeMask = 0xFF; 277 278 PointerRecord() = default; 279 explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 280 281 PointerRecord(TypeIndex ReferentType, uint32_t Attrs) 282 : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType), 283 Attrs(Attrs) {} 284 285 PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM, 286 PointerOptions PO, uint8_t Size) 287 : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType), 288 Attrs(calcAttrs(PK, PM, PO, Size)) {} 289 290 PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM, 291 PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI) 292 : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType), 293 Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(MPI) {} 294 295 TypeIndex getReferentType() const { return ReferentType; } 296 297 PointerKind getPointerKind() const { 298 return static_cast<PointerKind>((Attrs >> PointerKindShift) & 299 PointerKindMask); 300 } 301 302 PointerMode getMode() const { 303 return static_cast<PointerMode>((Attrs >> PointerModeShift) & 304 PointerModeMask); 305 } 306 307 PointerOptions getOptions() const { 308 return static_cast<PointerOptions>(Attrs); 309 } 310 311 uint8_t getSize() const { 312 return (Attrs >> PointerSizeShift) & PointerSizeMask; 313 } 314 315 MemberPointerInfo getMemberInfo() const { return *MemberInfo; } 316 317 bool isPointerToMember() const { 318 return getMode() == PointerMode::PointerToDataMember || 319 getMode() == PointerMode::PointerToMemberFunction; 320 } 321 322 bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); } 323 bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); } 324 325 bool isVolatile() const { 326 return !!(Attrs & uint32_t(PointerOptions::Volatile)); 327 } 328 329 bool isUnaligned() const { 330 return !!(Attrs & uint32_t(PointerOptions::Unaligned)); 331 } 332 333 bool isRestrict() const { 334 return !!(Attrs & uint32_t(PointerOptions::Restrict)); 335 } 336 337 TypeIndex ReferentType; 338 uint32_t Attrs; 339 Optional<MemberPointerInfo> MemberInfo; 340 341 void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO, 342 uint8_t Size) { 343 Attrs = calcAttrs(PK, PM, PO, Size); 344 } 345 346 private: 347 static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO, 348 uint8_t Size) { 349 uint32_t A = 0; 350 A |= static_cast<uint32_t>(PK); 351 A |= static_cast<uint32_t>(PO); 352 A |= (static_cast<uint32_t>(PM) << PointerModeShift); 353 A |= (static_cast<uint32_t>(Size) << PointerSizeShift); 354 return A; 355 } 356 }; 357 358 // LF_NESTTYPE 359 class NestedTypeRecord : public TypeRecord { 360 public: 361 NestedTypeRecord() = default; 362 explicit NestedTypeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 363 NestedTypeRecord(TypeIndex Type, StringRef Name) 364 : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {} 365 366 TypeIndex getNestedType() const { return Type; } 367 StringRef getName() const { return Name; } 368 369 TypeIndex Type; 370 StringRef Name; 371 }; 372 373 // LF_FIELDLIST 374 class FieldListRecord : public TypeRecord { 375 public: 376 FieldListRecord() = default; 377 explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 378 explicit FieldListRecord(ArrayRef<uint8_t> Data) 379 : TypeRecord(TypeRecordKind::FieldList), Data(Data) {} 380 381 ArrayRef<uint8_t> Data; 382 }; 383 384 // LF_ARRAY 385 class ArrayRecord : public TypeRecord { 386 public: 387 ArrayRecord() = default; 388 explicit ArrayRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 389 ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size, 390 StringRef Name) 391 : TypeRecord(TypeRecordKind::Array), ElementType(ElementType), 392 IndexType(IndexType), Size(Size), Name(Name) {} 393 394 TypeIndex getElementType() const { return ElementType; } 395 TypeIndex getIndexType() const { return IndexType; } 396 uint64_t getSize() const { return Size; } 397 StringRef getName() const { return Name; } 398 399 TypeIndex ElementType; 400 TypeIndex IndexType; 401 uint64_t Size; 402 StringRef Name; 403 }; 404 405 class TagRecord : public TypeRecord { 406 protected: 407 TagRecord() = default; 408 explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 409 TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options, 410 TypeIndex FieldList, StringRef Name, StringRef UniqueName) 411 : TypeRecord(Kind), MemberCount(MemberCount), Options(Options), 412 FieldList(FieldList), Name(Name), UniqueName(UniqueName) {} 413 414 public: 415 static const int HfaKindShift = 11; 416 static const int HfaKindMask = 0x1800; 417 static const int WinRTKindShift = 14; 418 static const int WinRTKindMask = 0xC000; 419 420 bool hasUniqueName() const { 421 return (Options & ClassOptions::HasUniqueName) != ClassOptions::None; 422 } 423 424 bool isNested() const { 425 return (Options & ClassOptions::Nested) != ClassOptions::None; 426 } 427 428 bool isForwardRef() const { 429 return (Options & ClassOptions::ForwardReference) != ClassOptions::None; 430 } 431 432 uint16_t getMemberCount() const { return MemberCount; } 433 ClassOptions getOptions() const { return Options; } 434 TypeIndex getFieldList() const { return FieldList; } 435 StringRef getName() const { return Name; } 436 StringRef getUniqueName() const { return UniqueName; } 437 438 uint16_t MemberCount; 439 ClassOptions Options; 440 TypeIndex FieldList; 441 StringRef Name; 442 StringRef UniqueName; 443 }; 444 445 // LF_CLASS, LF_STRUCTURE, LF_INTERFACE 446 class ClassRecord : public TagRecord { 447 public: 448 ClassRecord() = default; 449 explicit ClassRecord(TypeRecordKind Kind) : TagRecord(Kind) {} 450 ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options, 451 TypeIndex FieldList, TypeIndex DerivationList, 452 TypeIndex VTableShape, uint64_t Size, StringRef Name, 453 StringRef UniqueName) 454 : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName), 455 DerivationList(DerivationList), VTableShape(VTableShape), Size(Size) {} 456 457 HfaKind getHfa() const { 458 uint16_t Value = static_cast<uint16_t>(Options); 459 Value = (Value & HfaKindMask) >> HfaKindShift; 460 return static_cast<HfaKind>(Value); 461 } 462 463 WindowsRTClassKind getWinRTKind() const { 464 uint16_t Value = static_cast<uint16_t>(Options); 465 Value = (Value & WinRTKindMask) >> WinRTKindShift; 466 return static_cast<WindowsRTClassKind>(Value); 467 } 468 469 TypeIndex getDerivationList() const { return DerivationList; } 470 TypeIndex getVTableShape() const { return VTableShape; } 471 uint64_t getSize() const { return Size; } 472 473 TypeIndex DerivationList; 474 TypeIndex VTableShape; 475 uint64_t Size; 476 }; 477 478 // LF_UNION 479 struct UnionRecord : public TagRecord { 480 UnionRecord() = default; 481 explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {} 482 UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList, 483 uint64_t Size, StringRef Name, StringRef UniqueName) 484 : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name, 485 UniqueName), 486 Size(Size) {} 487 488 HfaKind getHfa() const { 489 uint16_t Value = static_cast<uint16_t>(Options); 490 Value = (Value & HfaKindMask) >> HfaKindShift; 491 return static_cast<HfaKind>(Value); 492 } 493 494 uint64_t getSize() const { return Size; } 495 496 uint64_t Size; 497 }; 498 499 // LF_ENUM 500 class EnumRecord : public TagRecord { 501 public: 502 EnumRecord() = default; 503 explicit EnumRecord(TypeRecordKind Kind) : TagRecord(Kind) {} 504 EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList, 505 StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType) 506 : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name, 507 UniqueName), 508 UnderlyingType(UnderlyingType) {} 509 510 TypeIndex getUnderlyingType() const { return UnderlyingType; } 511 512 TypeIndex UnderlyingType; 513 }; 514 515 // LF_BITFIELD 516 class BitFieldRecord : public TypeRecord { 517 public: 518 BitFieldRecord() = default; 519 explicit BitFieldRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 520 BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset) 521 : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize), 522 BitOffset(BitOffset) {} 523 524 TypeIndex getType() const { return Type; } 525 uint8_t getBitOffset() const { return BitOffset; } 526 uint8_t getBitSize() const { return BitSize; } 527 528 TypeIndex Type; 529 uint8_t BitSize; 530 uint8_t BitOffset; 531 }; 532 533 // LF_VTSHAPE 534 class VFTableShapeRecord : public TypeRecord { 535 public: 536 VFTableShapeRecord() = default; 537 explicit VFTableShapeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 538 explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots) 539 : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {} 540 explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots) 541 : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {} 542 543 ArrayRef<VFTableSlotKind> getSlots() const { 544 if (!SlotsRef.empty()) 545 return SlotsRef; 546 return Slots; 547 } 548 549 uint32_t getEntryCount() const { return getSlots().size(); } 550 551 ArrayRef<VFTableSlotKind> SlotsRef; 552 std::vector<VFTableSlotKind> Slots; 553 }; 554 555 // LF_TYPESERVER2 556 class TypeServer2Record : public TypeRecord { 557 public: 558 TypeServer2Record() = default; 559 explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {} 560 TypeServer2Record(StringRef GuidStr, uint32_t Age, StringRef Name) 561 : TypeRecord(TypeRecordKind::TypeServer2), Age(Age), Name(Name) { 562 assert(GuidStr.size() == 16 && "guid isn't 16 bytes"); 563 ::memcpy(Guid.Guid, GuidStr.data(), 16); 564 } 565 566 const GUID &getGuid() const { return Guid; } 567 uint32_t getAge() const { return Age; } 568 StringRef getName() const { return Name; } 569 570 GUID Guid; 571 uint32_t Age; 572 StringRef Name; 573 }; 574 575 // LF_STRING_ID 576 class StringIdRecord : public TypeRecord { 577 public: 578 StringIdRecord() = default; 579 explicit StringIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 580 StringIdRecord(TypeIndex Id, StringRef String) 581 : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {} 582 583 TypeIndex getId() const { return Id; } 584 StringRef getString() const { return String; } 585 586 TypeIndex Id; 587 StringRef String; 588 }; 589 590 // LF_FUNC_ID 591 class FuncIdRecord : public TypeRecord { 592 public: 593 FuncIdRecord() = default; 594 explicit FuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 595 FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name) 596 : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope), 597 FunctionType(FunctionType), Name(Name) {} 598 599 TypeIndex getParentScope() const { return ParentScope; } 600 TypeIndex getFunctionType() const { return FunctionType; } 601 StringRef getName() const { return Name; } 602 603 TypeIndex ParentScope; 604 TypeIndex FunctionType; 605 StringRef Name; 606 }; 607 608 // LF_UDT_SRC_LINE 609 class UdtSourceLineRecord : public TypeRecord { 610 public: 611 UdtSourceLineRecord() = default; 612 explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 613 UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber) 614 : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT), 615 SourceFile(SourceFile), LineNumber(LineNumber) {} 616 617 TypeIndex getUDT() const { return UDT; } 618 TypeIndex getSourceFile() const { return SourceFile; } 619 uint32_t getLineNumber() const { return LineNumber; } 620 621 TypeIndex UDT; 622 TypeIndex SourceFile; 623 uint32_t LineNumber; 624 }; 625 626 // LF_UDT_MOD_SRC_LINE 627 class UdtModSourceLineRecord : public TypeRecord { 628 public: 629 UdtModSourceLineRecord() = default; 630 explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 631 UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, 632 uint32_t LineNumber, uint16_t Module) 633 : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT), 634 SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {} 635 636 TypeIndex getUDT() const { return UDT; } 637 TypeIndex getSourceFile() const { return SourceFile; } 638 uint32_t getLineNumber() const { return LineNumber; } 639 uint16_t getModule() const { return Module; } 640 641 TypeIndex UDT; 642 TypeIndex SourceFile; 643 uint32_t LineNumber; 644 uint16_t Module; 645 }; 646 647 // LF_BUILDINFO 648 class BuildInfoRecord : public TypeRecord { 649 public: 650 BuildInfoRecord() = default; 651 explicit BuildInfoRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 652 BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices) 653 : TypeRecord(TypeRecordKind::BuildInfo), 654 ArgIndices(ArgIndices.begin(), ArgIndices.end()) {} 655 656 ArrayRef<TypeIndex> getArgs() const { return ArgIndices; } 657 658 SmallVector<TypeIndex, 4> ArgIndices; 659 }; 660 661 // LF_VFTABLE 662 class VFTableRecord : public TypeRecord { 663 public: 664 VFTableRecord() = default; 665 explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 666 VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable, 667 uint32_t VFPtrOffset, StringRef Name, 668 ArrayRef<StringRef> Methods) 669 : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass), 670 OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) { 671 MethodNames.push_back(Name); 672 MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.end()); 673 } 674 675 TypeIndex getCompleteClass() const { return CompleteClass; } 676 TypeIndex getOverriddenVTable() const { return OverriddenVFTable; } 677 uint32_t getVFPtrOffset() const { return VFPtrOffset; } 678 StringRef getName() const { return makeArrayRef(MethodNames).front(); } 679 680 ArrayRef<StringRef> getMethodNames() const { 681 return makeArrayRef(MethodNames).drop_front(); 682 } 683 684 TypeIndex CompleteClass; 685 TypeIndex OverriddenVFTable; 686 uint32_t VFPtrOffset; 687 std::vector<StringRef> MethodNames; 688 }; 689 690 // LF_ONEMETHOD 691 class OneMethodRecord : public TypeRecord { 692 public: 693 OneMethodRecord() = default; 694 explicit OneMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 695 OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset, 696 StringRef Name) 697 : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Attrs(Attrs), 698 VFTableOffset(VFTableOffset), Name(Name) {} 699 OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind MK, 700 MethodOptions Options, int32_t VFTableOffset, StringRef Name) 701 : TypeRecord(TypeRecordKind::OneMethod), Type(Type), 702 Attrs(Access, MK, Options), VFTableOffset(VFTableOffset), Name(Name) {} 703 704 TypeIndex getType() const { return Type; } 705 MethodKind getMethodKind() const { return Attrs.getMethodKind(); } 706 MethodOptions getOptions() const { return Attrs.getFlags(); } 707 MemberAccess getAccess() const { return Attrs.getAccess(); } 708 int32_t getVFTableOffset() const { return VFTableOffset; } 709 StringRef getName() const { return Name; } 710 711 bool isIntroducingVirtual() const { 712 return getMethodKind() == MethodKind::IntroducingVirtual || 713 getMethodKind() == MethodKind::PureIntroducingVirtual; 714 } 715 716 TypeIndex Type; 717 MemberAttributes Attrs; 718 int32_t VFTableOffset; 719 StringRef Name; 720 }; 721 722 // LF_METHODLIST 723 class MethodOverloadListRecord : public TypeRecord { 724 public: 725 MethodOverloadListRecord() = default; 726 explicit MethodOverloadListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 727 MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods) 728 : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {} 729 730 ArrayRef<OneMethodRecord> getMethods() const { return Methods; } 731 732 std::vector<OneMethodRecord> Methods; 733 }; 734 735 /// For method overload sets. LF_METHOD 736 class OverloadedMethodRecord : public TypeRecord { 737 public: 738 OverloadedMethodRecord() = default; 739 explicit OverloadedMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 740 OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList, 741 StringRef Name) 742 : TypeRecord(TypeRecordKind::OverloadedMethod), 743 NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {} 744 745 uint16_t getNumOverloads() const { return NumOverloads; } 746 TypeIndex getMethodList() const { return MethodList; } 747 StringRef getName() const { return Name; } 748 749 uint16_t NumOverloads; 750 TypeIndex MethodList; 751 StringRef Name; 752 }; 753 754 // LF_MEMBER 755 class DataMemberRecord : public TypeRecord { 756 public: 757 DataMemberRecord() = default; 758 explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 759 DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset, 760 StringRef Name) 761 : TypeRecord(TypeRecordKind::DataMember), Attrs(Attrs), Type(Type), 762 FieldOffset(Offset), Name(Name) {} 763 DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset, 764 StringRef Name) 765 : TypeRecord(TypeRecordKind::DataMember), Attrs(Access), Type(Type), 766 FieldOffset(Offset), Name(Name) {} 767 768 MemberAccess getAccess() const { return Attrs.getAccess(); } 769 TypeIndex getType() const { return Type; } 770 uint64_t getFieldOffset() const { return FieldOffset; } 771 StringRef getName() const { return Name; } 772 773 MemberAttributes Attrs; 774 TypeIndex Type; 775 uint64_t FieldOffset; 776 StringRef Name; 777 }; 778 779 // LF_STMEMBER 780 class StaticDataMemberRecord : public TypeRecord { 781 public: 782 StaticDataMemberRecord() = default; 783 explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 784 StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name) 785 : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type), 786 Name(Name) {} 787 StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name) 788 : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Access), Type(Type), 789 Name(Name) {} 790 791 MemberAccess getAccess() const { return Attrs.getAccess(); } 792 TypeIndex getType() const { return Type; } 793 StringRef getName() const { return Name; } 794 795 MemberAttributes Attrs; 796 TypeIndex Type; 797 StringRef Name; 798 }; 799 800 // LF_ENUMERATE 801 class EnumeratorRecord : public TypeRecord { 802 public: 803 EnumeratorRecord() = default; 804 explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 805 EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name) 806 : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs), 807 Value(std::move(Value)), Name(Name) {} 808 EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name) 809 : TypeRecord(TypeRecordKind::Enumerator), Attrs(Access), 810 Value(std::move(Value)), Name(Name) {} 811 812 MemberAccess getAccess() const { return Attrs.getAccess(); } 813 APSInt getValue() const { return Value; } 814 StringRef getName() const { return Name; } 815 816 MemberAttributes Attrs; 817 APSInt Value; 818 StringRef Name; 819 }; 820 821 // LF_VFUNCTAB 822 class VFPtrRecord : public TypeRecord { 823 public: 824 VFPtrRecord() = default; 825 explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 826 VFPtrRecord(TypeIndex Type) 827 : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {} 828 829 TypeIndex getType() const { return Type; } 830 831 TypeIndex Type; 832 }; 833 834 // LF_BCLASS, LF_BINTERFACE 835 class BaseClassRecord : public TypeRecord { 836 public: 837 BaseClassRecord() = default; 838 explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 839 BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset) 840 : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type), 841 Offset(Offset) {} 842 BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset) 843 : TypeRecord(TypeRecordKind::BaseClass), Attrs(Access), Type(Type), 844 Offset(Offset) {} 845 846 MemberAccess getAccess() const { return Attrs.getAccess(); } 847 TypeIndex getBaseType() const { return Type; } 848 uint64_t getBaseOffset() const { return Offset; } 849 850 MemberAttributes Attrs; 851 TypeIndex Type; 852 uint64_t Offset; 853 }; 854 855 // LF_VBCLASS, LF_IVBCLASS 856 class VirtualBaseClassRecord : public TypeRecord { 857 public: 858 VirtualBaseClassRecord() = default; 859 explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 860 VirtualBaseClassRecord(TypeRecordKind Kind, MemberAttributes Attrs, 861 TypeIndex BaseType, TypeIndex VBPtrType, 862 uint64_t Offset, uint64_t Index) 863 : TypeRecord(Kind), Attrs(Attrs), BaseType(BaseType), 864 VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {} 865 VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access, 866 TypeIndex BaseType, TypeIndex VBPtrType, 867 uint64_t Offset, uint64_t Index) 868 : TypeRecord(Kind), Attrs(Access), BaseType(BaseType), 869 VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {} 870 871 MemberAccess getAccess() const { return Attrs.getAccess(); } 872 TypeIndex getBaseType() const { return BaseType; } 873 TypeIndex getVBPtrType() const { return VBPtrType; } 874 uint64_t getVBPtrOffset() const { return VBPtrOffset; } 875 uint64_t getVTableIndex() const { return VTableIndex; } 876 877 MemberAttributes Attrs; 878 TypeIndex BaseType; 879 TypeIndex VBPtrType; 880 uint64_t VBPtrOffset; 881 uint64_t VTableIndex; 882 }; 883 884 /// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records 885 /// together. The first will end in an LF_INDEX record that points to the next. 886 class ListContinuationRecord : public TypeRecord { 887 public: 888 ListContinuationRecord() = default; 889 explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 890 ListContinuationRecord(TypeIndex ContinuationIndex) 891 : TypeRecord(TypeRecordKind::ListContinuation), 892 ContinuationIndex(ContinuationIndex) {} 893 894 TypeIndex getContinuationIndex() const { return ContinuationIndex; } 895 896 TypeIndex ContinuationIndex; 897 }; 898 899 // LF_PRECOMP 900 class PrecompRecord : public TypeRecord { 901 public: 902 PrecompRecord() = default; 903 explicit PrecompRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 904 905 uint32_t getStartTypeIndex() const { return StartTypeIndex; } 906 uint32_t getTypesCount() const { return TypesCount; } 907 uint32_t getSignature() const { return Signature; } 908 StringRef getPrecompFilePath() const { return PrecompFilePath; } 909 910 uint32_t StartTypeIndex; 911 uint32_t TypesCount; 912 uint32_t Signature; 913 StringRef PrecompFilePath; 914 }; 915 916 // LF_ENDPRECOMP 917 class EndPrecompRecord : public TypeRecord { 918 public: 919 EndPrecompRecord() = default; 920 explicit EndPrecompRecord(TypeRecordKind Kind) : TypeRecord(Kind) {} 921 922 uint32_t getSignature() const { return Signature; } 923 924 uint32_t Signature; 925 }; 926 } // end namespace codeview 927 } // end namespace llvm 928 929 #endif // LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H 930
