namespace llvm {
namespace codeview {
-/// Distinguishes individual records in .debug$T section or PDB type stream. The
-/// documentation and headers talk about this as the "leaf" type.
+/// Distinguishes individual records in .debug$T or .debug$P section or PDB type
+/// stream. The documentation and headers talk about this as the "leaf" type.
enum class TypeRecordKind : uint16_t {
#define TYPE_RECORD(lf_ename, value, name) name = value,
#include "CodeViewTypes.def"
TYPE_RECORD(LF_METHODLIST, 0x1206, MethodOverloadList)
+TYPE_RECORD(LF_PRECOMP, 0x1509, Precomp)
+TYPE_RECORD(LF_ENDPRECOMP, 0x0014, EndPrecomp)
// 16 bit type records.
CV_TYPE(LF_MODIFIER_16t, 0x0001)
CV_TYPE(LF_DIMARRAY_16t, 0x0011)
CV_TYPE(LF_VFTPATH_16t, 0x0012)
CV_TYPE(LF_PRECOMP_16t, 0x0013)
-CV_TYPE(LF_ENDPRECOMP, 0x0014)
CV_TYPE(LF_OEM_16t, 0x0015)
CV_TYPE(LF_TYPESERVER_ST, 0x0016)
CV_TYPE(LF_ST_MAX, 0x1500)
CV_TYPE(LF_TYPESERVER, 0x1501)
CV_TYPE(LF_DIMARRAY, 0x1508)
-CV_TYPE(LF_PRECOMP, 0x1509)
CV_TYPE(LF_ALIAS, 0x150a)
CV_TYPE(LF_DEFARG, 0x150b)
CV_TYPE(LF_FRIENDFCN, 0x150c)
-//===- TypeRecord.h ---------------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
-#define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
-
-#include "llvm/ADT/APSInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/iterator_range.h"
-#include "llvm/DebugInfo/CodeView/CVRecord.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/GUID.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/Support/BinaryStreamArray.h"
-#include "llvm/Support/Endian.h"
-#include <algorithm>
-#include <cstdint>
-#include <vector>
-
-namespace llvm {
-namespace codeview {
-
-using support::little32_t;
-using support::ulittle16_t;
-using support::ulittle32_t;
-
-using CVType = CVRecord<TypeLeafKind>;
-using RemappedType = RemappedRecord<TypeLeafKind>;
-
-struct CVMemberRecord {
- TypeLeafKind Kind;
- ArrayRef<uint8_t> Data;
-};
-using CVTypeArray = VarStreamArray<CVType>;
-using CVTypeRange = iterator_range<CVTypeArray::Iterator>;
-
-/// Equvalent to CV_fldattr_t in cvinfo.h.
-struct MemberAttributes {
- uint16_t Attrs = 0;
-
- enum {
- MethodKindShift = 2,
- };
-
- MemberAttributes() = default;
-
- explicit MemberAttributes(MemberAccess Access)
- : Attrs(static_cast<uint16_t>(Access)) {}
-
- MemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Flags) {
- Attrs = static_cast<uint16_t>(Access);
- Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift);
- Attrs |= static_cast<uint16_t>(Flags);
- }
-
- /// Get the access specifier. Valid for any kind of member.
- MemberAccess getAccess() const {
- return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
- }
-
- /// Indicates if a method is defined with friend, virtual, static, etc.
- MethodKind getMethodKind() const {
- return MethodKind(
- (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >>
- MethodKindShift);
- }
-
- /// Get the flags that are not included in access control or method
- /// properties.
- MethodOptions getFlags() const {
- return MethodOptions(
- unsigned(Attrs) &
- ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));
- }
-
- /// Is this method virtual.
- bool isVirtual() const {
- auto MP = getMethodKind();
- return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&
- MP != MethodKind::Static;
- }
-
- /// Does this member introduce a new virtual method.
- bool isIntroducedVirtual() const {
- auto MP = getMethodKind();
- return MP == MethodKind::IntroducingVirtual ||
- MP == MethodKind::PureIntroducingVirtual;
- }
-};
-
-// Does not correspond to any tag, this is the tail of an LF_POINTER record
-// if it represents a member pointer.
-class MemberPointerInfo {
-public:
- MemberPointerInfo() = default;
-
- MemberPointerInfo(TypeIndex ContainingType,
- PointerToMemberRepresentation Representation)
- : ContainingType(ContainingType), Representation(Representation) {}
-
- TypeIndex getContainingType() const { return ContainingType; }
- PointerToMemberRepresentation getRepresentation() const {
- return Representation;
- }
-
- TypeIndex ContainingType;
- PointerToMemberRepresentation Representation;
-};
-
-class TypeRecord {
-protected:
- TypeRecord() = default;
- explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
-
-public:
- TypeRecordKind getKind() const { return Kind; }
-
- TypeRecordKind Kind;
-};
-
-// LF_MODIFIER
-class ModifierRecord : public TypeRecord {
-public:
- ModifierRecord() = default;
- explicit ModifierRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)
- : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType),
- Modifiers(Modifiers) {}
-
- TypeIndex getModifiedType() const { return ModifiedType; }
- ModifierOptions getModifiers() const { return Modifiers; }
-
- TypeIndex ModifiedType;
- ModifierOptions Modifiers;
-};
-
-// LF_PROCEDURE
-class ProcedureRecord : public TypeRecord {
-public:
- ProcedureRecord() = default;
- explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,
- FunctionOptions Options, uint16_t ParameterCount,
- TypeIndex ArgumentList)
- : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType),
- CallConv(CallConv), Options(Options), ParameterCount(ParameterCount),
- ArgumentList(ArgumentList) {}
-
- TypeIndex getReturnType() const { return ReturnType; }
- CallingConvention getCallConv() const { return CallConv; }
- FunctionOptions getOptions() const { return Options; }
- uint16_t getParameterCount() const { return ParameterCount; }
- TypeIndex getArgumentList() const { return ArgumentList; }
-
- TypeIndex ReturnType;
- CallingConvention CallConv;
- FunctionOptions Options;
- uint16_t ParameterCount;
- TypeIndex ArgumentList;
-};
-
-// LF_MFUNCTION
-class MemberFunctionRecord : public TypeRecord {
-public:
- MemberFunctionRecord() = default;
- explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
- MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,
- TypeIndex ThisType, CallingConvention CallConv,
- FunctionOptions Options, uint16_t ParameterCount,
- TypeIndex ArgumentList, int32_t ThisPointerAdjustment)
- : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType),
- ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),
- Options(Options), ParameterCount(ParameterCount),
- ArgumentList(ArgumentList),
- ThisPointerAdjustment(ThisPointerAdjustment) {}
-
- TypeIndex getReturnType() const { return ReturnType; }
- TypeIndex getClassType() const { return ClassType; }
- TypeIndex getThisType() const { return ThisType; }
- CallingConvention getCallConv() const { return CallConv; }
- FunctionOptions getOptions() const { return Options; }
- uint16_t getParameterCount() const { return ParameterCount; }
- TypeIndex getArgumentList() const { return ArgumentList; }
- int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; }
-
- TypeIndex ReturnType;
- TypeIndex ClassType;
- TypeIndex ThisType;
- CallingConvention CallConv;
- FunctionOptions Options;
- uint16_t ParameterCount;
- TypeIndex ArgumentList;
- int32_t ThisPointerAdjustment;
-};
-
-// LF_LABEL
-class LabelRecord : public TypeRecord {
-public:
- LabelRecord() = default;
- explicit LabelRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
- LabelRecord(LabelType Mode) : TypeRecord(TypeRecordKind::Label), Mode(Mode) {}
-
- LabelType Mode;
-};
-
-// LF_MFUNC_ID
-class MemberFuncIdRecord : public TypeRecord {
-public:
- MemberFuncIdRecord() = default;
- explicit MemberFuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,
- StringRef Name)
- : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),
- FunctionType(FunctionType), Name(Name) {}
-
- TypeIndex getClassType() const { return ClassType; }
- TypeIndex getFunctionType() const { return FunctionType; }
- StringRef getName() const { return Name; }
-
- TypeIndex ClassType;
- TypeIndex FunctionType;
- StringRef Name;
-};
-
-// LF_ARGLIST
-class ArgListRecord : public TypeRecord {
-public:
- ArgListRecord() = default;
- explicit ArgListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
- ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
- : TypeRecord(Kind), ArgIndices(Indices) {}
-
- ArrayRef<TypeIndex> getIndices() const { return ArgIndices; }
-
- std::vector<TypeIndex> ArgIndices;
-};
-
-// LF_SUBSTR_LIST
-class StringListRecord : public TypeRecord {
-public:
- StringListRecord() = default;
- explicit StringListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
- StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)
- : TypeRecord(Kind), StringIndices(Indices) {}
-
- ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
-
- std::vector<TypeIndex> StringIndices;
-};
-
-// LF_POINTER
-class PointerRecord : public TypeRecord {
-public:
- static const uint32_t PointerKindShift = 0;
- static const uint32_t PointerKindMask = 0x1F;
-
- static const uint32_t PointerModeShift = 5;
- static const uint32_t PointerModeMask = 0x07;
-
- static const uint32_t PointerOptionMask = 0xFF;
-
- static const uint32_t PointerSizeShift = 13;
- static const uint32_t PointerSizeMask = 0xFF;
-
- PointerRecord() = default;
- explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
-
- PointerRecord(TypeIndex ReferentType, uint32_t Attrs)
- : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
- Attrs(Attrs) {}
-
- PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
- PointerOptions PO, uint8_t Size)
- : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
- Attrs(calcAttrs(PK, PM, PO, Size)) {}
-
- PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
- PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI)
- : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
- Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(MPI) {}
-
- TypeIndex getReferentType() const { return ReferentType; }
-
- PointerKind getPointerKind() const {
- return static_cast<PointerKind>((Attrs >> PointerKindShift) &
- PointerKindMask);
- }
-
- PointerMode getMode() const {
- return static_cast<PointerMode>((Attrs >> PointerModeShift) &
- PointerModeMask);
- }
-
- PointerOptions getOptions() const {
- return static_cast<PointerOptions>(Attrs);
- }
-
- uint8_t getSize() const {
- return (Attrs >> PointerSizeShift) & PointerSizeMask;
- }
-
- MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
-
- bool isPointerToMember() const {
- return getMode() == PointerMode::PointerToDataMember ||
- getMode() == PointerMode::PointerToMemberFunction;
- }
-
- bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }
- bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }
-
- bool isVolatile() const {
- return !!(Attrs & uint32_t(PointerOptions::Volatile));
- }
-
- bool isUnaligned() const {
- return !!(Attrs & uint32_t(PointerOptions::Unaligned));
- }
-
- bool isRestrict() const {
- return !!(Attrs & uint32_t(PointerOptions::Restrict));
- }
-
- TypeIndex ReferentType;
- uint32_t Attrs;
- Optional<MemberPointerInfo> MemberInfo;
-
- void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
- uint8_t Size) {
- Attrs = calcAttrs(PK, PM, PO, Size);
- }
-
-private:
- static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
- uint8_t Size) {
- uint32_t A = 0;
- A |= static_cast<uint32_t>(PK);
- A |= static_cast<uint32_t>(PO);
- A |= (static_cast<uint32_t>(PM) << PointerModeShift);
- A |= (static_cast<uint32_t>(Size) << PointerSizeShift);
- return A;
- }
-};
-
-// LF_NESTTYPE
-class NestedTypeRecord : public TypeRecord {
-public:
- NestedTypeRecord() = default;
- explicit NestedTypeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- NestedTypeRecord(TypeIndex Type, StringRef Name)
- : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}
-
- TypeIndex getNestedType() const { return Type; }
- StringRef getName() const { return Name; }
-
- TypeIndex Type;
- StringRef Name;
-};
-
-// LF_FIELDLIST
-class FieldListRecord : public TypeRecord {
-public:
- FieldListRecord() = default;
- explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- explicit FieldListRecord(ArrayRef<uint8_t> Data)
- : TypeRecord(TypeRecordKind::FieldList), Data(Data) {}
-
- ArrayRef<uint8_t> Data;
-};
-
-// LF_ARRAY
-class ArrayRecord : public TypeRecord {
-public:
- ArrayRecord() = default;
- explicit ArrayRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,
- StringRef Name)
- : TypeRecord(TypeRecordKind::Array), ElementType(ElementType),
- IndexType(IndexType), Size(Size), Name(Name) {}
-
- TypeIndex getElementType() const { return ElementType; }
- TypeIndex getIndexType() const { return IndexType; }
- uint64_t getSize() const { return Size; }
- StringRef getName() const { return Name; }
-
- TypeIndex ElementType;
- TypeIndex IndexType;
- uint64_t Size;
- StringRef Name;
-};
-
-class TagRecord : public TypeRecord {
-protected:
- TagRecord() = default;
- explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
- TypeIndex FieldList, StringRef Name, StringRef UniqueName)
- : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),
- FieldList(FieldList), Name(Name), UniqueName(UniqueName) {}
-
-public:
- static const int HfaKindShift = 11;
- static const int HfaKindMask = 0x1800;
- static const int WinRTKindShift = 14;
- static const int WinRTKindMask = 0xC000;
-
- bool hasUniqueName() const {
- return (Options & ClassOptions::HasUniqueName) != ClassOptions::None;
- }
-
- bool isNested() const {
- return (Options & ClassOptions::Nested) != ClassOptions::None;
- }
-
- bool isForwardRef() const {
- return (Options & ClassOptions::ForwardReference) != ClassOptions::None;
- }
-
- uint16_t getMemberCount() const { return MemberCount; }
- ClassOptions getOptions() const { return Options; }
- TypeIndex getFieldList() const { return FieldList; }
- StringRef getName() const { return Name; }
- StringRef getUniqueName() const { return UniqueName; }
-
- uint16_t MemberCount;
- ClassOptions Options;
- TypeIndex FieldList;
- StringRef Name;
- StringRef UniqueName;
-};
-
-// LF_CLASS, LF_STRUCTURE, LF_INTERFACE
-class ClassRecord : public TagRecord {
-public:
- ClassRecord() = default;
- explicit ClassRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
- ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,
- TypeIndex FieldList, TypeIndex DerivationList,
- TypeIndex VTableShape, uint64_t Size, StringRef Name,
- StringRef UniqueName)
- : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName),
- DerivationList(DerivationList), VTableShape(VTableShape), Size(Size) {}
-
- HfaKind getHfa() const {
- uint16_t Value = static_cast<uint16_t>(Options);
- Value = (Value & HfaKindMask) >> HfaKindShift;
- return static_cast<HfaKind>(Value);
- }
-
- WindowsRTClassKind getWinRTKind() const {
- uint16_t Value = static_cast<uint16_t>(Options);
- Value = (Value & WinRTKindMask) >> WinRTKindShift;
- return static_cast<WindowsRTClassKind>(Value);
- }
-
- TypeIndex getDerivationList() const { return DerivationList; }
- TypeIndex getVTableShape() const { return VTableShape; }
- uint64_t getSize() const { return Size; }
-
- TypeIndex DerivationList;
- TypeIndex VTableShape;
- uint64_t Size;
-};
-
-// LF_UNION
-struct UnionRecord : public TagRecord {
- UnionRecord() = default;
- explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
- UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
- uint64_t Size, StringRef Name, StringRef UniqueName)
- : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,
- UniqueName),
- Size(Size) {}
-
- HfaKind getHfa() const {
- uint16_t Value = static_cast<uint16_t>(Options);
- Value = (Value & HfaKindMask) >> HfaKindShift;
- return static_cast<HfaKind>(Value);
- }
-
- uint64_t getSize() const { return Size; }
-
- uint64_t Size;
-};
-
-// LF_ENUM
-class EnumRecord : public TagRecord {
-public:
- EnumRecord() = default;
- explicit EnumRecord(TypeRecordKind Kind) : TagRecord(Kind) {}
- EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,
- StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)
- : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,
- UniqueName),
- UnderlyingType(UnderlyingType) {}
-
- TypeIndex getUnderlyingType() const { return UnderlyingType; }
-
- TypeIndex UnderlyingType;
-};
-
-// LF_BITFIELD
-class BitFieldRecord : public TypeRecord {
-public:
- BitFieldRecord() = default;
- explicit BitFieldRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)
- : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize),
- BitOffset(BitOffset) {}
-
- TypeIndex getType() const { return Type; }
- uint8_t getBitOffset() const { return BitOffset; }
- uint8_t getBitSize() const { return BitSize; }
-
- TypeIndex Type;
- uint8_t BitSize;
- uint8_t BitOffset;
-};
-
-// LF_VTSHAPE
-class VFTableShapeRecord : public TypeRecord {
-public:
- VFTableShapeRecord() = default;
- explicit VFTableShapeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)
- : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}
- explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)
- : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}
-
- ArrayRef<VFTableSlotKind> getSlots() const {
- if (!SlotsRef.empty())
- return SlotsRef;
- return Slots;
- }
-
- uint32_t getEntryCount() const { return getSlots().size(); }
-
- ArrayRef<VFTableSlotKind> SlotsRef;
- std::vector<VFTableSlotKind> Slots;
-};
-
-// LF_TYPESERVER2
-class TypeServer2Record : public TypeRecord {
-public:
- TypeServer2Record() = default;
- explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}
- TypeServer2Record(StringRef GuidStr, uint32_t Age, StringRef Name)
- : TypeRecord(TypeRecordKind::TypeServer2), Age(Age), Name(Name) {
- assert(GuidStr.size() == 16 && "guid isn't 16 bytes");
- ::memcpy(Guid.Guid, GuidStr.data(), 16);
- }
-
- const GUID &getGuid() const { return Guid; }
- uint32_t getAge() const { return Age; }
- StringRef getName() const { return Name; }
-
- GUID Guid;
- uint32_t Age;
- StringRef Name;
-};
-
-// LF_STRING_ID
-class StringIdRecord : public TypeRecord {
-public:
- StringIdRecord() = default;
- explicit StringIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- StringIdRecord(TypeIndex Id, StringRef String)
- : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}
-
- TypeIndex getId() const { return Id; }
- StringRef getString() const { return String; }
-
- TypeIndex Id;
- StringRef String;
-};
-
-// LF_FUNC_ID
-class FuncIdRecord : public TypeRecord {
-public:
- FuncIdRecord() = default;
- explicit FuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)
- : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),
- FunctionType(FunctionType), Name(Name) {}
-
- TypeIndex getParentScope() const { return ParentScope; }
- TypeIndex getFunctionType() const { return FunctionType; }
- StringRef getName() const { return Name; }
-
- TypeIndex ParentScope;
- TypeIndex FunctionType;
- StringRef Name;
-};
-
-// LF_UDT_SRC_LINE
-class UdtSourceLineRecord : public TypeRecord {
-public:
- UdtSourceLineRecord() = default;
- explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)
- : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
- SourceFile(SourceFile), LineNumber(LineNumber) {}
-
- TypeIndex getUDT() const { return UDT; }
- TypeIndex getSourceFile() const { return SourceFile; }
- uint32_t getLineNumber() const { return LineNumber; }
-
- TypeIndex UDT;
- TypeIndex SourceFile;
- uint32_t LineNumber;
-};
-
-// LF_UDT_MOD_SRC_LINE
-class UdtModSourceLineRecord : public TypeRecord {
-public:
- UdtModSourceLineRecord() = default;
- explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,
- uint32_t LineNumber, uint16_t Module)
- : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),
- SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {}
-
- TypeIndex getUDT() const { return UDT; }
- TypeIndex getSourceFile() const { return SourceFile; }
- uint32_t getLineNumber() const { return LineNumber; }
- uint16_t getModule() const { return Module; }
-
- TypeIndex UDT;
- TypeIndex SourceFile;
- uint32_t LineNumber;
- uint16_t Module;
-};
-
-// LF_BUILDINFO
-class BuildInfoRecord : public TypeRecord {
-public:
- BuildInfoRecord() = default;
- explicit BuildInfoRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)
- : TypeRecord(TypeRecordKind::BuildInfo),
- ArgIndices(ArgIndices.begin(), ArgIndices.end()) {}
-
- ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }
-
- SmallVector<TypeIndex, 4> ArgIndices;
-};
-
-// LF_VFTABLE
-class VFTableRecord : public TypeRecord {
-public:
- VFTableRecord() = default;
- explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,
- uint32_t VFPtrOffset, StringRef Name,
- ArrayRef<StringRef> Methods)
- : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass),
- OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) {
- MethodNames.push_back(Name);
- MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.end());
- }
-
- TypeIndex getCompleteClass() const { return CompleteClass; }
- TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }
- uint32_t getVFPtrOffset() const { return VFPtrOffset; }
- StringRef getName() const { return makeArrayRef(MethodNames).front(); }
-
- ArrayRef<StringRef> getMethodNames() const {
- return makeArrayRef(MethodNames).drop_front();
- }
-
- TypeIndex CompleteClass;
- TypeIndex OverriddenVFTable;
- uint32_t VFPtrOffset;
- std::vector<StringRef> MethodNames;
-};
-
-// LF_ONEMETHOD
-class OneMethodRecord : public TypeRecord {
-public:
- OneMethodRecord() = default;
- explicit OneMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,
- StringRef Name)
- : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Attrs(Attrs),
- VFTableOffset(VFTableOffset), Name(Name) {}
- OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind MK,
- MethodOptions Options, int32_t VFTableOffset, StringRef Name)
- : TypeRecord(TypeRecordKind::OneMethod), Type(Type),
- Attrs(Access, MK, Options), VFTableOffset(VFTableOffset), Name(Name) {}
-
- TypeIndex getType() const { return Type; }
- MethodKind getMethodKind() const { return Attrs.getMethodKind(); }
- MethodOptions getOptions() const { return Attrs.getFlags(); }
- MemberAccess getAccess() const { return Attrs.getAccess(); }
- int32_t getVFTableOffset() const { return VFTableOffset; }
- StringRef getName() const { return Name; }
-
- bool isIntroducingVirtual() const {
- return getMethodKind() == MethodKind::IntroducingVirtual ||
- getMethodKind() == MethodKind::PureIntroducingVirtual;
- }
-
- TypeIndex Type;
- MemberAttributes Attrs;
- int32_t VFTableOffset;
- StringRef Name;
-};
-
-// LF_METHODLIST
-class MethodOverloadListRecord : public TypeRecord {
-public:
- MethodOverloadListRecord() = default;
- explicit MethodOverloadListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)
- : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}
-
- ArrayRef<OneMethodRecord> getMethods() const { return Methods; }
-
- std::vector<OneMethodRecord> Methods;
-};
-
-/// For method overload sets. LF_METHOD
-class OverloadedMethodRecord : public TypeRecord {
-public:
- OverloadedMethodRecord() = default;
- explicit OverloadedMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,
- StringRef Name)
- : TypeRecord(TypeRecordKind::OverloadedMethod),
- NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}
-
- uint16_t getNumOverloads() const { return NumOverloads; }
- TypeIndex getMethodList() const { return MethodList; }
- StringRef getName() const { return Name; }
-
- uint16_t NumOverloads;
- TypeIndex MethodList;
- StringRef Name;
-};
-
-// LF_MEMBER
-class DataMemberRecord : public TypeRecord {
-public:
- DataMemberRecord() = default;
- explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset,
- StringRef Name)
- : TypeRecord(TypeRecordKind::DataMember), Attrs(Attrs), Type(Type),
- FieldOffset(Offset), Name(Name) {}
- DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,
- StringRef Name)
- : TypeRecord(TypeRecordKind::DataMember), Attrs(Access), Type(Type),
- FieldOffset(Offset), Name(Name) {}
-
- MemberAccess getAccess() const { return Attrs.getAccess(); }
- TypeIndex getType() const { return Type; }
- uint64_t getFieldOffset() const { return FieldOffset; }
- StringRef getName() const { return Name; }
-
- MemberAttributes Attrs;
- TypeIndex Type;
- uint64_t FieldOffset;
- StringRef Name;
-};
-
-// LF_STMEMBER
-class StaticDataMemberRecord : public TypeRecord {
-public:
- StaticDataMemberRecord() = default;
- explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)
- : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type),
- Name(Name) {}
- StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)
- : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Access), Type(Type),
- Name(Name) {}
-
- MemberAccess getAccess() const { return Attrs.getAccess(); }
- TypeIndex getType() const { return Type; }
- StringRef getName() const { return Name; }
-
- MemberAttributes Attrs;
- TypeIndex Type;
- StringRef Name;
-};
-
-// LF_ENUMERATE
-class EnumeratorRecord : public TypeRecord {
-public:
- EnumeratorRecord() = default;
- explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name)
- : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs),
- Value(std::move(Value)), Name(Name) {}
- EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)
- : TypeRecord(TypeRecordKind::Enumerator), Attrs(Access),
- Value(std::move(Value)), Name(Name) {}
-
- MemberAccess getAccess() const { return Attrs.getAccess(); }
- APSInt getValue() const { return Value; }
- StringRef getName() const { return Name; }
-
- MemberAttributes Attrs;
- APSInt Value;
- StringRef Name;
-};
-
-// LF_VFUNCTAB
-class VFPtrRecord : public TypeRecord {
-public:
- VFPtrRecord() = default;
- explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- VFPtrRecord(TypeIndex Type)
- : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}
-
- TypeIndex getType() const { return Type; }
-
- TypeIndex Type;
-};
-
-// LF_BCLASS, LF_BINTERFACE
-class BaseClassRecord : public TypeRecord {
-public:
- BaseClassRecord() = default;
- explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)
- : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type),
- Offset(Offset) {}
- BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)
- : TypeRecord(TypeRecordKind::BaseClass), Attrs(Access), Type(Type),
- Offset(Offset) {}
-
- MemberAccess getAccess() const { return Attrs.getAccess(); }
- TypeIndex getBaseType() const { return Type; }
- uint64_t getBaseOffset() const { return Offset; }
-
- MemberAttributes Attrs;
- TypeIndex Type;
- uint64_t Offset;
-};
-
-// LF_VBCLASS, LF_IVBCLASS
-class VirtualBaseClassRecord : public TypeRecord {
-public:
- VirtualBaseClassRecord() = default;
- explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- VirtualBaseClassRecord(TypeRecordKind Kind, MemberAttributes Attrs,
- TypeIndex BaseType, TypeIndex VBPtrType,
- uint64_t Offset, uint64_t Index)
- : TypeRecord(Kind), Attrs(Attrs), BaseType(BaseType),
- VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
- VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access,
- TypeIndex BaseType, TypeIndex VBPtrType,
- uint64_t Offset, uint64_t Index)
- : TypeRecord(Kind), Attrs(Access), BaseType(BaseType),
- VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}
-
- MemberAccess getAccess() const { return Attrs.getAccess(); }
- TypeIndex getBaseType() const { return BaseType; }
- TypeIndex getVBPtrType() const { return VBPtrType; }
- uint64_t getVBPtrOffset() const { return VBPtrOffset; }
- uint64_t getVTableIndex() const { return VTableIndex; }
-
- MemberAttributes Attrs;
- TypeIndex BaseType;
- TypeIndex VBPtrType;
- uint64_t VBPtrOffset;
- uint64_t VTableIndex;
-};
-
-/// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records
-/// together. The first will end in an LF_INDEX record that points to the next.
-class ListContinuationRecord : public TypeRecord {
-public:
- ListContinuationRecord() = default;
- explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
- ListContinuationRecord(TypeIndex ContinuationIndex)
- : TypeRecord(TypeRecordKind::ListContinuation),
- ContinuationIndex(ContinuationIndex) {}
-
- TypeIndex getContinuationIndex() const { return ContinuationIndex; }
-
- TypeIndex ContinuationIndex;
-};
-
-} // end namespace codeview
-} // end namespace llvm
-
-#endif // LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H
+//===- TypeRecord.h ---------------------------------------------*- C++ -*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H\r
+#define LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H\r
+\r
+#include "llvm/ADT/APSInt.h"\r
+#include "llvm/ADT/ArrayRef.h"\r
+#include "llvm/ADT/Optional.h"\r
+#include "llvm/ADT/SmallVector.h"\r
+#include "llvm/ADT/StringRef.h"\r
+#include "llvm/ADT/iterator_range.h"\r
+#include "llvm/DebugInfo/CodeView/CVRecord.h"\r
+#include "llvm/DebugInfo/CodeView/CodeView.h"\r
+#include "llvm/DebugInfo/CodeView/GUID.h"\r
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"\r
+#include "llvm/Support/BinaryStreamArray.h"\r
+#include "llvm/Support/Endian.h"\r
+#include <algorithm>\r
+#include <cstdint>\r
+#include <vector>\r
+\r
+namespace llvm {\r
+namespace codeview {\r
+\r
+using support::little32_t;\r
+using support::ulittle16_t;\r
+using support::ulittle32_t;\r
+\r
+using CVType = CVRecord<TypeLeafKind>;\r
+using RemappedType = RemappedRecord<TypeLeafKind>;\r
+\r
+struct CVMemberRecord {\r
+ TypeLeafKind Kind;\r
+ ArrayRef<uint8_t> Data;\r
+};\r
+using CVTypeArray = VarStreamArray<CVType>;\r
+using CVTypeRange = iterator_range<CVTypeArray::Iterator>;\r
+\r
+/// Equvalent to CV_fldattr_t in cvinfo.h.\r
+struct MemberAttributes {\r
+ uint16_t Attrs = 0;\r
+\r
+ enum {\r
+ MethodKindShift = 2,\r
+ };\r
+\r
+ MemberAttributes() = default;\r
+\r
+ explicit MemberAttributes(MemberAccess Access)\r
+ : Attrs(static_cast<uint16_t>(Access)) {}\r
+\r
+ MemberAttributes(MemberAccess Access, MethodKind Kind, MethodOptions Flags) {\r
+ Attrs = static_cast<uint16_t>(Access);\r
+ Attrs |= (static_cast<uint16_t>(Kind) << MethodKindShift);\r
+ Attrs |= static_cast<uint16_t>(Flags);\r
+ }\r
+\r
+ /// Get the access specifier. Valid for any kind of member.\r
+ MemberAccess getAccess() const {\r
+ return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));\r
+ }\r
+\r
+ /// Indicates if a method is defined with friend, virtual, static, etc.\r
+ MethodKind getMethodKind() const {\r
+ return MethodKind(\r
+ (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >>\r
+ MethodKindShift);\r
+ }\r
+\r
+ /// Get the flags that are not included in access control or method\r
+ /// properties.\r
+ MethodOptions getFlags() const {\r
+ return MethodOptions(\r
+ unsigned(Attrs) &\r
+ ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));\r
+ }\r
+\r
+ /// Is this method virtual.\r
+ bool isVirtual() const {\r
+ auto MP = getMethodKind();\r
+ return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&\r
+ MP != MethodKind::Static;\r
+ }\r
+\r
+ /// Does this member introduce a new virtual method.\r
+ bool isIntroducedVirtual() const {\r
+ auto MP = getMethodKind();\r
+ return MP == MethodKind::IntroducingVirtual ||\r
+ MP == MethodKind::PureIntroducingVirtual;\r
+ }\r
+};\r
+\r
+// Does not correspond to any tag, this is the tail of an LF_POINTER record\r
+// if it represents a member pointer.\r
+class MemberPointerInfo {\r
+public:\r
+ MemberPointerInfo() = default;\r
+\r
+ MemberPointerInfo(TypeIndex ContainingType,\r
+ PointerToMemberRepresentation Representation)\r
+ : ContainingType(ContainingType), Representation(Representation) {}\r
+\r
+ TypeIndex getContainingType() const { return ContainingType; }\r
+ PointerToMemberRepresentation getRepresentation() const {\r
+ return Representation;\r
+ }\r
+\r
+ TypeIndex ContainingType;\r
+ PointerToMemberRepresentation Representation;\r
+};\r
+\r
+class TypeRecord {\r
+protected:\r
+ TypeRecord() = default;\r
+ explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}\r
+\r
+public:\r
+ TypeRecordKind getKind() const { return Kind; }\r
+\r
+ TypeRecordKind Kind;\r
+};\r
+\r
+// LF_MODIFIER\r
+class ModifierRecord : public TypeRecord {\r
+public:\r
+ ModifierRecord() = default;\r
+ explicit ModifierRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ ModifierRecord(TypeIndex ModifiedType, ModifierOptions Modifiers)\r
+ : TypeRecord(TypeRecordKind::Modifier), ModifiedType(ModifiedType),\r
+ Modifiers(Modifiers) {}\r
+\r
+ TypeIndex getModifiedType() const { return ModifiedType; }\r
+ ModifierOptions getModifiers() const { return Modifiers; }\r
+\r
+ TypeIndex ModifiedType;\r
+ ModifierOptions Modifiers;\r
+};\r
+\r
+// LF_PROCEDURE\r
+class ProcedureRecord : public TypeRecord {\r
+public:\r
+ ProcedureRecord() = default;\r
+ explicit ProcedureRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ ProcedureRecord(TypeIndex ReturnType, CallingConvention CallConv,\r
+ FunctionOptions Options, uint16_t ParameterCount,\r
+ TypeIndex ArgumentList)\r
+ : TypeRecord(TypeRecordKind::Procedure), ReturnType(ReturnType),\r
+ CallConv(CallConv), Options(Options), ParameterCount(ParameterCount),\r
+ ArgumentList(ArgumentList) {}\r
+\r
+ TypeIndex getReturnType() const { return ReturnType; }\r
+ CallingConvention getCallConv() const { return CallConv; }\r
+ FunctionOptions getOptions() const { return Options; }\r
+ uint16_t getParameterCount() const { return ParameterCount; }\r
+ TypeIndex getArgumentList() const { return ArgumentList; }\r
+\r
+ TypeIndex ReturnType;\r
+ CallingConvention CallConv;\r
+ FunctionOptions Options;\r
+ uint16_t ParameterCount;\r
+ TypeIndex ArgumentList;\r
+};\r
+\r
+// LF_MFUNCTION\r
+class MemberFunctionRecord : public TypeRecord {\r
+public:\r
+ MemberFunctionRecord() = default;\r
+ explicit MemberFunctionRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ MemberFunctionRecord(TypeIndex ReturnType, TypeIndex ClassType,\r
+ TypeIndex ThisType, CallingConvention CallConv,\r
+ FunctionOptions Options, uint16_t ParameterCount,\r
+ TypeIndex ArgumentList, int32_t ThisPointerAdjustment)\r
+ : TypeRecord(TypeRecordKind::MemberFunction), ReturnType(ReturnType),\r
+ ClassType(ClassType), ThisType(ThisType), CallConv(CallConv),\r
+ Options(Options), ParameterCount(ParameterCount),\r
+ ArgumentList(ArgumentList),\r
+ ThisPointerAdjustment(ThisPointerAdjustment) {}\r
+\r
+ TypeIndex getReturnType() const { return ReturnType; }\r
+ TypeIndex getClassType() const { return ClassType; }\r
+ TypeIndex getThisType() const { return ThisType; }\r
+ CallingConvention getCallConv() const { return CallConv; }\r
+ FunctionOptions getOptions() const { return Options; }\r
+ uint16_t getParameterCount() const { return ParameterCount; }\r
+ TypeIndex getArgumentList() const { return ArgumentList; }\r
+ int32_t getThisPointerAdjustment() const { return ThisPointerAdjustment; }\r
+\r
+ TypeIndex ReturnType;\r
+ TypeIndex ClassType;\r
+ TypeIndex ThisType;\r
+ CallingConvention CallConv;\r
+ FunctionOptions Options;\r
+ uint16_t ParameterCount;\r
+ TypeIndex ArgumentList;\r
+ int32_t ThisPointerAdjustment;\r
+};\r
+\r
+// LF_LABEL\r
+class LabelRecord : public TypeRecord {\r
+public:\r
+ LabelRecord() = default;\r
+ explicit LabelRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ LabelRecord(LabelType Mode) : TypeRecord(TypeRecordKind::Label), Mode(Mode) {}\r
+\r
+ LabelType Mode;\r
+};\r
+\r
+// LF_MFUNC_ID\r
+class MemberFuncIdRecord : public TypeRecord {\r
+public:\r
+ MemberFuncIdRecord() = default;\r
+ explicit MemberFuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ MemberFuncIdRecord(TypeIndex ClassType, TypeIndex FunctionType,\r
+ StringRef Name)\r
+ : TypeRecord(TypeRecordKind::MemberFuncId), ClassType(ClassType),\r
+ FunctionType(FunctionType), Name(Name) {}\r
+\r
+ TypeIndex getClassType() const { return ClassType; }\r
+ TypeIndex getFunctionType() const { return FunctionType; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ TypeIndex ClassType;\r
+ TypeIndex FunctionType;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_ARGLIST\r
+class ArgListRecord : public TypeRecord {\r
+public:\r
+ ArgListRecord() = default;\r
+ explicit ArgListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ ArgListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)\r
+ : TypeRecord(Kind), ArgIndices(Indices) {}\r
+\r
+ ArrayRef<TypeIndex> getIndices() const { return ArgIndices; }\r
+\r
+ std::vector<TypeIndex> ArgIndices;\r
+};\r
+\r
+// LF_SUBSTR_LIST\r
+class StringListRecord : public TypeRecord {\r
+public:\r
+ StringListRecord() = default;\r
+ explicit StringListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ StringListRecord(TypeRecordKind Kind, ArrayRef<TypeIndex> Indices)\r
+ : TypeRecord(Kind), StringIndices(Indices) {}\r
+\r
+ ArrayRef<TypeIndex> getIndices() const { return StringIndices; }\r
+\r
+ std::vector<TypeIndex> StringIndices;\r
+};\r
+\r
+// LF_POINTER\r
+class PointerRecord : public TypeRecord {\r
+public:\r
+ static const uint32_t PointerKindShift = 0;\r
+ static const uint32_t PointerKindMask = 0x1F;\r
+\r
+ static const uint32_t PointerModeShift = 5;\r
+ static const uint32_t PointerModeMask = 0x07;\r
+\r
+ static const uint32_t PointerOptionMask = 0xFF;\r
+\r
+ static const uint32_t PointerSizeShift = 13;\r
+ static const uint32_t PointerSizeMask = 0xFF;\r
+\r
+ PointerRecord() = default;\r
+ explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ PointerRecord(TypeIndex ReferentType, uint32_t Attrs)\r
+ : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),\r
+ Attrs(Attrs) {}\r
+\r
+ PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,\r
+ PointerOptions PO, uint8_t Size)\r
+ : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),\r
+ Attrs(calcAttrs(PK, PM, PO, Size)) {}\r
+\r
+ PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,\r
+ PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI)\r
+ : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),\r
+ Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(MPI) {}\r
+\r
+ TypeIndex getReferentType() const { return ReferentType; }\r
+\r
+ PointerKind getPointerKind() const {\r
+ return static_cast<PointerKind>((Attrs >> PointerKindShift) &\r
+ PointerKindMask);\r
+ }\r
+\r
+ PointerMode getMode() const {\r
+ return static_cast<PointerMode>((Attrs >> PointerModeShift) &\r
+ PointerModeMask);\r
+ }\r
+\r
+ PointerOptions getOptions() const {\r
+ return static_cast<PointerOptions>(Attrs);\r
+ }\r
+\r
+ uint8_t getSize() const {\r
+ return (Attrs >> PointerSizeShift) & PointerSizeMask;\r
+ }\r
+\r
+ MemberPointerInfo getMemberInfo() const { return *MemberInfo; }\r
+\r
+ bool isPointerToMember() const {\r
+ return getMode() == PointerMode::PointerToDataMember ||\r
+ getMode() == PointerMode::PointerToMemberFunction;\r
+ }\r
+\r
+ bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }\r
+ bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }\r
+\r
+ bool isVolatile() const {\r
+ return !!(Attrs & uint32_t(PointerOptions::Volatile));\r
+ }\r
+\r
+ bool isUnaligned() const {\r
+ return !!(Attrs & uint32_t(PointerOptions::Unaligned));\r
+ }\r
+\r
+ bool isRestrict() const {\r
+ return !!(Attrs & uint32_t(PointerOptions::Restrict));\r
+ }\r
+\r
+ TypeIndex ReferentType;\r
+ uint32_t Attrs;\r
+ Optional<MemberPointerInfo> MemberInfo;\r
+\r
+ void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,\r
+ uint8_t Size) {\r
+ Attrs = calcAttrs(PK, PM, PO, Size);\r
+ }\r
+\r
+private:\r
+ static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,\r
+ uint8_t Size) {\r
+ uint32_t A = 0;\r
+ A |= static_cast<uint32_t>(PK);\r
+ A |= static_cast<uint32_t>(PO);\r
+ A |= (static_cast<uint32_t>(PM) << PointerModeShift);\r
+ A |= (static_cast<uint32_t>(Size) << PointerSizeShift);\r
+ return A;\r
+ }\r
+};\r
+\r
+// LF_NESTTYPE\r
+class NestedTypeRecord : public TypeRecord {\r
+public:\r
+ NestedTypeRecord() = default;\r
+ explicit NestedTypeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ NestedTypeRecord(TypeIndex Type, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::NestedType), Type(Type), Name(Name) {}\r
+\r
+ TypeIndex getNestedType() const { return Type; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ TypeIndex Type;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_FIELDLIST\r
+class FieldListRecord : public TypeRecord {\r
+public:\r
+ FieldListRecord() = default;\r
+ explicit FieldListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ explicit FieldListRecord(ArrayRef<uint8_t> Data)\r
+ : TypeRecord(TypeRecordKind::FieldList), Data(Data) {}\r
+\r
+ ArrayRef<uint8_t> Data;\r
+};\r
+\r
+// LF_ARRAY\r
+class ArrayRecord : public TypeRecord {\r
+public:\r
+ ArrayRecord() = default;\r
+ explicit ArrayRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ ArrayRecord(TypeIndex ElementType, TypeIndex IndexType, uint64_t Size,\r
+ StringRef Name)\r
+ : TypeRecord(TypeRecordKind::Array), ElementType(ElementType),\r
+ IndexType(IndexType), Size(Size), Name(Name) {}\r
+\r
+ TypeIndex getElementType() const { return ElementType; }\r
+ TypeIndex getIndexType() const { return IndexType; }\r
+ uint64_t getSize() const { return Size; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ TypeIndex ElementType;\r
+ TypeIndex IndexType;\r
+ uint64_t Size;\r
+ StringRef Name;\r
+};\r
+\r
+class TagRecord : public TypeRecord {\r
+protected:\r
+ TagRecord() = default;\r
+ explicit TagRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ TagRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,\r
+ TypeIndex FieldList, StringRef Name, StringRef UniqueName)\r
+ : TypeRecord(Kind), MemberCount(MemberCount), Options(Options),\r
+ FieldList(FieldList), Name(Name), UniqueName(UniqueName) {}\r
+\r
+public:\r
+ static const int HfaKindShift = 11;\r
+ static const int HfaKindMask = 0x1800;\r
+ static const int WinRTKindShift = 14;\r
+ static const int WinRTKindMask = 0xC000;\r
+\r
+ bool hasUniqueName() const {\r
+ return (Options & ClassOptions::HasUniqueName) != ClassOptions::None;\r
+ }\r
+\r
+ bool isNested() const {\r
+ return (Options & ClassOptions::Nested) != ClassOptions::None;\r
+ }\r
+\r
+ bool isForwardRef() const {\r
+ return (Options & ClassOptions::ForwardReference) != ClassOptions::None;\r
+ }\r
+\r
+ uint16_t getMemberCount() const { return MemberCount; }\r
+ ClassOptions getOptions() const { return Options; }\r
+ TypeIndex getFieldList() const { return FieldList; }\r
+ StringRef getName() const { return Name; }\r
+ StringRef getUniqueName() const { return UniqueName; }\r
+\r
+ uint16_t MemberCount;\r
+ ClassOptions Options;\r
+ TypeIndex FieldList;\r
+ StringRef Name;\r
+ StringRef UniqueName;\r
+};\r
+\r
+// LF_CLASS, LF_STRUCTURE, LF_INTERFACE\r
+class ClassRecord : public TagRecord {\r
+public:\r
+ ClassRecord() = default;\r
+ explicit ClassRecord(TypeRecordKind Kind) : TagRecord(Kind) {}\r
+ ClassRecord(TypeRecordKind Kind, uint16_t MemberCount, ClassOptions Options,\r
+ TypeIndex FieldList, TypeIndex DerivationList,\r
+ TypeIndex VTableShape, uint64_t Size, StringRef Name,\r
+ StringRef UniqueName)\r
+ : TagRecord(Kind, MemberCount, Options, FieldList, Name, UniqueName),\r
+ DerivationList(DerivationList), VTableShape(VTableShape), Size(Size) {}\r
+\r
+ HfaKind getHfa() const {\r
+ uint16_t Value = static_cast<uint16_t>(Options);\r
+ Value = (Value & HfaKindMask) >> HfaKindShift;\r
+ return static_cast<HfaKind>(Value);\r
+ }\r
+\r
+ WindowsRTClassKind getWinRTKind() const {\r
+ uint16_t Value = static_cast<uint16_t>(Options);\r
+ Value = (Value & WinRTKindMask) >> WinRTKindShift;\r
+ return static_cast<WindowsRTClassKind>(Value);\r
+ }\r
+\r
+ TypeIndex getDerivationList() const { return DerivationList; }\r
+ TypeIndex getVTableShape() const { return VTableShape; }\r
+ uint64_t getSize() const { return Size; }\r
+\r
+ TypeIndex DerivationList;\r
+ TypeIndex VTableShape;\r
+ uint64_t Size;\r
+};\r
+\r
+// LF_UNION\r
+struct UnionRecord : public TagRecord {\r
+ UnionRecord() = default;\r
+ explicit UnionRecord(TypeRecordKind Kind) : TagRecord(Kind) {}\r
+ UnionRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,\r
+ uint64_t Size, StringRef Name, StringRef UniqueName)\r
+ : TagRecord(TypeRecordKind::Union, MemberCount, Options, FieldList, Name,\r
+ UniqueName),\r
+ Size(Size) {}\r
+\r
+ HfaKind getHfa() const {\r
+ uint16_t Value = static_cast<uint16_t>(Options);\r
+ Value = (Value & HfaKindMask) >> HfaKindShift;\r
+ return static_cast<HfaKind>(Value);\r
+ }\r
+\r
+ uint64_t getSize() const { return Size; }\r
+\r
+ uint64_t Size;\r
+};\r
+\r
+// LF_ENUM\r
+class EnumRecord : public TagRecord {\r
+public:\r
+ EnumRecord() = default;\r
+ explicit EnumRecord(TypeRecordKind Kind) : TagRecord(Kind) {}\r
+ EnumRecord(uint16_t MemberCount, ClassOptions Options, TypeIndex FieldList,\r
+ StringRef Name, StringRef UniqueName, TypeIndex UnderlyingType)\r
+ : TagRecord(TypeRecordKind::Enum, MemberCount, Options, FieldList, Name,\r
+ UniqueName),\r
+ UnderlyingType(UnderlyingType) {}\r
+\r
+ TypeIndex getUnderlyingType() const { return UnderlyingType; }\r
+\r
+ TypeIndex UnderlyingType;\r
+};\r
+\r
+// LF_BITFIELD\r
+class BitFieldRecord : public TypeRecord {\r
+public:\r
+ BitFieldRecord() = default;\r
+ explicit BitFieldRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ BitFieldRecord(TypeIndex Type, uint8_t BitSize, uint8_t BitOffset)\r
+ : TypeRecord(TypeRecordKind::BitField), Type(Type), BitSize(BitSize),\r
+ BitOffset(BitOffset) {}\r
+\r
+ TypeIndex getType() const { return Type; }\r
+ uint8_t getBitOffset() const { return BitOffset; }\r
+ uint8_t getBitSize() const { return BitSize; }\r
+\r
+ TypeIndex Type;\r
+ uint8_t BitSize;\r
+ uint8_t BitOffset;\r
+};\r
+\r
+// LF_VTSHAPE\r
+class VFTableShapeRecord : public TypeRecord {\r
+public:\r
+ VFTableShapeRecord() = default;\r
+ explicit VFTableShapeRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ explicit VFTableShapeRecord(ArrayRef<VFTableSlotKind> Slots)\r
+ : TypeRecord(TypeRecordKind::VFTableShape), SlotsRef(Slots) {}\r
+ explicit VFTableShapeRecord(std::vector<VFTableSlotKind> Slots)\r
+ : TypeRecord(TypeRecordKind::VFTableShape), Slots(std::move(Slots)) {}\r
+\r
+ ArrayRef<VFTableSlotKind> getSlots() const {\r
+ if (!SlotsRef.empty())\r
+ return SlotsRef;\r
+ return Slots;\r
+ }\r
+\r
+ uint32_t getEntryCount() const { return getSlots().size(); }\r
+\r
+ ArrayRef<VFTableSlotKind> SlotsRef;\r
+ std::vector<VFTableSlotKind> Slots;\r
+};\r
+\r
+// LF_TYPESERVER2\r
+class TypeServer2Record : public TypeRecord {\r
+public:\r
+ TypeServer2Record() = default;\r
+ explicit TypeServer2Record(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ TypeServer2Record(StringRef GuidStr, uint32_t Age, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::TypeServer2), Age(Age), Name(Name) {\r
+ assert(GuidStr.size() == 16 && "guid isn't 16 bytes");\r
+ ::memcpy(Guid.Guid, GuidStr.data(), 16);\r
+ }\r
+\r
+ const GUID &getGuid() const { return Guid; }\r
+ uint32_t getAge() const { return Age; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ GUID Guid;\r
+ uint32_t Age;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_STRING_ID\r
+class StringIdRecord : public TypeRecord {\r
+public:\r
+ StringIdRecord() = default;\r
+ explicit StringIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ StringIdRecord(TypeIndex Id, StringRef String)\r
+ : TypeRecord(TypeRecordKind::StringId), Id(Id), String(String) {}\r
+\r
+ TypeIndex getId() const { return Id; }\r
+ StringRef getString() const { return String; }\r
+\r
+ TypeIndex Id;\r
+ StringRef String;\r
+};\r
+\r
+// LF_FUNC_ID\r
+class FuncIdRecord : public TypeRecord {\r
+public:\r
+ FuncIdRecord() = default;\r
+ explicit FuncIdRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ FuncIdRecord(TypeIndex ParentScope, TypeIndex FunctionType, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::FuncId), ParentScope(ParentScope),\r
+ FunctionType(FunctionType), Name(Name) {}\r
+\r
+ TypeIndex getParentScope() const { return ParentScope; }\r
+ TypeIndex getFunctionType() const { return FunctionType; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ TypeIndex ParentScope;\r
+ TypeIndex FunctionType;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_UDT_SRC_LINE\r
+class UdtSourceLineRecord : public TypeRecord {\r
+public:\r
+ UdtSourceLineRecord() = default;\r
+ explicit UdtSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ UdtSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile, uint32_t LineNumber)\r
+ : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),\r
+ SourceFile(SourceFile), LineNumber(LineNumber) {}\r
+\r
+ TypeIndex getUDT() const { return UDT; }\r
+ TypeIndex getSourceFile() const { return SourceFile; }\r
+ uint32_t getLineNumber() const { return LineNumber; }\r
+\r
+ TypeIndex UDT;\r
+ TypeIndex SourceFile;\r
+ uint32_t LineNumber;\r
+};\r
+\r
+// LF_UDT_MOD_SRC_LINE\r
+class UdtModSourceLineRecord : public TypeRecord {\r
+public:\r
+ UdtModSourceLineRecord() = default;\r
+ explicit UdtModSourceLineRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ UdtModSourceLineRecord(TypeIndex UDT, TypeIndex SourceFile,\r
+ uint32_t LineNumber, uint16_t Module)\r
+ : TypeRecord(TypeRecordKind::UdtSourceLine), UDT(UDT),\r
+ SourceFile(SourceFile), LineNumber(LineNumber), Module(Module) {}\r
+\r
+ TypeIndex getUDT() const { return UDT; }\r
+ TypeIndex getSourceFile() const { return SourceFile; }\r
+ uint32_t getLineNumber() const { return LineNumber; }\r
+ uint16_t getModule() const { return Module; }\r
+\r
+ TypeIndex UDT;\r
+ TypeIndex SourceFile;\r
+ uint32_t LineNumber;\r
+ uint16_t Module;\r
+};\r
+\r
+// LF_BUILDINFO\r
+class BuildInfoRecord : public TypeRecord {\r
+public:\r
+ BuildInfoRecord() = default;\r
+ explicit BuildInfoRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ BuildInfoRecord(ArrayRef<TypeIndex> ArgIndices)\r
+ : TypeRecord(TypeRecordKind::BuildInfo),\r
+ ArgIndices(ArgIndices.begin(), ArgIndices.end()) {}\r
+\r
+ ArrayRef<TypeIndex> getArgs() const { return ArgIndices; }\r
+\r
+ SmallVector<TypeIndex, 4> ArgIndices;\r
+};\r
+\r
+// LF_VFTABLE\r
+class VFTableRecord : public TypeRecord {\r
+public:\r
+ VFTableRecord() = default;\r
+ explicit VFTableRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ VFTableRecord(TypeIndex CompleteClass, TypeIndex OverriddenVFTable,\r
+ uint32_t VFPtrOffset, StringRef Name,\r
+ ArrayRef<StringRef> Methods)\r
+ : TypeRecord(TypeRecordKind::VFTable), CompleteClass(CompleteClass),\r
+ OverriddenVFTable(OverriddenVFTable), VFPtrOffset(VFPtrOffset) {\r
+ MethodNames.push_back(Name);\r
+ MethodNames.insert(MethodNames.end(), Methods.begin(), Methods.end());\r
+ }\r
+\r
+ TypeIndex getCompleteClass() const { return CompleteClass; }\r
+ TypeIndex getOverriddenVTable() const { return OverriddenVFTable; }\r
+ uint32_t getVFPtrOffset() const { return VFPtrOffset; }\r
+ StringRef getName() const { return makeArrayRef(MethodNames).front(); }\r
+\r
+ ArrayRef<StringRef> getMethodNames() const {\r
+ return makeArrayRef(MethodNames).drop_front();\r
+ }\r
+\r
+ TypeIndex CompleteClass;\r
+ TypeIndex OverriddenVFTable;\r
+ uint32_t VFPtrOffset;\r
+ std::vector<StringRef> MethodNames;\r
+};\r
+\r
+// LF_ONEMETHOD\r
+class OneMethodRecord : public TypeRecord {\r
+public:\r
+ OneMethodRecord() = default;\r
+ explicit OneMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ OneMethodRecord(TypeIndex Type, MemberAttributes Attrs, int32_t VFTableOffset,\r
+ StringRef Name)\r
+ : TypeRecord(TypeRecordKind::OneMethod), Type(Type), Attrs(Attrs),\r
+ VFTableOffset(VFTableOffset), Name(Name) {}\r
+ OneMethodRecord(TypeIndex Type, MemberAccess Access, MethodKind MK,\r
+ MethodOptions Options, int32_t VFTableOffset, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::OneMethod), Type(Type),\r
+ Attrs(Access, MK, Options), VFTableOffset(VFTableOffset), Name(Name) {}\r
+\r
+ TypeIndex getType() const { return Type; }\r
+ MethodKind getMethodKind() const { return Attrs.getMethodKind(); }\r
+ MethodOptions getOptions() const { return Attrs.getFlags(); }\r
+ MemberAccess getAccess() const { return Attrs.getAccess(); }\r
+ int32_t getVFTableOffset() const { return VFTableOffset; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ bool isIntroducingVirtual() const {\r
+ return getMethodKind() == MethodKind::IntroducingVirtual ||\r
+ getMethodKind() == MethodKind::PureIntroducingVirtual;\r
+ }\r
+\r
+ TypeIndex Type;\r
+ MemberAttributes Attrs;\r
+ int32_t VFTableOffset;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_METHODLIST\r
+class MethodOverloadListRecord : public TypeRecord {\r
+public:\r
+ MethodOverloadListRecord() = default;\r
+ explicit MethodOverloadListRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ MethodOverloadListRecord(ArrayRef<OneMethodRecord> Methods)\r
+ : TypeRecord(TypeRecordKind::MethodOverloadList), Methods(Methods) {}\r
+\r
+ ArrayRef<OneMethodRecord> getMethods() const { return Methods; }\r
+\r
+ std::vector<OneMethodRecord> Methods;\r
+};\r
+\r
+/// For method overload sets. LF_METHOD\r
+class OverloadedMethodRecord : public TypeRecord {\r
+public:\r
+ OverloadedMethodRecord() = default;\r
+ explicit OverloadedMethodRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ OverloadedMethodRecord(uint16_t NumOverloads, TypeIndex MethodList,\r
+ StringRef Name)\r
+ : TypeRecord(TypeRecordKind::OverloadedMethod),\r
+ NumOverloads(NumOverloads), MethodList(MethodList), Name(Name) {}\r
+\r
+ uint16_t getNumOverloads() const { return NumOverloads; }\r
+ TypeIndex getMethodList() const { return MethodList; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ uint16_t NumOverloads;\r
+ TypeIndex MethodList;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_MEMBER\r
+class DataMemberRecord : public TypeRecord {\r
+public:\r
+ DataMemberRecord() = default;\r
+ explicit DataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ DataMemberRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset,\r
+ StringRef Name)\r
+ : TypeRecord(TypeRecordKind::DataMember), Attrs(Attrs), Type(Type),\r
+ FieldOffset(Offset), Name(Name) {}\r
+ DataMemberRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset,\r
+ StringRef Name)\r
+ : TypeRecord(TypeRecordKind::DataMember), Attrs(Access), Type(Type),\r
+ FieldOffset(Offset), Name(Name) {}\r
+\r
+ MemberAccess getAccess() const { return Attrs.getAccess(); }\r
+ TypeIndex getType() const { return Type; }\r
+ uint64_t getFieldOffset() const { return FieldOffset; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ MemberAttributes Attrs;\r
+ TypeIndex Type;\r
+ uint64_t FieldOffset;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_STMEMBER\r
+class StaticDataMemberRecord : public TypeRecord {\r
+public:\r
+ StaticDataMemberRecord() = default;\r
+ explicit StaticDataMemberRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ StaticDataMemberRecord(MemberAttributes Attrs, TypeIndex Type, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Attrs), Type(Type),\r
+ Name(Name) {}\r
+ StaticDataMemberRecord(MemberAccess Access, TypeIndex Type, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::StaticDataMember), Attrs(Access), Type(Type),\r
+ Name(Name) {}\r
+\r
+ MemberAccess getAccess() const { return Attrs.getAccess(); }\r
+ TypeIndex getType() const { return Type; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ MemberAttributes Attrs;\r
+ TypeIndex Type;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_ENUMERATE\r
+class EnumeratorRecord : public TypeRecord {\r
+public:\r
+ EnumeratorRecord() = default;\r
+ explicit EnumeratorRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ EnumeratorRecord(MemberAttributes Attrs, APSInt Value, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::Enumerator), Attrs(Attrs),\r
+ Value(std::move(Value)), Name(Name) {}\r
+ EnumeratorRecord(MemberAccess Access, APSInt Value, StringRef Name)\r
+ : TypeRecord(TypeRecordKind::Enumerator), Attrs(Access),\r
+ Value(std::move(Value)), Name(Name) {}\r
+\r
+ MemberAccess getAccess() const { return Attrs.getAccess(); }\r
+ APSInt getValue() const { return Value; }\r
+ StringRef getName() const { return Name; }\r
+\r
+ MemberAttributes Attrs;\r
+ APSInt Value;\r
+ StringRef Name;\r
+};\r
+\r
+// LF_VFUNCTAB\r
+class VFPtrRecord : public TypeRecord {\r
+public:\r
+ VFPtrRecord() = default;\r
+ explicit VFPtrRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ VFPtrRecord(TypeIndex Type)\r
+ : TypeRecord(TypeRecordKind::VFPtr), Type(Type) {}\r
+\r
+ TypeIndex getType() const { return Type; }\r
+\r
+ TypeIndex Type;\r
+};\r
+\r
+// LF_BCLASS, LF_BINTERFACE\r
+class BaseClassRecord : public TypeRecord {\r
+public:\r
+ BaseClassRecord() = default;\r
+ explicit BaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ BaseClassRecord(MemberAttributes Attrs, TypeIndex Type, uint64_t Offset)\r
+ : TypeRecord(TypeRecordKind::BaseClass), Attrs(Attrs), Type(Type),\r
+ Offset(Offset) {}\r
+ BaseClassRecord(MemberAccess Access, TypeIndex Type, uint64_t Offset)\r
+ : TypeRecord(TypeRecordKind::BaseClass), Attrs(Access), Type(Type),\r
+ Offset(Offset) {}\r
+\r
+ MemberAccess getAccess() const { return Attrs.getAccess(); }\r
+ TypeIndex getBaseType() const { return Type; }\r
+ uint64_t getBaseOffset() const { return Offset; }\r
+\r
+ MemberAttributes Attrs;\r
+ TypeIndex Type;\r
+ uint64_t Offset;\r
+};\r
+\r
+// LF_VBCLASS, LF_IVBCLASS\r
+class VirtualBaseClassRecord : public TypeRecord {\r
+public:\r
+ VirtualBaseClassRecord() = default;\r
+ explicit VirtualBaseClassRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ VirtualBaseClassRecord(TypeRecordKind Kind, MemberAttributes Attrs,\r
+ TypeIndex BaseType, TypeIndex VBPtrType,\r
+ uint64_t Offset, uint64_t Index)\r
+ : TypeRecord(Kind), Attrs(Attrs), BaseType(BaseType),\r
+ VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}\r
+ VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access,\r
+ TypeIndex BaseType, TypeIndex VBPtrType,\r
+ uint64_t Offset, uint64_t Index)\r
+ : TypeRecord(Kind), Attrs(Access), BaseType(BaseType),\r
+ VBPtrType(VBPtrType), VBPtrOffset(Offset), VTableIndex(Index) {}\r
+\r
+ MemberAccess getAccess() const { return Attrs.getAccess(); }\r
+ TypeIndex getBaseType() const { return BaseType; }\r
+ TypeIndex getVBPtrType() const { return VBPtrType; }\r
+ uint64_t getVBPtrOffset() const { return VBPtrOffset; }\r
+ uint64_t getVTableIndex() const { return VTableIndex; }\r
+\r
+ MemberAttributes Attrs;\r
+ TypeIndex BaseType;\r
+ TypeIndex VBPtrType;\r
+ uint64_t VBPtrOffset;\r
+ uint64_t VTableIndex;\r
+};\r
+\r
+/// LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records\r
+/// together. The first will end in an LF_INDEX record that points to the next.\r
+class ListContinuationRecord : public TypeRecord {\r
+public:\r
+ ListContinuationRecord() = default;\r
+ explicit ListContinuationRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+ ListContinuationRecord(TypeIndex ContinuationIndex)\r
+ : TypeRecord(TypeRecordKind::ListContinuation),\r
+ ContinuationIndex(ContinuationIndex) {}\r
+\r
+ TypeIndex getContinuationIndex() const { return ContinuationIndex; }\r
+\r
+ TypeIndex ContinuationIndex;\r
+};\r
+\r
+// LF_PRECOMP\r
+class PrecompRecord : public TypeRecord {\r
+public:\r
+ PrecompRecord() = default;\r
+ explicit PrecompRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ uint32_t getStartTypeIndex() const { return StartTypeIndex; }\r
+ uint32_t getTypesCount() const { return TypesCount; }\r
+ uint32_t getSignature() const { return Signature; }\r
+ StringRef getPrecompFilePath() const { return PrecompFilePath; }\r
+\r
+ uint32_t StartTypeIndex;\r
+ uint32_t TypesCount;\r
+ uint32_t Signature;\r
+ StringRef PrecompFilePath;\r
+};\r
+\r
+// LF_ENDPRECOMP\r
+class EndPrecompRecord : public TypeRecord {\r
+public:\r
+ EndPrecompRecord() = default;\r
+ explicit EndPrecompRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}\r
+\r
+ uint32_t getSignature() const { return Signature; }\r
+\r
+ uint32_t Signature;\r
+};\r
+} // end namespace codeview\r
+} // end namespace llvm\r
+\r
+#endif // LLVM_DEBUGINFO_CODEVIEW_TYPERECORD_H\r
yaml::BinaryRef SectionData;
std::vector<CodeViewYAML::YAMLDebugSubsection> DebugS;
std::vector<CodeViewYAML::LeafRecord> DebugT;
+ std::vector<CodeViewYAML::LeafRecord> DebugP;
Optional<CodeViewYAML::DebugHSection> DebugH;
std::vector<Relocation> Relocations;
StringRef Name;
std::vector<GlobalHash> Hashes;
};
-DebugHSection fromDebugH(ArrayRef<uint8_t> DebugT);
+DebugHSection fromDebugH(ArrayRef<uint8_t> DebugH);
ArrayRef<uint8_t> toDebugH(const DebugHSection &DebugH,
BumpPtrAllocator &Alloc);
static Expected<LeafRecord> fromCodeViewRecord(codeview::CVType Type);
};
-std::vector<LeafRecord> fromDebugT(ArrayRef<uint8_t> DebugT);
-ArrayRef<uint8_t> toDebugT(ArrayRef<LeafRecord>, BumpPtrAllocator &Alloc);
+std::vector<LeafRecord> fromDebugT(ArrayRef<uint8_t> DebugTorP,
+ StringRef SectionName);
+ArrayRef<uint8_t> toDebugT(ArrayRef<LeafRecord>, BumpPtrAllocator &Alloc,
+ StringRef SectionName);
} // end namespace CodeViewYAML
if (TypeTable.empty())
return;
- // Start the .debug$T section with 0x4.
+ // Start the .debug$T or .debug$P section with 0x4.
OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
emitCodeViewMagicVersion();
}
/// Emit the magic version number at the start of a CodeView type or symbol
- /// section. Appears at the front of every .debug$S or .debug$T section.
+ /// section. Appears at the front of every .debug$S or .debug$T or .debug$P
+ /// section.
void emitCodeViewMagicVersion();
void emitTypeInformation();
-//===- RecordName.cpp ----------------------------------------- *- C++ --*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/DebugInfo/CodeView/RecordName.h"
-
-#include "llvm/ADT/SmallString.h"
-#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
-#include "llvm/DebugInfo/CodeView/SymbolRecordMapping.h"
-#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
-#include "llvm/Support/FormatVariadic.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-
-namespace {
-class TypeNameComputer : public TypeVisitorCallbacks {
- /// The type collection. Used to calculate names of nested types.
- TypeCollection &Types;
- TypeIndex CurrentTypeIndex = TypeIndex::None();
-
- /// Name of the current type. Only valid before visitTypeEnd.
- SmallString<256> Name;
-
-public:
- explicit TypeNameComputer(TypeCollection &Types) : Types(Types) {}
-
- StringRef name() const { return Name; }
-
- /// Paired begin/end actions for all types. Receives all record data,
- /// including the fixed-length record prefix.
- Error visitTypeBegin(CVType &Record) override;
- Error visitTypeBegin(CVType &Record, TypeIndex Index) override;
- Error visitTypeEnd(CVType &Record) override;
-
-#define TYPE_RECORD(EnumName, EnumVal, Name) \
- Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
-#define MEMBER_RECORD(EnumName, EnumVal, Name)
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
-};
-} // namespace
-
-Error TypeNameComputer::visitTypeBegin(CVType &Record) {
- llvm_unreachable("Must call visitTypeBegin with a TypeIndex!");
- return Error::success();
-}
-
-Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {
- // Reset Name to the empty string. If the visitor sets it, we know it.
- Name = "";
- CurrentTypeIndex = Index;
- return Error::success();
-}
-
-Error TypeNameComputer::visitTypeEnd(CVType &CVR) { return Error::success(); }
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR,
- FieldListRecord &FieldList) {
- Name = "<field list>";
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,
- StringIdRecord &String) {
- Name = String.getString();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
- auto Indices = Args.getIndices();
- uint32_t Size = Indices.size();
- Name = "(";
- for (uint32_t I = 0; I < Size; ++I) {
- assert(Indices[I] < CurrentTypeIndex);
-
- Name.append(Types.getTypeName(Indices[I]));
- if (I + 1 != Size)
- Name.append(", ");
- }
- Name.push_back(')');
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR,
- StringListRecord &Strings) {
- auto Indices = Strings.getIndices();
- uint32_t Size = Indices.size();
- Name = "\"";
- for (uint32_t I = 0; I < Size; ++I) {
- Name.append(Types.getTypeName(Indices[I]));
- if (I + 1 != Size)
- Name.append("\" \"");
- }
- Name.push_back('\"');
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
- Name = Class.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
- Name = Union.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
- Name = Enum.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
- Name = AT.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {
- Name = VFT.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {
- Name = Id.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
- StringRef Ret = Types.getTypeName(Proc.getReturnType());
- StringRef Params = Types.getTypeName(Proc.getArgumentList());
- Name = formatv("{0} {1}", Ret, Params).sstr<256>();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR,
- MemberFunctionRecord &MF) {
- StringRef Ret = Types.getTypeName(MF.getReturnType());
- StringRef Class = Types.getTypeName(MF.getClassType());
- StringRef Params = Types.getTypeName(MF.getArgumentList());
- Name = formatv("{0} {1}::{2}", Ret, Class, Params).sstr<256>();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
- Name = Func.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
- Name = TS.getName();
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
-
- if (Ptr.isPointerToMember()) {
- const MemberPointerInfo &MI = Ptr.getMemberInfo();
-
- StringRef Pointee = Types.getTypeName(Ptr.getReferentType());
- StringRef Class = Types.getTypeName(MI.getContainingType());
- Name = formatv("{0} {1}::*", Pointee, Class);
- } else {
- Name.append(Types.getTypeName(Ptr.getReferentType()));
-
- if (Ptr.getMode() == PointerMode::LValueReference)
- Name.append("&");
- else if (Ptr.getMode() == PointerMode::RValueReference)
- Name.append("&&");
- else if (Ptr.getMode() == PointerMode::Pointer)
- Name.append("*");
-
- // Qualifiers in pointer records apply to the pointer, not the pointee, so
- // they go on the right.
- if (Ptr.isConst())
- Name.append(" const");
- if (Ptr.isVolatile())
- Name.append(" volatile");
- if (Ptr.isUnaligned())
- Name.append(" __unaligned");
- if (Ptr.isRestrict())
- Name.append(" __restrict");
- }
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
- uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
-
- if (Mods & uint16_t(ModifierOptions::Const))
- Name.append("const ");
- if (Mods & uint16_t(ModifierOptions::Volatile))
- Name.append("volatile ");
- if (Mods & uint16_t(ModifierOptions::Unaligned))
- Name.append("__unaligned ");
- Name.append(Types.getTypeName(Mod.getModifiedType()));
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR,
- VFTableShapeRecord &Shape) {
- Name = formatv("<vftable {0} methods>", Shape.getEntryCount());
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(
- CVType &CVR, UdtModSourceLineRecord &ModSourceLine) {
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR,
- UdtSourceLineRecord &SourceLine) {
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, BitFieldRecord &BF) {
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR,
- MethodOverloadListRecord &Overloads) {
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, BuildInfoRecord &BI) {
- return Error::success();
-}
-
-Error TypeNameComputer::visitKnownRecord(CVType &CVR, LabelRecord &R) {
- return Error::success();
-}
-
-std::string llvm::codeview::computeTypeName(TypeCollection &Types,
- TypeIndex Index) {
- TypeNameComputer Computer(Types);
- CVType Record = Types.getType(Index);
- if (auto EC = visitTypeRecord(Record, Index, Computer)) {
- consumeError(std::move(EC));
- return "<unknown UDT>";
- }
- return Computer.name();
-}
-
-static int getSymbolNameOffset(CVSymbol Sym) {
- switch (Sym.kind()) {
- // See ProcSym
- case SymbolKind::S_GPROC32:
- case SymbolKind::S_LPROC32:
- case SymbolKind::S_GPROC32_ID:
- case SymbolKind::S_LPROC32_ID:
- case SymbolKind::S_LPROC32_DPC:
- case SymbolKind::S_LPROC32_DPC_ID:
- return 35;
- // See Thunk32Sym
- case SymbolKind::S_THUNK32:
- return 21;
- // See SectionSym
- case SymbolKind::S_SECTION:
- return 16;
- // See CoffGroupSym
- case SymbolKind::S_COFFGROUP:
- return 14;
- // See PublicSym32, FileStaticSym, RegRelativeSym, DataSym, ThreadLocalDataSym
- case SymbolKind::S_PUB32:
- case SymbolKind::S_FILESTATIC:
- case SymbolKind::S_REGREL32:
- case SymbolKind::S_GDATA32:
- case SymbolKind::S_LDATA32:
- case SymbolKind::S_LMANDATA:
- case SymbolKind::S_GMANDATA:
- case SymbolKind::S_LTHREAD32:
- case SymbolKind::S_GTHREAD32:
- return 10;
- // See RegisterSym and LocalSym
- case SymbolKind::S_REGISTER:
- case SymbolKind::S_LOCAL:
- return 6;
- // See BlockSym
- case SymbolKind::S_BLOCK32:
- return 18;
- // See LabelSym
- case SymbolKind::S_LABEL32:
- return 7;
- // See ObjNameSym, ExportSym, and UDTSym
- case SymbolKind::S_OBJNAME:
- case SymbolKind::S_EXPORT:
- case SymbolKind::S_UDT:
- return 4;
- // See BPRelativeSym
- case SymbolKind::S_BPREL32:
- return 8;
- default:
- return -1;
- }
-}
-
-StringRef llvm::codeview::getSymbolName(CVSymbol Sym) {
- if (Sym.kind() == SymbolKind::S_CONSTANT) {
- // S_CONSTANT is preceded by an APSInt, which has a variable length. So we
- // have to do a full deserialization.
- BinaryStreamReader Reader(Sym.content(), llvm::support::little);
- // The container doesn't matter for single records.
- SymbolRecordMapping Mapping(Reader, CodeViewContainer::ObjectFile);
- ConstantSym Const(SymbolKind::S_CONSTANT);
- cantFail(Mapping.visitSymbolBegin(Sym));
- cantFail(Mapping.visitKnownRecord(Sym, Const));
- cantFail(Mapping.visitSymbolEnd(Sym));
- return Const.Name;
- }
-
- int Offset = getSymbolNameOffset(Sym);
- if (Offset == -1)
- return StringRef();
-
- StringRef StringData = toStringRef(Sym.content()).drop_front(Offset);
- return StringData.split('\0').first;
-}
+//===- RecordName.cpp ----------------------------------------- *- C++ --*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "llvm/DebugInfo/CodeView/RecordName.h"\r
+\r
+#include "llvm/ADT/SmallString.h"\r
+#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"\r
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"\r
+#include "llvm/DebugInfo/CodeView/SymbolRecordMapping.h"\r
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"\r
+#include "llvm/Support/FormatVariadic.h"\r
+\r
+using namespace llvm;\r
+using namespace llvm::codeview;\r
+\r
+namespace {\r
+class TypeNameComputer : public TypeVisitorCallbacks {\r
+ /// The type collection. Used to calculate names of nested types.\r
+ TypeCollection &Types;\r
+ TypeIndex CurrentTypeIndex = TypeIndex::None();\r
+\r
+ /// Name of the current type. Only valid before visitTypeEnd.\r
+ SmallString<256> Name;\r
+\r
+public:\r
+ explicit TypeNameComputer(TypeCollection &Types) : Types(Types) {}\r
+\r
+ StringRef name() const { return Name; }\r
+\r
+ /// Paired begin/end actions for all types. Receives all record data,\r
+ /// including the fixed-length record prefix.\r
+ Error visitTypeBegin(CVType &Record) override;\r
+ Error visitTypeBegin(CVType &Record, TypeIndex Index) override;\r
+ Error visitTypeEnd(CVType &Record) override;\r
+\r
+#define TYPE_RECORD(EnumName, EnumVal, Name) \\r
+ Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;\r
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)\r
+#define MEMBER_RECORD(EnumName, EnumVal, Name)\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+};\r
+} // namespace\r
+\r
+Error TypeNameComputer::visitTypeBegin(CVType &Record) {\r
+ llvm_unreachable("Must call visitTypeBegin with a TypeIndex!");\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {\r
+ // Reset Name to the empty string. If the visitor sets it, we know it.\r
+ Name = "";\r
+ CurrentTypeIndex = Index;\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitTypeEnd(CVType &CVR) { return Error::success(); }\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ FieldListRecord &FieldList) {\r
+ Name = "<field list>";\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVRecord<TypeLeafKind> &CVR,\r
+ StringIdRecord &String) {\r
+ Name = String.getString();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {\r
+ auto Indices = Args.getIndices();\r
+ uint32_t Size = Indices.size();\r
+ Name = "(";\r
+ for (uint32_t I = 0; I < Size; ++I) {\r
+ assert(Indices[I] < CurrentTypeIndex);\r
+\r
+ Name.append(Types.getTypeName(Indices[I]));\r
+ if (I + 1 != Size)\r
+ Name.append(", ");\r
+ }\r
+ Name.push_back(')');\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ StringListRecord &Strings) {\r
+ auto Indices = Strings.getIndices();\r
+ uint32_t Size = Indices.size();\r
+ Name = "\"";\r
+ for (uint32_t I = 0; I < Size; ++I) {\r
+ Name.append(Types.getTypeName(Indices[I]));\r
+ if (I + 1 != Size)\r
+ Name.append("\" \"");\r
+ }\r
+ Name.push_back('\"');\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ClassRecord &Class) {\r
+ Name = Class.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, UnionRecord &Union) {\r
+ Name = Union.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {\r
+ Name = Enum.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {\r
+ Name = AT.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {\r
+ Name = VFT.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {\r
+ Name = Id.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {\r
+ StringRef Ret = Types.getTypeName(Proc.getReturnType());\r
+ StringRef Params = Types.getTypeName(Proc.getArgumentList());\r
+ Name = formatv("{0} {1}", Ret, Params).sstr<256>();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ MemberFunctionRecord &MF) {\r
+ StringRef Ret = Types.getTypeName(MF.getReturnType());\r
+ StringRef Class = Types.getTypeName(MF.getClassType());\r
+ StringRef Params = Types.getTypeName(MF.getArgumentList());\r
+ Name = formatv("{0} {1}::{2}", Ret, Class, Params).sstr<256>();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {\r
+ Name = Func.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {\r
+ Name = TS.getName();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {\r
+\r
+ if (Ptr.isPointerToMember()) {\r
+ const MemberPointerInfo &MI = Ptr.getMemberInfo();\r
+\r
+ StringRef Pointee = Types.getTypeName(Ptr.getReferentType());\r
+ StringRef Class = Types.getTypeName(MI.getContainingType());\r
+ Name = formatv("{0} {1}::*", Pointee, Class);\r
+ } else {\r
+ Name.append(Types.getTypeName(Ptr.getReferentType()));\r
+\r
+ if (Ptr.getMode() == PointerMode::LValueReference)\r
+ Name.append("&");\r
+ else if (Ptr.getMode() == PointerMode::RValueReference)\r
+ Name.append("&&");\r
+ else if (Ptr.getMode() == PointerMode::Pointer)\r
+ Name.append("*");\r
+\r
+ // Qualifiers in pointer records apply to the pointer, not the pointee, so\r
+ // they go on the right.\r
+ if (Ptr.isConst())\r
+ Name.append(" const");\r
+ if (Ptr.isVolatile())\r
+ Name.append(" volatile");\r
+ if (Ptr.isUnaligned())\r
+ Name.append(" __unaligned");\r
+ if (Ptr.isRestrict())\r
+ Name.append(" __restrict");\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {\r
+ uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());\r
+\r
+ if (Mods & uint16_t(ModifierOptions::Const))\r
+ Name.append("const ");\r
+ if (Mods & uint16_t(ModifierOptions::Volatile))\r
+ Name.append("volatile ");\r
+ if (Mods & uint16_t(ModifierOptions::Unaligned))\r
+ Name.append("__unaligned ");\r
+ Name.append(Types.getTypeName(Mod.getModifiedType()));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ VFTableShapeRecord &Shape) {\r
+ Name = formatv("<vftable {0} methods>", Shape.getEntryCount());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(\r
+ CVType &CVR, UdtModSourceLineRecord &ModSourceLine) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ UdtSourceLineRecord &SourceLine) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, BitFieldRecord &BF) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ MethodOverloadListRecord &Overloads) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, BuildInfoRecord &BI) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR, LabelRecord &R) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ PrecompRecord &Precomp) {\r
+ return Error::success();\r
+}\r
+\r
+Error TypeNameComputer::visitKnownRecord(CVType &CVR,\r
+ EndPrecompRecord &EndPrecomp) {\r
+ return Error::success();\r
+}\r
+\r
+std::string llvm::codeview::computeTypeName(TypeCollection &Types,\r
+ TypeIndex Index) {\r
+ TypeNameComputer Computer(Types);\r
+ CVType Record = Types.getType(Index);\r
+ if (auto EC = visitTypeRecord(Record, Index, Computer)) {\r
+ consumeError(std::move(EC));\r
+ return "<unknown UDT>";\r
+ }\r
+ return Computer.name();\r
+}\r
+\r
+static int getSymbolNameOffset(CVSymbol Sym) {\r
+ switch (Sym.kind()) {\r
+ // See ProcSym\r
+ case SymbolKind::S_GPROC32:\r
+ case SymbolKind::S_LPROC32:\r
+ case SymbolKind::S_GPROC32_ID:\r
+ case SymbolKind::S_LPROC32_ID:\r
+ case SymbolKind::S_LPROC32_DPC:\r
+ case SymbolKind::S_LPROC32_DPC_ID:\r
+ return 35;\r
+ // See Thunk32Sym\r
+ case SymbolKind::S_THUNK32:\r
+ return 21;\r
+ // See SectionSym\r
+ case SymbolKind::S_SECTION:\r
+ return 16;\r
+ // See CoffGroupSym\r
+ case SymbolKind::S_COFFGROUP:\r
+ return 14;\r
+ // See PublicSym32, FileStaticSym, RegRelativeSym, DataSym, ThreadLocalDataSym\r
+ case SymbolKind::S_PUB32:\r
+ case SymbolKind::S_FILESTATIC:\r
+ case SymbolKind::S_REGREL32:\r
+ case SymbolKind::S_GDATA32:\r
+ case SymbolKind::S_LDATA32:\r
+ case SymbolKind::S_LMANDATA:\r
+ case SymbolKind::S_GMANDATA:\r
+ case SymbolKind::S_LTHREAD32:\r
+ case SymbolKind::S_GTHREAD32:\r
+ return 10;\r
+ // See RegisterSym and LocalSym\r
+ case SymbolKind::S_REGISTER:\r
+ case SymbolKind::S_LOCAL:\r
+ return 6;\r
+ // See BlockSym\r
+ case SymbolKind::S_BLOCK32:\r
+ return 18;\r
+ // See LabelSym\r
+ case SymbolKind::S_LABEL32:\r
+ return 7;\r
+ // See ObjNameSym, ExportSym, and UDTSym\r
+ case SymbolKind::S_OBJNAME:\r
+ case SymbolKind::S_EXPORT:\r
+ case SymbolKind::S_UDT:\r
+ return 4;\r
+ // See BPRelativeSym\r
+ case SymbolKind::S_BPREL32:\r
+ return 8;\r
+ default:\r
+ return -1;\r
+ }\r
+}\r
+\r
+StringRef llvm::codeview::getSymbolName(CVSymbol Sym) {\r
+ if (Sym.kind() == SymbolKind::S_CONSTANT) {\r
+ // S_CONSTANT is preceded by an APSInt, which has a variable length. So we\r
+ // have to do a full deserialization.\r
+ BinaryStreamReader Reader(Sym.content(), llvm::support::little);\r
+ // The container doesn't matter for single records.\r
+ SymbolRecordMapping Mapping(Reader, CodeViewContainer::ObjectFile);\r
+ ConstantSym Const(SymbolKind::S_CONSTANT);\r
+ cantFail(Mapping.visitSymbolBegin(Sym));\r
+ cantFail(Mapping.visitKnownRecord(Sym, Const));\r
+ cantFail(Mapping.visitSymbolEnd(Sym));\r
+ return Const.Name;\r
+ }\r
+\r
+ int Offset = getSymbolNameOffset(Sym);\r
+ if (Offset == -1)\r
+ return StringRef();\r
+\r
+ StringRef StringData = toStringRef(Sym.content()).drop_front(Offset);\r
+ return StringData.split('\0').first;\r
+}\r
-//===-- TypeDumpVisitor.cpp - CodeView type info dumper ----------*- C++-*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
-
-#include "llvm/ADT/SmallString.h"
-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
-#include "llvm/DebugInfo/CodeView/Formatters.h"
-#include "llvm/DebugInfo/CodeView/TypeCollection.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/ScopedPrinter.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-
-static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
-#define CV_TYPE(enum, val) {#enum, enum},
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
-};
-
-#define ENUM_ENTRY(enum_class, enum) \
- { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
-
-static const EnumEntry<uint16_t> ClassOptionNames[] = {
- ENUM_ENTRY(ClassOptions, Packed),
- ENUM_ENTRY(ClassOptions, HasConstructorOrDestructor),
- ENUM_ENTRY(ClassOptions, HasOverloadedOperator),
- ENUM_ENTRY(ClassOptions, Nested),
- ENUM_ENTRY(ClassOptions, ContainsNestedClass),
- ENUM_ENTRY(ClassOptions, HasOverloadedAssignmentOperator),
- ENUM_ENTRY(ClassOptions, HasConversionOperator),
- ENUM_ENTRY(ClassOptions, ForwardReference),
- ENUM_ENTRY(ClassOptions, Scoped),
- ENUM_ENTRY(ClassOptions, HasUniqueName),
- ENUM_ENTRY(ClassOptions, Sealed),
- ENUM_ENTRY(ClassOptions, Intrinsic),
-};
-
-static const EnumEntry<uint8_t> MemberAccessNames[] = {
- ENUM_ENTRY(MemberAccess, None), ENUM_ENTRY(MemberAccess, Private),
- ENUM_ENTRY(MemberAccess, Protected), ENUM_ENTRY(MemberAccess, Public),
-};
-
-static const EnumEntry<uint16_t> MethodOptionNames[] = {
- ENUM_ENTRY(MethodOptions, Pseudo),
- ENUM_ENTRY(MethodOptions, NoInherit),
- ENUM_ENTRY(MethodOptions, NoConstruct),
- ENUM_ENTRY(MethodOptions, CompilerGenerated),
- ENUM_ENTRY(MethodOptions, Sealed),
-};
-
-static const EnumEntry<uint16_t> MemberKindNames[] = {
- ENUM_ENTRY(MethodKind, Vanilla),
- ENUM_ENTRY(MethodKind, Virtual),
- ENUM_ENTRY(MethodKind, Static),
- ENUM_ENTRY(MethodKind, Friend),
- ENUM_ENTRY(MethodKind, IntroducingVirtual),
- ENUM_ENTRY(MethodKind, PureVirtual),
- ENUM_ENTRY(MethodKind, PureIntroducingVirtual),
-};
-
-static const EnumEntry<uint8_t> PtrKindNames[] = {
- ENUM_ENTRY(PointerKind, Near16),
- ENUM_ENTRY(PointerKind, Far16),
- ENUM_ENTRY(PointerKind, Huge16),
- ENUM_ENTRY(PointerKind, BasedOnSegment),
- ENUM_ENTRY(PointerKind, BasedOnValue),
- ENUM_ENTRY(PointerKind, BasedOnSegmentValue),
- ENUM_ENTRY(PointerKind, BasedOnAddress),
- ENUM_ENTRY(PointerKind, BasedOnSegmentAddress),
- ENUM_ENTRY(PointerKind, BasedOnType),
- ENUM_ENTRY(PointerKind, BasedOnSelf),
- ENUM_ENTRY(PointerKind, Near32),
- ENUM_ENTRY(PointerKind, Far32),
- ENUM_ENTRY(PointerKind, Near64),
-};
-
-static const EnumEntry<uint8_t> PtrModeNames[] = {
- ENUM_ENTRY(PointerMode, Pointer),
- ENUM_ENTRY(PointerMode, LValueReference),
- ENUM_ENTRY(PointerMode, PointerToDataMember),
- ENUM_ENTRY(PointerMode, PointerToMemberFunction),
- ENUM_ENTRY(PointerMode, RValueReference),
-};
-
-static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
- ENUM_ENTRY(PointerToMemberRepresentation, Unknown),
- ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceData),
- ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceData),
- ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceData),
- ENUM_ENTRY(PointerToMemberRepresentation, GeneralData),
- ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceFunction),
- ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceFunction),
- ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceFunction),
- ENUM_ENTRY(PointerToMemberRepresentation, GeneralFunction),
-};
-
-static const EnumEntry<uint16_t> TypeModifierNames[] = {
- ENUM_ENTRY(ModifierOptions, Const), ENUM_ENTRY(ModifierOptions, Volatile),
- ENUM_ENTRY(ModifierOptions, Unaligned),
-};
-
-static const EnumEntry<uint8_t> CallingConventions[] = {
- ENUM_ENTRY(CallingConvention, NearC),
- ENUM_ENTRY(CallingConvention, FarC),
- ENUM_ENTRY(CallingConvention, NearPascal),
- ENUM_ENTRY(CallingConvention, FarPascal),
- ENUM_ENTRY(CallingConvention, NearFast),
- ENUM_ENTRY(CallingConvention, FarFast),
- ENUM_ENTRY(CallingConvention, NearStdCall),
- ENUM_ENTRY(CallingConvention, FarStdCall),
- ENUM_ENTRY(CallingConvention, NearSysCall),
- ENUM_ENTRY(CallingConvention, FarSysCall),
- ENUM_ENTRY(CallingConvention, ThisCall),
- ENUM_ENTRY(CallingConvention, MipsCall),
- ENUM_ENTRY(CallingConvention, Generic),
- ENUM_ENTRY(CallingConvention, AlphaCall),
- ENUM_ENTRY(CallingConvention, PpcCall),
- ENUM_ENTRY(CallingConvention, SHCall),
- ENUM_ENTRY(CallingConvention, ArmCall),
- ENUM_ENTRY(CallingConvention, AM33Call),
- ENUM_ENTRY(CallingConvention, TriCall),
- ENUM_ENTRY(CallingConvention, SH5Call),
- ENUM_ENTRY(CallingConvention, M32RCall),
- ENUM_ENTRY(CallingConvention, ClrCall),
- ENUM_ENTRY(CallingConvention, Inline),
- ENUM_ENTRY(CallingConvention, NearVector),
-};
-
-static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
- ENUM_ENTRY(FunctionOptions, CxxReturnUdt),
- ENUM_ENTRY(FunctionOptions, Constructor),
- ENUM_ENTRY(FunctionOptions, ConstructorWithVirtualBases),
-};
-
-static const EnumEntry<uint16_t> LabelTypeEnum[] = {
- ENUM_ENTRY(LabelType, Near), ENUM_ENTRY(LabelType, Far),
-};
-
-#undef ENUM_ENTRY
-
-static StringRef getLeafTypeName(TypeLeafKind LT) {
- switch (LT) {
-#define TYPE_RECORD(ename, value, name) \
- case ename: \
- return #name;
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
- default:
- break;
- }
- return "UnknownLeaf";
-}
-
-void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {
- codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);
-}
-
-void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {
- codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());
-}
-
-Error TypeDumpVisitor::visitTypeBegin(CVType &Record) {
- return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));
-}
-
-Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
- W->startLine() << getLeafTypeName(Record.Type);
- W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";
- W->getOStream() << " {\n";
- W->indent();
- W->printEnum("TypeLeafKind", unsigned(Record.Type),
- makeArrayRef(LeafTypeNames));
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitTypeEnd(CVType &Record) {
- if (PrintRecordBytes)
- W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));
-
- W->unindent();
- W->startLine() << "}\n";
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
- W->startLine() << getLeafTypeName(Record.Kind);
- W->getOStream() << " {\n";
- W->indent();
- W->printEnum("TypeLeafKind", unsigned(Record.Kind),
- makeArrayRef(LeafTypeNames));
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
- if (PrintRecordBytes)
- W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));
-
- W->unindent();
- W->startLine() << "}\n";
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
- FieldListRecord &FieldList) {
- if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
- return EC;
-
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {
- printItemIndex("Id", String.getId());
- W->printString("StringData", String.getString());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
- auto Indices = Args.getIndices();
- uint32_t Size = Indices.size();
- W->printNumber("NumArgs", Size);
- ListScope Arguments(*W, "Arguments");
- for (uint32_t I = 0; I < Size; ++I) {
- printTypeIndex("ArgType", Indices[I]);
- }
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringListRecord &Strs) {
- auto Indices = Strs.getIndices();
- uint32_t Size = Indices.size();
- W->printNumber("NumStrings", Size);
- ListScope Arguments(*W, "Strings");
- for (uint32_t I = 0; I < Size; ++I) {
- printItemIndex("String", Indices[I]);
- }
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {
- uint16_t Props = static_cast<uint16_t>(Class.getOptions());
- W->printNumber("MemberCount", Class.getMemberCount());
- W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
- printTypeIndex("FieldList", Class.getFieldList());
- printTypeIndex("DerivedFrom", Class.getDerivationList());
- printTypeIndex("VShape", Class.getVTableShape());
- W->printNumber("SizeOf", Class.getSize());
- W->printString("Name", Class.getName());
- if (Props & uint16_t(ClassOptions::HasUniqueName))
- W->printString("LinkageName", Class.getUniqueName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {
- uint16_t Props = static_cast<uint16_t>(Union.getOptions());
- W->printNumber("MemberCount", Union.getMemberCount());
- W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
- printTypeIndex("FieldList", Union.getFieldList());
- W->printNumber("SizeOf", Union.getSize());
- W->printString("Name", Union.getName());
- if (Props & uint16_t(ClassOptions::HasUniqueName))
- W->printString("LinkageName", Union.getUniqueName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
- uint16_t Props = static_cast<uint16_t>(Enum.getOptions());
- W->printNumber("NumEnumerators", Enum.getMemberCount());
- W->printFlags("Properties", uint16_t(Enum.getOptions()),
- makeArrayRef(ClassOptionNames));
- printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
- printTypeIndex("FieldListType", Enum.getFieldList());
- W->printString("Name", Enum.getName());
- if (Props & uint16_t(ClassOptions::HasUniqueName))
- W->printString("LinkageName", Enum.getUniqueName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
- printTypeIndex("ElementType", AT.getElementType());
- printTypeIndex("IndexType", AT.getIndexType());
- W->printNumber("SizeOf", AT.getSize());
- W->printString("Name", AT.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {
- printTypeIndex("CompleteClass", VFT.getCompleteClass());
- printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
- W->printHex("VFPtrOffset", VFT.getVFPtrOffset());
- W->printString("VFTableName", VFT.getName());
- for (auto N : VFT.getMethodNames())
- W->printString("MethodName", N);
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {
- printTypeIndex("ClassType", Id.getClassType());
- printTypeIndex("FunctionType", Id.getFunctionType());
- W->printString("Name", Id.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {
- printTypeIndex("ReturnType", Proc.getReturnType());
- W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
- makeArrayRef(CallingConventions));
- W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
- makeArrayRef(FunctionOptionEnum));
- W->printNumber("NumParameters", Proc.getParameterCount());
- printTypeIndex("ArgListType", Proc.getArgumentList());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {
- printTypeIndex("ReturnType", MF.getReturnType());
- printTypeIndex("ClassType", MF.getClassType());
- printTypeIndex("ThisType", MF.getThisType());
- W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),
- makeArrayRef(CallingConventions));
- W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),
- makeArrayRef(FunctionOptionEnum));
- W->printNumber("NumParameters", MF.getParameterCount());
- printTypeIndex("ArgListType", MF.getArgumentList());
- W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
- MethodOverloadListRecord &MethodList) {
- for (auto &M : MethodList.getMethods()) {
- ListScope S(*W, "Method");
- printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());
- printTypeIndex("Type", M.getType());
- if (M.isIntroducingVirtual())
- W->printHex("VFTableOffset", M.getVFTableOffset());
- }
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {
- printItemIndex("ParentScope", Func.getParentScope());
- printTypeIndex("FunctionType", Func.getFunctionType());
- W->printString("Name", Func.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
- W->printString("Guid", formatv("{0}", TS.getGuid()).str());
- W->printNumber("Age", TS.getAge());
- W->printString("Name", TS.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
- printTypeIndex("PointeeType", Ptr.getReferentType());
- W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
- W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
- makeArrayRef(PtrKindNames));
- W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
-
- W->printNumber("IsFlat", Ptr.isFlat());
- W->printNumber("IsConst", Ptr.isConst());
- W->printNumber("IsVolatile", Ptr.isVolatile());
- W->printNumber("IsUnaligned", Ptr.isUnaligned());
- W->printNumber("IsRestrict", Ptr.isRestrict());
- W->printNumber("SizeOf", Ptr.getSize());
-
- if (Ptr.isPointerToMember()) {
- const MemberPointerInfo &MI = Ptr.getMemberInfo();
-
- printTypeIndex("ClassType", MI.getContainingType());
- W->printEnum("Representation", uint16_t(MI.getRepresentation()),
- makeArrayRef(PtrMemberRepNames));
- }
-
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
- uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
- printTypeIndex("ModifiedType", Mod.getModifiedType());
- W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));
-
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BitFieldRecord &BitField) {
- printTypeIndex("Type", BitField.getType());
- W->printNumber("BitSize", BitField.getBitSize());
- W->printNumber("BitOffset", BitField.getBitOffset());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
- VFTableShapeRecord &Shape) {
- W->printNumber("VFEntryCount", Shape.getEntryCount());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
- UdtSourceLineRecord &Line) {
- printTypeIndex("UDT", Line.getUDT());
- printItemIndex("SourceFile", Line.getSourceFile());
- W->printNumber("LineNumber", Line.getLineNumber());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,
- UdtModSourceLineRecord &Line) {
- printTypeIndex("UDT", Line.getUDT());
- printItemIndex("SourceFile", Line.getSourceFile());
- W->printNumber("LineNumber", Line.getLineNumber());
- W->printNumber("Module", Line.getModule());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {
- W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
-
- ListScope Arguments(*W, "Arguments");
- for (auto Arg : Args.getArgs()) {
- printItemIndex("ArgType", Arg);
- }
- return Error::success();
-}
-
-void TypeDumpVisitor::printMemberAttributes(MemberAttributes Attrs) {
- return printMemberAttributes(Attrs.getAccess(), Attrs.getMethodKind(),
- Attrs.getFlags());
-}
-
-void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,
- MethodKind Kind,
- MethodOptions Options) {
- W->printEnum("AccessSpecifier", uint8_t(Access),
- makeArrayRef(MemberAccessNames));
- // Data members will be vanilla. Don't try to print a method kind for them.
- if (Kind != MethodKind::Vanilla)
- W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));
- if (Options != MethodOptions::None) {
- W->printFlags("MethodOptions", unsigned(Options),
- makeArrayRef(MethodOptionNames));
- }
-}
-
-Error TypeDumpVisitor::visitUnknownMember(CVMemberRecord &Record) {
- W->printHex("UnknownMember", unsigned(Record.Kind));
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitUnknownType(CVType &Record) {
- W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames));
- W->printNumber("Length", uint32_t(Record.content().size()));
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- NestedTypeRecord &Nested) {
- printTypeIndex("Type", Nested.getNestedType());
- W->printString("Name", Nested.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- OneMethodRecord &Method) {
- MethodKind K = Method.getMethodKind();
- printMemberAttributes(Method.getAccess(), K, Method.getOptions());
- printTypeIndex("Type", Method.getType());
- // If virtual, then read the vftable offset.
- if (Method.isIntroducingVirtual())
- W->printHex("VFTableOffset", Method.getVFTableOffset());
- W->printString("Name", Method.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- OverloadedMethodRecord &Method) {
- W->printHex("MethodCount", Method.getNumOverloads());
- printTypeIndex("MethodListIndex", Method.getMethodList());
- W->printString("Name", Method.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- DataMemberRecord &Field) {
- printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
- MethodOptions::None);
- printTypeIndex("Type", Field.getType());
- W->printHex("FieldOffset", Field.getFieldOffset());
- W->printString("Name", Field.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- StaticDataMemberRecord &Field) {
- printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
- MethodOptions::None);
- printTypeIndex("Type", Field.getType());
- W->printString("Name", Field.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- VFPtrRecord &VFTable) {
- printTypeIndex("Type", VFTable.getType());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- EnumeratorRecord &Enum) {
- printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
- MethodOptions::None);
- W->printNumber("EnumValue", Enum.getValue());
- W->printString("Name", Enum.getName());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- BaseClassRecord &Base) {
- printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
- MethodOptions::None);
- printTypeIndex("BaseType", Base.getBaseType());
- W->printHex("BaseOffset", Base.getBaseOffset());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- VirtualBaseClassRecord &Base) {
- printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
- MethodOptions::None);
- printTypeIndex("BaseType", Base.getBaseType());
- printTypeIndex("VBPtrType", Base.getVBPtrType());
- W->printHex("VBPtrOffset", Base.getVBPtrOffset());
- W->printHex("VBTableIndex", Base.getVTableIndex());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- ListContinuationRecord &Cont) {
- printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());
- return Error::success();
-}
-
-Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {
- W->printEnum("Mode", uint16_t(LR.Mode), makeArrayRef(LabelTypeEnum));
- return Error::success();
-}
+//===-- TypeDumpVisitor.cpp - CodeView type info dumper ----------*- C++-*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"\r
+\r
+#include "llvm/ADT/SmallString.h"\r
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"\r
+#include "llvm/DebugInfo/CodeView/Formatters.h"\r
+#include "llvm/DebugInfo/CodeView/TypeCollection.h"\r
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"\r
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"\r
+#include "llvm/Support/FormatVariadic.h"\r
+#include "llvm/Support/ScopedPrinter.h"\r
+\r
+using namespace llvm;\r
+using namespace llvm::codeview;\r
+\r
+static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {\r
+#define CV_TYPE(enum, val) {#enum, enum},\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+};\r
+\r
+#define ENUM_ENTRY(enum_class, enum) \\r
+ { #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }\r
+\r
+static const EnumEntry<uint16_t> ClassOptionNames[] = {\r
+ ENUM_ENTRY(ClassOptions, Packed),\r
+ ENUM_ENTRY(ClassOptions, HasConstructorOrDestructor),\r
+ ENUM_ENTRY(ClassOptions, HasOverloadedOperator),\r
+ ENUM_ENTRY(ClassOptions, Nested),\r
+ ENUM_ENTRY(ClassOptions, ContainsNestedClass),\r
+ ENUM_ENTRY(ClassOptions, HasOverloadedAssignmentOperator),\r
+ ENUM_ENTRY(ClassOptions, HasConversionOperator),\r
+ ENUM_ENTRY(ClassOptions, ForwardReference),\r
+ ENUM_ENTRY(ClassOptions, Scoped),\r
+ ENUM_ENTRY(ClassOptions, HasUniqueName),\r
+ ENUM_ENTRY(ClassOptions, Sealed),\r
+ ENUM_ENTRY(ClassOptions, Intrinsic),\r
+};\r
+\r
+static const EnumEntry<uint8_t> MemberAccessNames[] = {\r
+ ENUM_ENTRY(MemberAccess, None), ENUM_ENTRY(MemberAccess, Private),\r
+ ENUM_ENTRY(MemberAccess, Protected), ENUM_ENTRY(MemberAccess, Public),\r
+};\r
+\r
+static const EnumEntry<uint16_t> MethodOptionNames[] = {\r
+ ENUM_ENTRY(MethodOptions, Pseudo),\r
+ ENUM_ENTRY(MethodOptions, NoInherit),\r
+ ENUM_ENTRY(MethodOptions, NoConstruct),\r
+ ENUM_ENTRY(MethodOptions, CompilerGenerated),\r
+ ENUM_ENTRY(MethodOptions, Sealed),\r
+};\r
+\r
+static const EnumEntry<uint16_t> MemberKindNames[] = {\r
+ ENUM_ENTRY(MethodKind, Vanilla),\r
+ ENUM_ENTRY(MethodKind, Virtual),\r
+ ENUM_ENTRY(MethodKind, Static),\r
+ ENUM_ENTRY(MethodKind, Friend),\r
+ ENUM_ENTRY(MethodKind, IntroducingVirtual),\r
+ ENUM_ENTRY(MethodKind, PureVirtual),\r
+ ENUM_ENTRY(MethodKind, PureIntroducingVirtual),\r
+};\r
+\r
+static const EnumEntry<uint8_t> PtrKindNames[] = {\r
+ ENUM_ENTRY(PointerKind, Near16),\r
+ ENUM_ENTRY(PointerKind, Far16),\r
+ ENUM_ENTRY(PointerKind, Huge16),\r
+ ENUM_ENTRY(PointerKind, BasedOnSegment),\r
+ ENUM_ENTRY(PointerKind, BasedOnValue),\r
+ ENUM_ENTRY(PointerKind, BasedOnSegmentValue),\r
+ ENUM_ENTRY(PointerKind, BasedOnAddress),\r
+ ENUM_ENTRY(PointerKind, BasedOnSegmentAddress),\r
+ ENUM_ENTRY(PointerKind, BasedOnType),\r
+ ENUM_ENTRY(PointerKind, BasedOnSelf),\r
+ ENUM_ENTRY(PointerKind, Near32),\r
+ ENUM_ENTRY(PointerKind, Far32),\r
+ ENUM_ENTRY(PointerKind, Near64),\r
+};\r
+\r
+static const EnumEntry<uint8_t> PtrModeNames[] = {\r
+ ENUM_ENTRY(PointerMode, Pointer),\r
+ ENUM_ENTRY(PointerMode, LValueReference),\r
+ ENUM_ENTRY(PointerMode, PointerToDataMember),\r
+ ENUM_ENTRY(PointerMode, PointerToMemberFunction),\r
+ ENUM_ENTRY(PointerMode, RValueReference),\r
+};\r
+\r
+static const EnumEntry<uint16_t> PtrMemberRepNames[] = {\r
+ ENUM_ENTRY(PointerToMemberRepresentation, Unknown),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceData),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceData),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceData),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, GeneralData),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, SingleInheritanceFunction),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceFunction),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceFunction),\r
+ ENUM_ENTRY(PointerToMemberRepresentation, GeneralFunction),\r
+};\r
+\r
+static const EnumEntry<uint16_t> TypeModifierNames[] = {\r
+ ENUM_ENTRY(ModifierOptions, Const), ENUM_ENTRY(ModifierOptions, Volatile),\r
+ ENUM_ENTRY(ModifierOptions, Unaligned),\r
+};\r
+\r
+static const EnumEntry<uint8_t> CallingConventions[] = {\r
+ ENUM_ENTRY(CallingConvention, NearC),\r
+ ENUM_ENTRY(CallingConvention, FarC),\r
+ ENUM_ENTRY(CallingConvention, NearPascal),\r
+ ENUM_ENTRY(CallingConvention, FarPascal),\r
+ ENUM_ENTRY(CallingConvention, NearFast),\r
+ ENUM_ENTRY(CallingConvention, FarFast),\r
+ ENUM_ENTRY(CallingConvention, NearStdCall),\r
+ ENUM_ENTRY(CallingConvention, FarStdCall),\r
+ ENUM_ENTRY(CallingConvention, NearSysCall),\r
+ ENUM_ENTRY(CallingConvention, FarSysCall),\r
+ ENUM_ENTRY(CallingConvention, ThisCall),\r
+ ENUM_ENTRY(CallingConvention, MipsCall),\r
+ ENUM_ENTRY(CallingConvention, Generic),\r
+ ENUM_ENTRY(CallingConvention, AlphaCall),\r
+ ENUM_ENTRY(CallingConvention, PpcCall),\r
+ ENUM_ENTRY(CallingConvention, SHCall),\r
+ ENUM_ENTRY(CallingConvention, ArmCall),\r
+ ENUM_ENTRY(CallingConvention, AM33Call),\r
+ ENUM_ENTRY(CallingConvention, TriCall),\r
+ ENUM_ENTRY(CallingConvention, SH5Call),\r
+ ENUM_ENTRY(CallingConvention, M32RCall),\r
+ ENUM_ENTRY(CallingConvention, ClrCall),\r
+ ENUM_ENTRY(CallingConvention, Inline),\r
+ ENUM_ENTRY(CallingConvention, NearVector),\r
+};\r
+\r
+static const EnumEntry<uint8_t> FunctionOptionEnum[] = {\r
+ ENUM_ENTRY(FunctionOptions, CxxReturnUdt),\r
+ ENUM_ENTRY(FunctionOptions, Constructor),\r
+ ENUM_ENTRY(FunctionOptions, ConstructorWithVirtualBases),\r
+};\r
+\r
+static const EnumEntry<uint16_t> LabelTypeEnum[] = {\r
+ ENUM_ENTRY(LabelType, Near), ENUM_ENTRY(LabelType, Far),\r
+};\r
+\r
+#undef ENUM_ENTRY\r
+\r
+static StringRef getLeafTypeName(TypeLeafKind LT) {\r
+ switch (LT) {\r
+#define TYPE_RECORD(ename, value, name) \\r
+ case ename: \\r
+ return #name;\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+ default:\r
+ break;\r
+ }\r
+ return "UnknownLeaf";\r
+}\r
+\r
+void TypeDumpVisitor::printTypeIndex(StringRef FieldName, TypeIndex TI) const {\r
+ codeview::printTypeIndex(*W, FieldName, TI, TpiTypes);\r
+}\r
+\r
+void TypeDumpVisitor::printItemIndex(StringRef FieldName, TypeIndex TI) const {\r
+ codeview::printTypeIndex(*W, FieldName, TI, getSourceTypes());\r
+}\r
+\r
+Error TypeDumpVisitor::visitTypeBegin(CVType &Record) {\r
+ return visitTypeBegin(Record, TypeIndex::fromArrayIndex(TpiTypes.size()));\r
+}\r
+\r
+Error TypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {\r
+ W->startLine() << getLeafTypeName(Record.Type);\r
+ W->getOStream() << " (" << HexNumber(Index.getIndex()) << ")";\r
+ W->getOStream() << " {\n";\r
+ W->indent();\r
+ W->printEnum("TypeLeafKind", unsigned(Record.Type),\r
+ makeArrayRef(LeafTypeNames));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitTypeEnd(CVType &Record) {\r
+ if (PrintRecordBytes)\r
+ W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.content()));\r
+\r
+ W->unindent();\r
+ W->startLine() << "}\n";\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {\r
+ W->startLine() << getLeafTypeName(Record.Kind);\r
+ W->getOStream() << " {\n";\r
+ W->indent();\r
+ W->printEnum("TypeLeafKind", unsigned(Record.Kind),\r
+ makeArrayRef(LeafTypeNames));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {\r
+ if (PrintRecordBytes)\r
+ W->printBinaryBlock("LeafData", getBytesAsCharacters(Record.Data));\r
+\r
+ W->unindent();\r
+ W->startLine() << "}\n";\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ FieldListRecord &FieldList) {\r
+ if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))\r
+ return EC;\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringIdRecord &String) {\r
+ printItemIndex("Id", String.getId());\r
+ W->printString("StringData", String.getString());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {\r
+ auto Indices = Args.getIndices();\r
+ uint32_t Size = Indices.size();\r
+ W->printNumber("NumArgs", Size);\r
+ ListScope Arguments(*W, "Arguments");\r
+ for (uint32_t I = 0; I < Size; ++I) {\r
+ printTypeIndex("ArgType", Indices[I]);\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, StringListRecord &Strs) {\r
+ auto Indices = Strs.getIndices();\r
+ uint32_t Size = Indices.size();\r
+ W->printNumber("NumStrings", Size);\r
+ ListScope Arguments(*W, "Strings");\r
+ for (uint32_t I = 0; I < Size; ++I) {\r
+ printItemIndex("String", Indices[I]);\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ClassRecord &Class) {\r
+ uint16_t Props = static_cast<uint16_t>(Class.getOptions());\r
+ W->printNumber("MemberCount", Class.getMemberCount());\r
+ W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));\r
+ printTypeIndex("FieldList", Class.getFieldList());\r
+ printTypeIndex("DerivedFrom", Class.getDerivationList());\r
+ printTypeIndex("VShape", Class.getVTableShape());\r
+ W->printNumber("SizeOf", Class.getSize());\r
+ W->printString("Name", Class.getName());\r
+ if (Props & uint16_t(ClassOptions::HasUniqueName))\r
+ W->printString("LinkageName", Class.getUniqueName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, UnionRecord &Union) {\r
+ uint16_t Props = static_cast<uint16_t>(Union.getOptions());\r
+ W->printNumber("MemberCount", Union.getMemberCount());\r
+ W->printFlags("Properties", Props, makeArrayRef(ClassOptionNames));\r
+ printTypeIndex("FieldList", Union.getFieldList());\r
+ W->printNumber("SizeOf", Union.getSize());\r
+ W->printString("Name", Union.getName());\r
+ if (Props & uint16_t(ClassOptions::HasUniqueName))\r
+ W->printString("LinkageName", Union.getUniqueName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {\r
+ uint16_t Props = static_cast<uint16_t>(Enum.getOptions());\r
+ W->printNumber("NumEnumerators", Enum.getMemberCount());\r
+ W->printFlags("Properties", uint16_t(Enum.getOptions()),\r
+ makeArrayRef(ClassOptionNames));\r
+ printTypeIndex("UnderlyingType", Enum.getUnderlyingType());\r
+ printTypeIndex("FieldListType", Enum.getFieldList());\r
+ W->printString("Name", Enum.getName());\r
+ if (Props & uint16_t(ClassOptions::HasUniqueName))\r
+ W->printString("LinkageName", Enum.getUniqueName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {\r
+ printTypeIndex("ElementType", AT.getElementType());\r
+ printTypeIndex("IndexType", AT.getIndexType());\r
+ W->printNumber("SizeOf", AT.getSize());\r
+ W->printString("Name", AT.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {\r
+ printTypeIndex("CompleteClass", VFT.getCompleteClass());\r
+ printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());\r
+ W->printHex("VFPtrOffset", VFT.getVFPtrOffset());\r
+ W->printString("VFTableName", VFT.getName());\r
+ for (auto N : VFT.getMethodNames())\r
+ W->printString("MethodName", N);\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {\r
+ printTypeIndex("ClassType", Id.getClassType());\r
+ printTypeIndex("FunctionType", Id.getFunctionType());\r
+ W->printString("Name", Id.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {\r
+ printTypeIndex("ReturnType", Proc.getReturnType());\r
+ W->printEnum("CallingConvention", uint8_t(Proc.getCallConv()),\r
+ makeArrayRef(CallingConventions));\r
+ W->printFlags("FunctionOptions", uint8_t(Proc.getOptions()),\r
+ makeArrayRef(FunctionOptionEnum));\r
+ W->printNumber("NumParameters", Proc.getParameterCount());\r
+ printTypeIndex("ArgListType", Proc.getArgumentList());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, MemberFunctionRecord &MF) {\r
+ printTypeIndex("ReturnType", MF.getReturnType());\r
+ printTypeIndex("ClassType", MF.getClassType());\r
+ printTypeIndex("ThisType", MF.getThisType());\r
+ W->printEnum("CallingConvention", uint8_t(MF.getCallConv()),\r
+ makeArrayRef(CallingConventions));\r
+ W->printFlags("FunctionOptions", uint8_t(MF.getOptions()),\r
+ makeArrayRef(FunctionOptionEnum));\r
+ W->printNumber("NumParameters", MF.getParameterCount());\r
+ printTypeIndex("ArgListType", MF.getArgumentList());\r
+ W->printNumber("ThisAdjustment", MF.getThisPointerAdjustment());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ MethodOverloadListRecord &MethodList) {\r
+ for (auto &M : MethodList.getMethods()) {\r
+ ListScope S(*W, "Method");\r
+ printMemberAttributes(M.getAccess(), M.getMethodKind(), M.getOptions());\r
+ printTypeIndex("Type", M.getType());\r
+ if (M.isIntroducingVirtual())\r
+ W->printHex("VFTableOffset", M.getVFTableOffset());\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {\r
+ printItemIndex("ParentScope", Func.getParentScope());\r
+ printTypeIndex("FunctionType", Func.getFunctionType());\r
+ W->printString("Name", Func.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {\r
+ W->printString("Guid", formatv("{0}", TS.getGuid()).str());\r
+ W->printNumber("Age", TS.getAge());\r
+ W->printString("Name", TS.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {\r
+ printTypeIndex("PointeeType", Ptr.getReferentType());\r
+ W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));\r
+ W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),\r
+ makeArrayRef(PtrKindNames));\r
+ W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));\r
+\r
+ W->printNumber("IsFlat", Ptr.isFlat());\r
+ W->printNumber("IsConst", Ptr.isConst());\r
+ W->printNumber("IsVolatile", Ptr.isVolatile());\r
+ W->printNumber("IsUnaligned", Ptr.isUnaligned());\r
+ W->printNumber("IsRestrict", Ptr.isRestrict());\r
+ W->printNumber("SizeOf", Ptr.getSize());\r
+\r
+ if (Ptr.isPointerToMember()) {\r
+ const MemberPointerInfo &MI = Ptr.getMemberInfo();\r
+\r
+ printTypeIndex("ClassType", MI.getContainingType());\r
+ W->printEnum("Representation", uint16_t(MI.getRepresentation()),\r
+ makeArrayRef(PtrMemberRepNames));\r
+ }\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {\r
+ uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());\r
+ printTypeIndex("ModifiedType", Mod.getModifiedType());\r
+ W->printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BitFieldRecord &BitField) {\r
+ printTypeIndex("Type", BitField.getType());\r
+ W->printNumber("BitSize", BitField.getBitSize());\r
+ W->printNumber("BitOffset", BitField.getBitOffset());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ VFTableShapeRecord &Shape) {\r
+ W->printNumber("VFEntryCount", Shape.getEntryCount());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ UdtSourceLineRecord &Line) {\r
+ printTypeIndex("UDT", Line.getUDT());\r
+ printItemIndex("SourceFile", Line.getSourceFile());\r
+ W->printNumber("LineNumber", Line.getLineNumber());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ UdtModSourceLineRecord &Line) {\r
+ printTypeIndex("UDT", Line.getUDT());\r
+ printItemIndex("SourceFile", Line.getSourceFile());\r
+ W->printNumber("LineNumber", Line.getLineNumber());\r
+ W->printNumber("Module", Line.getModule());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, BuildInfoRecord &Args) {\r
+ W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));\r
+\r
+ ListScope Arguments(*W, "Arguments");\r
+ for (auto Arg : Args.getArgs()) {\r
+ printItemIndex("ArgType", Arg);\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+void TypeDumpVisitor::printMemberAttributes(MemberAttributes Attrs) {\r
+ return printMemberAttributes(Attrs.getAccess(), Attrs.getMethodKind(),\r
+ Attrs.getFlags());\r
+}\r
+\r
+void TypeDumpVisitor::printMemberAttributes(MemberAccess Access,\r
+ MethodKind Kind,\r
+ MethodOptions Options) {\r
+ W->printEnum("AccessSpecifier", uint8_t(Access),\r
+ makeArrayRef(MemberAccessNames));\r
+ // Data members will be vanilla. Don't try to print a method kind for them.\r
+ if (Kind != MethodKind::Vanilla)\r
+ W->printEnum("MethodKind", unsigned(Kind), makeArrayRef(MemberKindNames));\r
+ if (Options != MethodOptions::None) {\r
+ W->printFlags("MethodOptions", unsigned(Options),\r
+ makeArrayRef(MethodOptionNames));\r
+ }\r
+}\r
+\r
+Error TypeDumpVisitor::visitUnknownMember(CVMemberRecord &Record) {\r
+ W->printHex("UnknownMember", unsigned(Record.Kind));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitUnknownType(CVType &Record) {\r
+ W->printEnum("Kind", uint16_t(Record.kind()), makeArrayRef(LeafTypeNames));\r
+ W->printNumber("Length", uint32_t(Record.content().size()));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ NestedTypeRecord &Nested) {\r
+ printTypeIndex("Type", Nested.getNestedType());\r
+ W->printString("Name", Nested.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ OneMethodRecord &Method) {\r
+ MethodKind K = Method.getMethodKind();\r
+ printMemberAttributes(Method.getAccess(), K, Method.getOptions());\r
+ printTypeIndex("Type", Method.getType());\r
+ // If virtual, then read the vftable offset.\r
+ if (Method.isIntroducingVirtual())\r
+ W->printHex("VFTableOffset", Method.getVFTableOffset());\r
+ W->printString("Name", Method.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ OverloadedMethodRecord &Method) {\r
+ W->printHex("MethodCount", Method.getNumOverloads());\r
+ printTypeIndex("MethodListIndex", Method.getMethodList());\r
+ W->printString("Name", Method.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ DataMemberRecord &Field) {\r
+ printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,\r
+ MethodOptions::None);\r
+ printTypeIndex("Type", Field.getType());\r
+ W->printHex("FieldOffset", Field.getFieldOffset());\r
+ W->printString("Name", Field.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ StaticDataMemberRecord &Field) {\r
+ printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,\r
+ MethodOptions::None);\r
+ printTypeIndex("Type", Field.getType());\r
+ W->printString("Name", Field.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ VFPtrRecord &VFTable) {\r
+ printTypeIndex("Type", VFTable.getType());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ EnumeratorRecord &Enum) {\r
+ printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,\r
+ MethodOptions::None);\r
+ W->printNumber("EnumValue", Enum.getValue());\r
+ W->printString("Name", Enum.getName());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ BaseClassRecord &Base) {\r
+ printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,\r
+ MethodOptions::None);\r
+ printTypeIndex("BaseType", Base.getBaseType());\r
+ W->printHex("BaseOffset", Base.getBaseOffset());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ VirtualBaseClassRecord &Base) {\r
+ printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,\r
+ MethodOptions::None);\r
+ printTypeIndex("BaseType", Base.getBaseType());\r
+ printTypeIndex("VBPtrType", Base.getVBPtrType());\r
+ W->printHex("VBPtrOffset", Base.getVBPtrOffset());\r
+ W->printHex("VBTableIndex", Base.getVTableIndex());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ ListContinuationRecord &Cont) {\r
+ printTypeIndex("ContinuationIndex", Cont.getContinuationIndex());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &LR) {\r
+ W->printEnum("Mode", uint16_t(LR.Mode), makeArrayRef(LabelTypeEnum));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ PrecompRecord &Precomp) {\r
+ W->printHex("StartIndex", Precomp.getStartTypeIndex());\r
+ W->printHex("Count", Precomp.getTypesCount());\r
+ W->printHex("Signature", Precomp.getSignature());\r
+ W->printString("PrecompFile", Precomp.getPrecompFilePath());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ EndPrecompRecord &EndPrecomp) {\r
+ W->printHex("Signature", EndPrecomp.getSignature());\r
+ return Error::success();\r
+}\r
-//===- TypeRecordMapping.cpp ------------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-
-#define error(X) \
- if (auto EC = X) \
- return EC;
-
-namespace {
-struct MapOneMethodRecord {
- explicit MapOneMethodRecord(bool IsFromOverloadList)
- : IsFromOverloadList(IsFromOverloadList) {}
-
- Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {
- error(IO.mapInteger(Method.Attrs.Attrs));
- if (IsFromOverloadList) {
- uint16_t Padding = 0;
- error(IO.mapInteger(Padding));
- }
- error(IO.mapInteger(Method.Type));
- if (Method.isIntroducingVirtual()) {
- error(IO.mapInteger(Method.VFTableOffset));
- } else if (!IO.isWriting())
- Method.VFTableOffset = -1;
-
- if (!IsFromOverloadList)
- error(IO.mapStringZ(Method.Name));
-
- return Error::success();
- }
-
-private:
- bool IsFromOverloadList;
-};
-}
-
-static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,
- StringRef &UniqueName, bool HasUniqueName) {
- if (IO.isWriting()) {
- // Try to be smart about what we write here. We can't write anything too
- // large, so if we're going to go over the limit, truncate both the name
- // and unique name by the same amount.
- size_t BytesLeft = IO.maxFieldLength();
- if (HasUniqueName) {
- size_t BytesNeeded = Name.size() + UniqueName.size() + 2;
- StringRef N = Name;
- StringRef U = UniqueName;
- if (BytesNeeded > BytesLeft) {
- size_t BytesToDrop = (BytesNeeded - BytesLeft);
- size_t DropN = std::min(N.size(), BytesToDrop / 2);
- size_t DropU = std::min(U.size(), BytesToDrop - DropN);
-
- N = N.drop_back(DropN);
- U = U.drop_back(DropU);
- }
-
- error(IO.mapStringZ(N));
- error(IO.mapStringZ(U));
- } else {
- // Cap the length of the string at however many bytes we have available,
- // plus one for the required null terminator.
- auto N = StringRef(Name).take_front(BytesLeft - 1);
- error(IO.mapStringZ(N));
- }
- } else {
- error(IO.mapStringZ(Name));
- if (HasUniqueName)
- error(IO.mapStringZ(UniqueName));
- }
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {
- assert(!TypeKind.hasValue() && "Already in a type mapping!");
- assert(!MemberKind.hasValue() && "Already in a member mapping!");
-
- // FieldList and MethodList records can be any length because they can be
- // split with continuation records. All other record types cannot be
- // longer than the maximum record length.
- Optional<uint32_t> MaxLen;
- if (CVR.Type != TypeLeafKind::LF_FIELDLIST &&
- CVR.Type != TypeLeafKind::LF_METHODLIST)
- MaxLen = MaxRecordLength - sizeof(RecordPrefix);
- error(IO.beginRecord(MaxLen));
- TypeKind = CVR.Type;
- return Error::success();
-}
-
-Error TypeRecordMapping::visitTypeEnd(CVType &Record) {
- assert(TypeKind.hasValue() && "Not in a type mapping!");
- assert(!MemberKind.hasValue() && "Still in a member mapping!");
-
- error(IO.endRecord());
-
- TypeKind.reset();
- return Error::success();
-}
-
-Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {
- assert(TypeKind.hasValue() && "Not in a type mapping!");
- assert(!MemberKind.hasValue() && "Already in a member mapping!");
-
- // The largest possible subrecord is one in which there is a record prefix,
- // followed by the subrecord, followed by a continuation, and that entire
- // sequence spaws `MaxRecordLength` bytes. So the record's length is
- // calculated as follows.
- constexpr uint32_t ContinuationLength = 8;
- error(IO.beginRecord(MaxRecordLength - sizeof(RecordPrefix) -
- ContinuationLength));
-
- MemberKind = Record.Kind;
- return Error::success();
-}
-
-Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {
- assert(TypeKind.hasValue() && "Not in a type mapping!");
- assert(MemberKind.hasValue() && "Not in a member mapping!");
-
- if (!IO.isWriting()) {
- if (auto EC = IO.skipPadding())
- return EC;
- }
-
- MemberKind.reset();
- error(IO.endRecord());
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {
- error(IO.mapInteger(Record.ModifiedType));
- error(IO.mapEnum(Record.Modifiers));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- ProcedureRecord &Record) {
- error(IO.mapInteger(Record.ReturnType));
- error(IO.mapEnum(Record.CallConv));
- error(IO.mapEnum(Record.Options));
- error(IO.mapInteger(Record.ParameterCount));
- error(IO.mapInteger(Record.ArgumentList));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- MemberFunctionRecord &Record) {
- error(IO.mapInteger(Record.ReturnType));
- error(IO.mapInteger(Record.ClassType));
- error(IO.mapInteger(Record.ThisType));
- error(IO.mapEnum(Record.CallConv));
- error(IO.mapEnum(Record.Options));
- error(IO.mapInteger(Record.ParameterCount));
- error(IO.mapInteger(Record.ArgumentList));
- error(IO.mapInteger(Record.ThisPointerAdjustment));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {
- error(IO.mapVectorN<uint32_t>(
- Record.ArgIndices,
- [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- StringListRecord &Record) {
- error(IO.mapVectorN<uint32_t>(
- Record.StringIndices,
- [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {
- error(IO.mapInteger(Record.ReferentType));
- error(IO.mapInteger(Record.Attrs));
-
- if (Record.isPointerToMember()) {
- if (!IO.isWriting())
- Record.MemberInfo.emplace();
-
- MemberPointerInfo &M = *Record.MemberInfo;
- error(IO.mapInteger(M.ContainingType));
- error(IO.mapEnum(M.Representation));
- }
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {
- error(IO.mapInteger(Record.ElementType));
- error(IO.mapInteger(Record.IndexType));
- error(IO.mapEncodedInteger(Record.Size));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ClassRecord &Record) {
- assert((CVR.Type == TypeLeafKind::LF_STRUCTURE) ||
- (CVR.Type == TypeLeafKind::LF_CLASS) ||
- (CVR.Type == TypeLeafKind::LF_INTERFACE));
-
- error(IO.mapInteger(Record.MemberCount));
- error(IO.mapEnum(Record.Options));
- error(IO.mapInteger(Record.FieldList));
- error(IO.mapInteger(Record.DerivationList));
- error(IO.mapInteger(Record.VTableShape));
- error(IO.mapEncodedInteger(Record.Size));
- error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
- Record.hasUniqueName()));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {
- error(IO.mapInteger(Record.MemberCount));
- error(IO.mapEnum(Record.Options));
- error(IO.mapInteger(Record.FieldList));
- error(IO.mapEncodedInteger(Record.Size));
- error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
- Record.hasUniqueName()));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {
- error(IO.mapInteger(Record.MemberCount));
- error(IO.mapEnum(Record.Options));
- error(IO.mapInteger(Record.UnderlyingType));
- error(IO.mapInteger(Record.FieldList));
- error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,
- Record.hasUniqueName()));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, BitFieldRecord &Record) {
- error(IO.mapInteger(Record.Type));
- error(IO.mapInteger(Record.BitSize));
- error(IO.mapInteger(Record.BitOffset));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- VFTableShapeRecord &Record) {
- uint16_t Size;
- if (IO.isWriting()) {
- ArrayRef<VFTableSlotKind> Slots = Record.getSlots();
- Size = Slots.size();
- error(IO.mapInteger(Size));
-
- for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {
- uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;
- if ((SlotIndex + 1) < Slots.size()) {
- Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);
- }
- error(IO.mapInteger(Byte));
- }
- } else {
- error(IO.mapInteger(Size));
- for (uint16_t I = 0; I < Size; I += 2) {
- uint8_t Byte;
- error(IO.mapInteger(Byte));
- Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));
- if ((I + 1) < Size)
- Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));
- }
- }
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {
- error(IO.mapInteger(Record.CompleteClass));
- error(IO.mapInteger(Record.OverriddenVFTable));
- error(IO.mapInteger(Record.VFPtrOffset));
- uint32_t NamesLen = 0;
- if (IO.isWriting()) {
- for (auto Name : Record.MethodNames)
- NamesLen += Name.size() + 1;
- }
- error(IO.mapInteger(NamesLen));
- error(IO.mapVectorTail(
- Record.MethodNames,
- [](CodeViewRecordIO &IO, StringRef &S) { return IO.mapStringZ(S); }));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {
- error(IO.mapInteger(Record.Id));
- error(IO.mapStringZ(Record.String));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- UdtSourceLineRecord &Record) {
- error(IO.mapInteger(Record.UDT));
- error(IO.mapInteger(Record.SourceFile));
- error(IO.mapInteger(Record.LineNumber));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- UdtModSourceLineRecord &Record) {
- error(IO.mapInteger(Record.UDT));
- error(IO.mapInteger(Record.SourceFile));
- error(IO.mapInteger(Record.LineNumber));
- error(IO.mapInteger(Record.Module));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, FuncIdRecord &Record) {
- error(IO.mapInteger(Record.ParentScope));
- error(IO.mapInteger(Record.FunctionType));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- MemberFuncIdRecord &Record) {
- error(IO.mapInteger(Record.ClassType));
- error(IO.mapInteger(Record.FunctionType));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- BuildInfoRecord &Record) {
- error(IO.mapVectorN<uint16_t>(
- Record.ArgIndices,
- [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- MethodOverloadListRecord &Record) {
- // TODO: Split the list into multiple records if it's longer than 64KB, using
- // a subrecord of TypeRecordKind::Index to chain the records together.
- error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true)));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- FieldListRecord &Record) {
- error(IO.mapByteVectorTail(Record.Data));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR,
- TypeServer2Record &Record) {
- error(IO.mapGuid(Record.Guid));
- error(IO.mapInteger(Record.Age));
- error(IO.mapStringZ(Record.Name));
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {
- error(IO.mapEnum(Record.Mode));
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- BaseClassRecord &Record) {
- error(IO.mapInteger(Record.Attrs.Attrs));
- error(IO.mapInteger(Record.Type));
- error(IO.mapEncodedInteger(Record.Offset));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- EnumeratorRecord &Record) {
- error(IO.mapInteger(Record.Attrs.Attrs));
-
- // FIXME: Handle full APInt such as __int128.
- error(IO.mapEncodedInteger(Record.Value));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- DataMemberRecord &Record) {
- error(IO.mapInteger(Record.Attrs.Attrs));
- error(IO.mapInteger(Record.Type));
- error(IO.mapEncodedInteger(Record.FieldOffset));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- OverloadedMethodRecord &Record) {
- error(IO.mapInteger(Record.NumOverloads));
- error(IO.mapInteger(Record.MethodList));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- OneMethodRecord &Record) {
- const bool IsFromOverloadList = (TypeKind == LF_METHODLIST);
- MapOneMethodRecord Mapper(IsFromOverloadList);
- return Mapper(IO, Record);
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- NestedTypeRecord &Record) {
- uint16_t Padding = 0;
- error(IO.mapInteger(Padding));
- error(IO.mapInteger(Record.Type));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- StaticDataMemberRecord &Record) {
-
- error(IO.mapInteger(Record.Attrs.Attrs));
- error(IO.mapInteger(Record.Type));
- error(IO.mapStringZ(Record.Name));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- VirtualBaseClassRecord &Record) {
-
- error(IO.mapInteger(Record.Attrs.Attrs));
- error(IO.mapInteger(Record.BaseType));
- error(IO.mapInteger(Record.VBPtrType));
- error(IO.mapEncodedInteger(Record.VBPtrOffset));
- error(IO.mapEncodedInteger(Record.VTableIndex));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- VFPtrRecord &Record) {
- uint16_t Padding = 0;
- error(IO.mapInteger(Padding));
- error(IO.mapInteger(Record.Type));
-
- return Error::success();
-}
-
-Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,
- ListContinuationRecord &Record) {
- uint16_t Padding = 0;
- error(IO.mapInteger(Padding));
- error(IO.mapInteger(Record.ContinuationIndex));
-
- return Error::success();
-}
+//===- TypeRecordMapping.cpp ------------------------------------*- C++ -*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"\r
+\r
+using namespace llvm;\r
+using namespace llvm::codeview;\r
+\r
+#define error(X) \\r
+ if (auto EC = X) \\r
+ return EC;\r
+\r
+namespace {\r
+struct MapOneMethodRecord {\r
+ explicit MapOneMethodRecord(bool IsFromOverloadList)\r
+ : IsFromOverloadList(IsFromOverloadList) {}\r
+\r
+ Error operator()(CodeViewRecordIO &IO, OneMethodRecord &Method) const {\r
+ error(IO.mapInteger(Method.Attrs.Attrs));\r
+ if (IsFromOverloadList) {\r
+ uint16_t Padding = 0;\r
+ error(IO.mapInteger(Padding));\r
+ }\r
+ error(IO.mapInteger(Method.Type));\r
+ if (Method.isIntroducingVirtual()) {\r
+ error(IO.mapInteger(Method.VFTableOffset));\r
+ } else if (!IO.isWriting())\r
+ Method.VFTableOffset = -1;\r
+\r
+ if (!IsFromOverloadList)\r
+ error(IO.mapStringZ(Method.Name));\r
+\r
+ return Error::success();\r
+ }\r
+\r
+private:\r
+ bool IsFromOverloadList;\r
+};\r
+}\r
+\r
+static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name,\r
+ StringRef &UniqueName, bool HasUniqueName) {\r
+ if (IO.isWriting()) {\r
+ // Try to be smart about what we write here. We can't write anything too\r
+ // large, so if we're going to go over the limit, truncate both the name\r
+ // and unique name by the same amount.\r
+ size_t BytesLeft = IO.maxFieldLength();\r
+ if (HasUniqueName) {\r
+ size_t BytesNeeded = Name.size() + UniqueName.size() + 2;\r
+ StringRef N = Name;\r
+ StringRef U = UniqueName;\r
+ if (BytesNeeded > BytesLeft) {\r
+ size_t BytesToDrop = (BytesNeeded - BytesLeft);\r
+ size_t DropN = std::min(N.size(), BytesToDrop / 2);\r
+ size_t DropU = std::min(U.size(), BytesToDrop - DropN);\r
+\r
+ N = N.drop_back(DropN);\r
+ U = U.drop_back(DropU);\r
+ }\r
+\r
+ error(IO.mapStringZ(N));\r
+ error(IO.mapStringZ(U));\r
+ } else {\r
+ // Cap the length of the string at however many bytes we have available,\r
+ // plus one for the required null terminator.\r
+ auto N = StringRef(Name).take_front(BytesLeft - 1);\r
+ error(IO.mapStringZ(N));\r
+ }\r
+ } else {\r
+ error(IO.mapStringZ(Name));\r
+ if (HasUniqueName)\r
+ error(IO.mapStringZ(UniqueName));\r
+ }\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitTypeBegin(CVType &CVR) {\r
+ assert(!TypeKind.hasValue() && "Already in a type mapping!");\r
+ assert(!MemberKind.hasValue() && "Already in a member mapping!");\r
+\r
+ // FieldList and MethodList records can be any length because they can be\r
+ // split with continuation records. All other record types cannot be\r
+ // longer than the maximum record length.\r
+ Optional<uint32_t> MaxLen;\r
+ if (CVR.Type != TypeLeafKind::LF_FIELDLIST &&\r
+ CVR.Type != TypeLeafKind::LF_METHODLIST)\r
+ MaxLen = MaxRecordLength - sizeof(RecordPrefix);\r
+ error(IO.beginRecord(MaxLen));\r
+ TypeKind = CVR.Type;\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitTypeEnd(CVType &Record) {\r
+ assert(TypeKind.hasValue() && "Not in a type mapping!");\r
+ assert(!MemberKind.hasValue() && "Still in a member mapping!");\r
+\r
+ error(IO.endRecord());\r
+\r
+ TypeKind.reset();\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) {\r
+ assert(TypeKind.hasValue() && "Not in a type mapping!");\r
+ assert(!MemberKind.hasValue() && "Already in a member mapping!");\r
+\r
+ // The largest possible subrecord is one in which there is a record prefix,\r
+ // followed by the subrecord, followed by a continuation, and that entire\r
+ // sequence spaws `MaxRecordLength` bytes. So the record's length is\r
+ // calculated as follows.\r
+ constexpr uint32_t ContinuationLength = 8;\r
+ error(IO.beginRecord(MaxRecordLength - sizeof(RecordPrefix) -\r
+ ContinuationLength));\r
+\r
+ MemberKind = Record.Kind;\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) {\r
+ assert(TypeKind.hasValue() && "Not in a type mapping!");\r
+ assert(MemberKind.hasValue() && "Not in a member mapping!");\r
+\r
+ if (!IO.isWriting()) {\r
+ if (auto EC = IO.skipPadding())\r
+ return EC;\r
+ }\r
+\r
+ MemberKind.reset();\r
+ error(IO.endRecord());\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ModifierRecord &Record) {\r
+ error(IO.mapInteger(Record.ModifiedType));\r
+ error(IO.mapEnum(Record.Modifiers));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ ProcedureRecord &Record) {\r
+ error(IO.mapInteger(Record.ReturnType));\r
+ error(IO.mapEnum(Record.CallConv));\r
+ error(IO.mapEnum(Record.Options));\r
+ error(IO.mapInteger(Record.ParameterCount));\r
+ error(IO.mapInteger(Record.ArgumentList));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ MemberFunctionRecord &Record) {\r
+ error(IO.mapInteger(Record.ReturnType));\r
+ error(IO.mapInteger(Record.ClassType));\r
+ error(IO.mapInteger(Record.ThisType));\r
+ error(IO.mapEnum(Record.CallConv));\r
+ error(IO.mapEnum(Record.Options));\r
+ error(IO.mapInteger(Record.ParameterCount));\r
+ error(IO.mapInteger(Record.ArgumentList));\r
+ error(IO.mapInteger(Record.ThisPointerAdjustment));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArgListRecord &Record) {\r
+ error(IO.mapVectorN<uint32_t>(\r
+ Record.ArgIndices,\r
+ [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ StringListRecord &Record) {\r
+ error(IO.mapVectorN<uint32_t>(\r
+ Record.StringIndices,\r
+ [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, PointerRecord &Record) {\r
+ error(IO.mapInteger(Record.ReferentType));\r
+ error(IO.mapInteger(Record.Attrs));\r
+\r
+ if (Record.isPointerToMember()) {\r
+ if (!IO.isWriting())\r
+ Record.MemberInfo.emplace();\r
+\r
+ MemberPointerInfo &M = *Record.MemberInfo;\r
+ error(IO.mapInteger(M.ContainingType));\r
+ error(IO.mapEnum(M.Representation));\r
+ }\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ArrayRecord &Record) {\r
+ error(IO.mapInteger(Record.ElementType));\r
+ error(IO.mapInteger(Record.IndexType));\r
+ error(IO.mapEncodedInteger(Record.Size));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, ClassRecord &Record) {\r
+ assert((CVR.Type == TypeLeafKind::LF_STRUCTURE) ||\r
+ (CVR.Type == TypeLeafKind::LF_CLASS) ||\r
+ (CVR.Type == TypeLeafKind::LF_INTERFACE));\r
+\r
+ error(IO.mapInteger(Record.MemberCount));\r
+ error(IO.mapEnum(Record.Options));\r
+ error(IO.mapInteger(Record.FieldList));\r
+ error(IO.mapInteger(Record.DerivationList));\r
+ error(IO.mapInteger(Record.VTableShape));\r
+ error(IO.mapEncodedInteger(Record.Size));\r
+ error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,\r
+ Record.hasUniqueName()));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, UnionRecord &Record) {\r
+ error(IO.mapInteger(Record.MemberCount));\r
+ error(IO.mapEnum(Record.Options));\r
+ error(IO.mapInteger(Record.FieldList));\r
+ error(IO.mapEncodedInteger(Record.Size));\r
+ error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,\r
+ Record.hasUniqueName()));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, EnumRecord &Record) {\r
+ error(IO.mapInteger(Record.MemberCount));\r
+ error(IO.mapEnum(Record.Options));\r
+ error(IO.mapInteger(Record.UnderlyingType));\r
+ error(IO.mapInteger(Record.FieldList));\r
+ error(mapNameAndUniqueName(IO, Record.Name, Record.UniqueName,\r
+ Record.hasUniqueName()));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, BitFieldRecord &Record) {\r
+ error(IO.mapInteger(Record.Type));\r
+ error(IO.mapInteger(Record.BitSize));\r
+ error(IO.mapInteger(Record.BitOffset));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ VFTableShapeRecord &Record) {\r
+ uint16_t Size;\r
+ if (IO.isWriting()) {\r
+ ArrayRef<VFTableSlotKind> Slots = Record.getSlots();\r
+ Size = Slots.size();\r
+ error(IO.mapInteger(Size));\r
+\r
+ for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {\r
+ uint8_t Byte = static_cast<uint8_t>(Slots[SlotIndex]) << 4;\r
+ if ((SlotIndex + 1) < Slots.size()) {\r
+ Byte |= static_cast<uint8_t>(Slots[SlotIndex + 1]);\r
+ }\r
+ error(IO.mapInteger(Byte));\r
+ }\r
+ } else {\r
+ error(IO.mapInteger(Size));\r
+ for (uint16_t I = 0; I < Size; I += 2) {\r
+ uint8_t Byte;\r
+ error(IO.mapInteger(Byte));\r
+ Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte & 0xF));\r
+ if ((I + 1) < Size)\r
+ Record.Slots.push_back(static_cast<VFTableSlotKind>(Byte >> 4));\r
+ }\r
+ }\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, VFTableRecord &Record) {\r
+ error(IO.mapInteger(Record.CompleteClass));\r
+ error(IO.mapInteger(Record.OverriddenVFTable));\r
+ error(IO.mapInteger(Record.VFPtrOffset));\r
+ uint32_t NamesLen = 0;\r
+ if (IO.isWriting()) {\r
+ for (auto Name : Record.MethodNames)\r
+ NamesLen += Name.size() + 1;\r
+ }\r
+ error(IO.mapInteger(NamesLen));\r
+ error(IO.mapVectorTail(\r
+ Record.MethodNames,\r
+ [](CodeViewRecordIO &IO, StringRef &S) { return IO.mapStringZ(S); }));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, StringIdRecord &Record) {\r
+ error(IO.mapInteger(Record.Id));\r
+ error(IO.mapStringZ(Record.String));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ UdtSourceLineRecord &Record) {\r
+ error(IO.mapInteger(Record.UDT));\r
+ error(IO.mapInteger(Record.SourceFile));\r
+ error(IO.mapInteger(Record.LineNumber));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ UdtModSourceLineRecord &Record) {\r
+ error(IO.mapInteger(Record.UDT));\r
+ error(IO.mapInteger(Record.SourceFile));\r
+ error(IO.mapInteger(Record.LineNumber));\r
+ error(IO.mapInteger(Record.Module));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, FuncIdRecord &Record) {\r
+ error(IO.mapInteger(Record.ParentScope));\r
+ error(IO.mapInteger(Record.FunctionType));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ MemberFuncIdRecord &Record) {\r
+ error(IO.mapInteger(Record.ClassType));\r
+ error(IO.mapInteger(Record.FunctionType));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ BuildInfoRecord &Record) {\r
+ error(IO.mapVectorN<uint16_t>(\r
+ Record.ArgIndices,\r
+ [](CodeViewRecordIO &IO, TypeIndex &N) { return IO.mapInteger(N); }));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ MethodOverloadListRecord &Record) {\r
+ // TODO: Split the list into multiple records if it's longer than 64KB, using\r
+ // a subrecord of TypeRecordKind::Index to chain the records together.\r
+ error(IO.mapVectorTail(Record.Methods, MapOneMethodRecord(true)));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ FieldListRecord &Record) {\r
+ error(IO.mapByteVectorTail(Record.Data));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ TypeServer2Record &Record) {\r
+ error(IO.mapGuid(Record.Guid));\r
+ error(IO.mapInteger(Record.Age));\r
+ error(IO.mapStringZ(Record.Name));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR, LabelRecord &Record) {\r
+ error(IO.mapEnum(Record.Mode));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ BaseClassRecord &Record) {\r
+ error(IO.mapInteger(Record.Attrs.Attrs));\r
+ error(IO.mapInteger(Record.Type));\r
+ error(IO.mapEncodedInteger(Record.Offset));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ EnumeratorRecord &Record) {\r
+ error(IO.mapInteger(Record.Attrs.Attrs));\r
+\r
+ // FIXME: Handle full APInt such as __int128.\r
+ error(IO.mapEncodedInteger(Record.Value));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ DataMemberRecord &Record) {\r
+ error(IO.mapInteger(Record.Attrs.Attrs));\r
+ error(IO.mapInteger(Record.Type));\r
+ error(IO.mapEncodedInteger(Record.FieldOffset));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ OverloadedMethodRecord &Record) {\r
+ error(IO.mapInteger(Record.NumOverloads));\r
+ error(IO.mapInteger(Record.MethodList));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ OneMethodRecord &Record) {\r
+ const bool IsFromOverloadList = (TypeKind == LF_METHODLIST);\r
+ MapOneMethodRecord Mapper(IsFromOverloadList);\r
+ return Mapper(IO, Record);\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ NestedTypeRecord &Record) {\r
+ uint16_t Padding = 0;\r
+ error(IO.mapInteger(Padding));\r
+ error(IO.mapInteger(Record.Type));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ StaticDataMemberRecord &Record) {\r
+\r
+ error(IO.mapInteger(Record.Attrs.Attrs));\r
+ error(IO.mapInteger(Record.Type));\r
+ error(IO.mapStringZ(Record.Name));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ VirtualBaseClassRecord &Record) {\r
+\r
+ error(IO.mapInteger(Record.Attrs.Attrs));\r
+ error(IO.mapInteger(Record.BaseType));\r
+ error(IO.mapInteger(Record.VBPtrType));\r
+ error(IO.mapEncodedInteger(Record.VBPtrOffset));\r
+ error(IO.mapEncodedInteger(Record.VTableIndex));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ VFPtrRecord &Record) {\r
+ uint16_t Padding = 0;\r
+ error(IO.mapInteger(Padding));\r
+ error(IO.mapInteger(Record.Type));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownMember(CVMemberRecord &CVR,\r
+ ListContinuationRecord &Record) {\r
+ uint16_t Padding = 0;\r
+ error(IO.mapInteger(Padding));\r
+ error(IO.mapInteger(Record.ContinuationIndex));\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ PrecompRecord &Precomp) {\r
+ error(IO.mapInteger(Precomp.StartTypeIndex));\r
+ error(IO.mapInteger(Precomp.TypesCount));\r
+ error(IO.mapInteger(Precomp.Signature));\r
+ error(IO.mapStringZ(Precomp.PrecompFilePath));\r
+ return Error::success();\r
+}\r
+\r
+Error TypeRecordMapping::visitKnownRecord(CVType &CVR,\r
+ EndPrecompRecord &EndPrecomp) {\r
+ error(IO.mapInteger(EndPrecomp.Signature));\r
+ return Error::success();\r
+}\r
IO.mapOptional("VirtualSize", Sec.Header.VirtualSize, 0U);
IO.mapOptional("Alignment", Sec.Alignment, 0U);
- // If this is a .debug$S .debug$T, or .debug$H section parse the semantic
- // representation of the symbols/types. If it is any other kind of section,
- // just deal in raw bytes.
+ // If this is a .debug$S .debug$T .debug$P, or .debug$H section parse the
+ // semantic representation of the symbols/types. If it is any other kind
+ // of section, just deal in raw bytes.
IO.mapOptional("SectionData", Sec.SectionData);
if (Sec.Name == ".debug$S")
IO.mapOptional("Subsections", Sec.DebugS);
else if (Sec.Name == ".debug$T")
IO.mapOptional("Types", Sec.DebugT);
+ else if (Sec.Name == ".debug$P")
+ IO.mapOptional("PrecompTypes", Sec.DebugP);
else if (Sec.Name == ".debug$H")
IO.mapOptional("GlobalHashes", Sec.DebugH);
-//===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines classes for handling the YAML representation of CodeView
-// Debug Info.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
-#include "llvm/ADT/APSInt.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/BinaryFormat/COFF.h"
-#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/CodeViewError.h"
-#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
-#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
-#include "llvm/DebugInfo/CodeView/TypeIndex.h"
-#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/BinaryStreamReader.h"
-#include "llvm/Support/BinaryStreamWriter.h"
-#include "llvm/Support/Endian.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <vector>
-
-using namespace llvm;
-using namespace llvm::codeview;
-using namespace llvm::CodeViewYAML;
-using namespace llvm::CodeViewYAML::detail;
-using namespace llvm::yaml;
-
-LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
-LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
-
-LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)
-LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)
-
-LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)
-LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)
-LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)
-LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)
-LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)
-LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)
-LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)
-LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)
-LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)
-LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)
-LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)
-
-LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)
-LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)
-LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)
-LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)
-LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)
-
-LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)
-LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)
-
-namespace llvm {
-namespace CodeViewYAML {
-namespace detail {
-
-struct LeafRecordBase {
- TypeLeafKind Kind;
-
- explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}
- virtual ~LeafRecordBase() = default;
-
- virtual void map(yaml::IO &io) = 0;
- virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;
- virtual Error fromCodeViewRecord(CVType Type) = 0;
-};
-
-template <typename T> struct LeafRecordImpl : public LeafRecordBase {
- explicit LeafRecordImpl(TypeLeafKind K)
- : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
-
- void map(yaml::IO &io) override;
-
- Error fromCodeViewRecord(CVType Type) override {
- return TypeDeserializer::deserializeAs<T>(Type, Record);
- }
-
- CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
- TS.writeLeafType(Record);
- return CVType(Kind, TS.records().back());
- }
-
- mutable T Record;
-};
-
-template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {
- explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}
-
- void map(yaml::IO &io) override;
- CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;
- Error fromCodeViewRecord(CVType Type) override;
-
- std::vector<MemberRecord> Members;
-};
-
-struct MemberRecordBase {
- TypeLeafKind Kind;
-
- explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}
- virtual ~MemberRecordBase() = default;
-
- virtual void map(yaml::IO &io) = 0;
- virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;
-};
-
-template <typename T> struct MemberRecordImpl : public MemberRecordBase {
- explicit MemberRecordImpl(TypeLeafKind K)
- : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
-
- void map(yaml::IO &io) override;
-
- void writeTo(ContinuationRecordBuilder &CRB) override {
- CRB.writeMemberType(Record);
- }
-
- mutable T Record;
-};
-
-} // end namespace detail
-} // end namespace CodeViewYAML
-} // end namespace llvm
-
-void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {
- OS << G;
-}
-
-StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {
- if (Scalar.size() != 38)
- return "GUID strings are 38 characters long";
- if (Scalar[0] != '{' || Scalar[37] != '}')
- return "GUID is not enclosed in {}";
- if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
- Scalar[24] != '-')
- return "GUID sections are not properly delineated with dashes";
-
- uint8_t *OutBuffer = S.Guid;
- for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
- if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
- ++Iter;
- continue;
- }
- uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);
- Value |= llvm::hexDigitValue(*Iter++);
- *OutBuffer++ = Value;
- }
-
- return "";
-}
-
-void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
- raw_ostream &OS) {
- OS << S.getIndex();
-}
-
-StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,
- TypeIndex &S) {
- uint32_t I;
- StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);
- S.setIndex(I);
- return Result;
-}
-
-void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {
- S.print(OS, S.isSigned());
-}
-
-StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {
- S = APSInt(Scalar);
- return "";
-}
-
-void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
- TypeLeafKind &Value) {
-#define CV_TYPE(name, val) io.enumCase(Value, #name, name);
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
-#undef CV_TYPE
-}
-
-void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(
- IO &IO, PointerToMemberRepresentation &Value) {
- IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
- IO.enumCase(Value, "SingleInheritanceData",
- PointerToMemberRepresentation::SingleInheritanceData);
- IO.enumCase(Value, "MultipleInheritanceData",
- PointerToMemberRepresentation::MultipleInheritanceData);
- IO.enumCase(Value, "VirtualInheritanceData",
- PointerToMemberRepresentation::VirtualInheritanceData);
- IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);
- IO.enumCase(Value, "SingleInheritanceFunction",
- PointerToMemberRepresentation::SingleInheritanceFunction);
- IO.enumCase(Value, "MultipleInheritanceFunction",
- PointerToMemberRepresentation::MultipleInheritanceFunction);
- IO.enumCase(Value, "VirtualInheritanceFunction",
- PointerToMemberRepresentation::VirtualInheritanceFunction);
- IO.enumCase(Value, "GeneralFunction",
- PointerToMemberRepresentation::GeneralFunction);
-}
-
-void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(
- IO &IO, VFTableSlotKind &Kind) {
- IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);
- IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);
- IO.enumCase(Kind, "This", VFTableSlotKind::This);
- IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);
- IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);
- IO.enumCase(Kind, "Near", VFTableSlotKind::Near);
- IO.enumCase(Kind, "Far", VFTableSlotKind::Far);
-}
-
-void ScalarEnumerationTraits<CallingConvention>::enumeration(
- IO &IO, CallingConvention &Value) {
- IO.enumCase(Value, "NearC", CallingConvention::NearC);
- IO.enumCase(Value, "FarC", CallingConvention::FarC);
- IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);
- IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);
- IO.enumCase(Value, "NearFast", CallingConvention::NearFast);
- IO.enumCase(Value, "FarFast", CallingConvention::FarFast);
- IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);
- IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);
- IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);
- IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);
- IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);
- IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);
- IO.enumCase(Value, "Generic", CallingConvention::Generic);
- IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);
- IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);
- IO.enumCase(Value, "SHCall", CallingConvention::SHCall);
- IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);
- IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);
- IO.enumCase(Value, "TriCall", CallingConvention::TriCall);
- IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);
- IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);
- IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);
- IO.enumCase(Value, "Inline", CallingConvention::Inline);
- IO.enumCase(Value, "NearVector", CallingConvention::NearVector);
-}
-
-void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,
- PointerKind &Kind) {
- IO.enumCase(Kind, "Near16", PointerKind::Near16);
- IO.enumCase(Kind, "Far16", PointerKind::Far16);
- IO.enumCase(Kind, "Huge16", PointerKind::Huge16);
- IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);
- IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);
- IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);
- IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);
- IO.enumCase(Kind, "BasedOnSegmentAddress",
- PointerKind::BasedOnSegmentAddress);
- IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);
- IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);
- IO.enumCase(Kind, "Near32", PointerKind::Near32);
- IO.enumCase(Kind, "Far32", PointerKind::Far32);
- IO.enumCase(Kind, "Near64", PointerKind::Near64);
-}
-
-void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,
- PointerMode &Mode) {
- IO.enumCase(Mode, "Pointer", PointerMode::Pointer);
- IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);
- IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);
- IO.enumCase(Mode, "PointerToMemberFunction",
- PointerMode::PointerToMemberFunction);
- IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);
-}
-
-void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {
- IO.enumCase(Value, "None", HfaKind::None);
- IO.enumCase(Value, "Float", HfaKind::Float);
- IO.enumCase(Value, "Double", HfaKind::Double);
- IO.enumCase(Value, "Other", HfaKind::Other);
-}
-
-void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,
- MemberAccess &Access) {
- IO.enumCase(Access, "None", MemberAccess::None);
- IO.enumCase(Access, "Private", MemberAccess::Private);
- IO.enumCase(Access, "Protected", MemberAccess::Protected);
- IO.enumCase(Access, "Public", MemberAccess::Public);
-}
-
-void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,
- MethodKind &Kind) {
- IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);
- IO.enumCase(Kind, "Virtual", MethodKind::Virtual);
- IO.enumCase(Kind, "Static", MethodKind::Static);
- IO.enumCase(Kind, "Friend", MethodKind::Friend);
- IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);
- IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);
- IO.enumCase(Kind, "PureIntroducingVirtual",
- MethodKind::PureIntroducingVirtual);
-}
-
-void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(
- IO &IO, WindowsRTClassKind &Value) {
- IO.enumCase(Value, "None", WindowsRTClassKind::None);
- IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);
- IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);
- IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);
-}
-
-void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {
- IO.enumCase(Value, "Near", LabelType::Near);
- IO.enumCase(Value, "Far", LabelType::Far);
-}
-
-void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
- PointerOptions &Options) {
- IO.bitSetCase(Options, "None", PointerOptions::None);
- IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
- IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
- IO.bitSetCase(Options, "Const", PointerOptions::Const);
- IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
- IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
- IO.bitSetCase(Options, "WinRTSmartPointer",
- PointerOptions::WinRTSmartPointer);
-}
-
-void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
- ModifierOptions &Options) {
- IO.bitSetCase(Options, "None", ModifierOptions::None);
- IO.bitSetCase(Options, "Const", ModifierOptions::Const);
- IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
- IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);
-}
-
-void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,
- FunctionOptions &Options) {
- IO.bitSetCase(Options, "None", FunctionOptions::None);
- IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
- IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
- IO.bitSetCase(Options, "ConstructorWithVirtualBases",
- FunctionOptions::ConstructorWithVirtualBases);
-}
-
-void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {
- IO.bitSetCase(Options, "None", ClassOptions::None);
- IO.bitSetCase(Options, "HasConstructorOrDestructor",
- ClassOptions::HasConstructorOrDestructor);
- IO.bitSetCase(Options, "HasOverloadedOperator",
- ClassOptions::HasOverloadedOperator);
- IO.bitSetCase(Options, "Nested", ClassOptions::Nested);
- IO.bitSetCase(Options, "ContainsNestedClass",
- ClassOptions::ContainsNestedClass);
- IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",
- ClassOptions::HasOverloadedAssignmentOperator);
- IO.bitSetCase(Options, "HasConversionOperator",
- ClassOptions::HasConversionOperator);
- IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);
- IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);
- IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);
- IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);
- IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);
-}
-
-void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {
- IO.bitSetCase(Options, "None", MethodOptions::None);
- IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);
- IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);
- IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);
- IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);
- IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
-}
-
-void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
- IO.mapRequired("ContainingType", MPI.ContainingType);
- IO.mapRequired("Representation", MPI.Representation);
-}
-
-namespace llvm {
-namespace CodeViewYAML {
-namespace detail {
-
-template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {
- IO.mapRequired("ModifiedType", Record.ModifiedType);
- IO.mapRequired("Modifiers", Record.Modifiers);
-}
-
-template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {
- IO.mapRequired("ReturnType", Record.ReturnType);
- IO.mapRequired("CallConv", Record.CallConv);
- IO.mapRequired("Options", Record.Options);
- IO.mapRequired("ParameterCount", Record.ParameterCount);
- IO.mapRequired("ArgumentList", Record.ArgumentList);
-}
-
-template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {
- IO.mapRequired("ReturnType", Record.ReturnType);
- IO.mapRequired("ClassType", Record.ClassType);
- IO.mapRequired("ThisType", Record.ThisType);
- IO.mapRequired("CallConv", Record.CallConv);
- IO.mapRequired("Options", Record.Options);
- IO.mapRequired("ParameterCount", Record.ParameterCount);
- IO.mapRequired("ArgumentList", Record.ArgumentList);
- IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);
-}
-
-template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {
- IO.mapRequired("Mode", Record.Mode);
-}
-
-template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {
- IO.mapRequired("ClassType", Record.ClassType);
- IO.mapRequired("FunctionType", Record.FunctionType);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {
- IO.mapRequired("ArgIndices", Record.ArgIndices);
-}
-
-template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {
- IO.mapRequired("StringIndices", Record.StringIndices);
-}
-
-template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {
- IO.mapRequired("ReferentType", Record.ReferentType);
- IO.mapRequired("Attrs", Record.Attrs);
- IO.mapOptional("MemberInfo", Record.MemberInfo);
-}
-
-template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {
- IO.mapRequired("ElementType", Record.ElementType);
- IO.mapRequired("IndexType", Record.IndexType);
- IO.mapRequired("Size", Record.Size);
- IO.mapRequired("Name", Record.Name);
-}
-
-void LeafRecordImpl<FieldListRecord>::map(IO &IO) {
- IO.mapRequired("FieldList", Members);
-}
-
-} // end namespace detail
-} // end namespace CodeViewYAML
-} // end namespace llvm
-
-namespace {
-
-class MemberRecordConversionVisitor : public TypeVisitorCallbacks {
-public:
- explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)
- : Records(Records) {}
-
-#define TYPE_RECORD(EnumName, EnumVal, Name)
-#define MEMBER_RECORD(EnumName, EnumVal, Name) \
- Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
- return visitKnownMemberImpl(Record); \
- }
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
-private:
- template <typename T> Error visitKnownMemberImpl(T &Record) {
- TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());
- auto Impl = std::make_shared<MemberRecordImpl<T>>(K);
- Impl->Record = Record;
- Records.push_back(MemberRecord{Impl});
- return Error::success();
- }
-
- std::vector<MemberRecord> &Records;
-};
-
-} // end anonymous namespace
-
-Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {
- MemberRecordConversionVisitor V(Members);
- return visitMemberRecordStream(Type.content(), V);
-}
-
-CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(
- AppendingTypeTableBuilder &TS) const {
- ContinuationRecordBuilder CRB;
- CRB.begin(ContinuationRecordKind::FieldList);
- for (const auto &Member : Members) {
- Member.Member->writeTo(CRB);
- }
- TS.insertRecord(CRB);
- return CVType(Kind, TS.records().back());
-}
-
-void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {
- io.mapRequired("Type", Record.Type);
- io.mapRequired("Attrs", Record.Attrs.Attrs);
- io.mapRequired("VFTableOffset", Record.VFTableOffset);
- io.mapRequired("Name", Record.Name);
-}
-
-namespace llvm {
-namespace CodeViewYAML {
-namespace detail {
-
-template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {
- IO.mapRequired("MemberCount", Record.MemberCount);
- IO.mapRequired("Options", Record.Options);
- IO.mapRequired("FieldList", Record.FieldList);
- IO.mapRequired("Name", Record.Name);
- IO.mapRequired("UniqueName", Record.UniqueName);
- IO.mapRequired("DerivationList", Record.DerivationList);
- IO.mapRequired("VTableShape", Record.VTableShape);
- IO.mapRequired("Size", Record.Size);
-}
-
-template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {
- IO.mapRequired("MemberCount", Record.MemberCount);
- IO.mapRequired("Options", Record.Options);
- IO.mapRequired("FieldList", Record.FieldList);
- IO.mapRequired("Name", Record.Name);
- IO.mapRequired("UniqueName", Record.UniqueName);
- IO.mapRequired("Size", Record.Size);
-}
-
-template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {
- IO.mapRequired("NumEnumerators", Record.MemberCount);
- IO.mapRequired("Options", Record.Options);
- IO.mapRequired("FieldList", Record.FieldList);
- IO.mapRequired("Name", Record.Name);
- IO.mapRequired("UniqueName", Record.UniqueName);
- IO.mapRequired("UnderlyingType", Record.UnderlyingType);
-}
-
-template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {
- IO.mapRequired("Type", Record.Type);
- IO.mapRequired("BitSize", Record.BitSize);
- IO.mapRequired("BitOffset", Record.BitOffset);
-}
-
-template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {
- IO.mapRequired("Slots", Record.Slots);
-}
-
-template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {
- IO.mapRequired("Guid", Record.Guid);
- IO.mapRequired("Age", Record.Age);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {
- IO.mapRequired("Id", Record.Id);
- IO.mapRequired("String", Record.String);
-}
-
-template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {
- IO.mapRequired("ParentScope", Record.ParentScope);
- IO.mapRequired("FunctionType", Record.FunctionType);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {
- IO.mapRequired("UDT", Record.UDT);
- IO.mapRequired("SourceFile", Record.SourceFile);
- IO.mapRequired("LineNumber", Record.LineNumber);
-}
-
-template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {
- IO.mapRequired("UDT", Record.UDT);
- IO.mapRequired("SourceFile", Record.SourceFile);
- IO.mapRequired("LineNumber", Record.LineNumber);
- IO.mapRequired("Module", Record.Module);
-}
-
-template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {
- IO.mapRequired("ArgIndices", Record.ArgIndices);
-}
-
-template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {
- IO.mapRequired("CompleteClass", Record.CompleteClass);
- IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);
- IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);
- IO.mapRequired("MethodNames", Record.MethodNames);
-}
-
-template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {
- IO.mapRequired("Methods", Record.Methods);
-}
-
-template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {
- MappingTraits<OneMethodRecord>::mapping(IO, Record);
-}
-
-template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {
- IO.mapRequired("NumOverloads", Record.NumOverloads);
- IO.mapRequired("MethodList", Record.MethodList);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {
- IO.mapRequired("Type", Record.Type);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {
- IO.mapRequired("Attrs", Record.Attrs.Attrs);
- IO.mapRequired("Type", Record.Type);
- IO.mapRequired("FieldOffset", Record.FieldOffset);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {
- IO.mapRequired("Attrs", Record.Attrs.Attrs);
- IO.mapRequired("Type", Record.Type);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {
- IO.mapRequired("Attrs", Record.Attrs.Attrs);
- IO.mapRequired("Value", Record.Value);
- IO.mapRequired("Name", Record.Name);
-}
-
-template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {
- IO.mapRequired("Type", Record.Type);
-}
-
-template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {
- IO.mapRequired("Attrs", Record.Attrs.Attrs);
- IO.mapRequired("Type", Record.Type);
- IO.mapRequired("Offset", Record.Offset);
-}
-
-template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {
- IO.mapRequired("Attrs", Record.Attrs.Attrs);
- IO.mapRequired("BaseType", Record.BaseType);
- IO.mapRequired("VBPtrType", Record.VBPtrType);
- IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);
- IO.mapRequired("VTableIndex", Record.VTableIndex);
-}
-
-template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {
- IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);
-}
-
-} // end namespace detail
-} // end namespace CodeViewYAML
-} // end namespace llvm
-
-template <typename T>
-static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
- LeafRecord Result;
-
- auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
- if (auto EC = Impl->fromCodeViewRecord(Type))
- return std::move(EC);
- Result.Leaf = Impl;
- return Result;
-}
-
-Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {
-#define TYPE_RECORD(EnumName, EnumVal, ClassName) \
- case EnumName: \
- return fromCodeViewRecordImpl<ClassName##Record>(Type);
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
- TYPE_RECORD(EnumName, EnumVal, ClassName)
-#define MEMBER_RECORD(EnumName, EnumVal, ClassName)
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
- switch (Type.kind()) {
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
- default:
- llvm_unreachable("Unknown leaf kind!");
- }
- return make_error<CodeViewError>(cv_error_code::corrupt_record);
-}
-
-CVType
-LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {
- return Leaf->toCodeViewRecord(Serializer);
-}
-
-namespace llvm {
-namespace yaml {
-
-template <> struct MappingTraits<LeafRecordBase> {
- static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }
-};
-
-template <> struct MappingTraits<MemberRecordBase> {
- static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }
-};
-
-} // end namespace yaml
-} // end namespace llvm
-
-template <typename ConcreteType>
-static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
- LeafRecord &Obj) {
- if (!IO.outputting())
- Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);
-
- if (Kind == LF_FIELDLIST)
- Obj.Leaf->map(IO);
- else
- IO.mapRequired(Class, *Obj.Leaf);
-}
-
-void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {
- TypeLeafKind Kind;
- if (IO.outputting())
- Kind = Obj.Leaf->Kind;
- IO.mapRequired("Kind", Kind);
-
-#define TYPE_RECORD(EnumName, EnumVal, ClassName) \
- case EnumName: \
- mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \
- break;
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
- TYPE_RECORD(EnumName, EnumVal, ClassName)
-#define MEMBER_RECORD(EnumName, EnumVal, ClassName)
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
- switch (Kind) {
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
- default: { llvm_unreachable("Unknown leaf kind!"); }
- }
-}
-
-template <typename ConcreteType>
-static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
- MemberRecord &Obj) {
- if (!IO.outputting())
- Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);
-
- IO.mapRequired(Class, *Obj.Member);
-}
-
-void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {
- TypeLeafKind Kind;
- if (IO.outputting())
- Kind = Obj.Member->Kind;
- IO.mapRequired("Kind", Kind);
-
-#define MEMBER_RECORD(EnumName, EnumVal, ClassName) \
- case EnumName: \
- mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \
- break;
-#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
- MEMBER_RECORD(EnumName, EnumVal, ClassName)
-#define TYPE_RECORD(EnumName, EnumVal, ClassName)
-#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
- switch (Kind) {
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
- default: { llvm_unreachable("Unknown member kind!"); }
- }
-}
-
-std::vector<LeafRecord>
-llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugT) {
- ExitOnError Err("Invalid .debug$T section!");
- BinaryStreamReader Reader(DebugT, support::little);
- CVTypeArray Types;
- uint32_t Magic;
-
- Err(Reader.readInteger(Magic));
- assert(Magic == COFF::DEBUG_SECTION_MAGIC && "Invalid .debug$T section!");
-
- std::vector<LeafRecord> Result;
- Err(Reader.readArray(Types, Reader.bytesRemaining()));
- for (const auto &T : Types) {
- auto CVT = Err(LeafRecord::fromCodeViewRecord(T));
- Result.push_back(CVT);
- }
- return Result;
-}
-
-ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,
- BumpPtrAllocator &Alloc) {
- AppendingTypeTableBuilder TS(Alloc);
- uint32_t Size = sizeof(uint32_t);
- for (const auto &Leaf : Leafs) {
- CVType T = Leaf.Leaf->toCodeViewRecord(TS);
- Size += T.length();
- assert(T.length() % 4 == 0 && "Improper type record alignment!");
- }
- uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);
- MutableArrayRef<uint8_t> Output(ResultBuffer, Size);
- BinaryStreamWriter Writer(Output, support::little);
- ExitOnError Err("Error writing type record to .debug$T section");
- Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));
- for (const auto &R : TS.records()) {
- Err(Writer.writeBytes(R));
- }
- assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!");
- return Output;
-}
+//===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file defines classes for handling the YAML representation of CodeView\r
+// Debug Info.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"\r
+#include "llvm/ADT/APSInt.h"\r
+#include "llvm/ADT/ArrayRef.h"\r
+#include "llvm/ADT/StringRef.h"\r
+#include "llvm/BinaryFormat/COFF.h"\r
+#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"\r
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"\r
+#include "llvm/DebugInfo/CodeView/CodeView.h"\r
+#include "llvm/DebugInfo/CodeView/CodeViewError.h"\r
+#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"\r
+#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"\r
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"\r
+#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"\r
+#include "llvm/Support/Allocator.h"\r
+#include "llvm/Support/BinaryStreamReader.h"\r
+#include "llvm/Support/BinaryStreamWriter.h"\r
+#include "llvm/Support/Endian.h"\r
+#include "llvm/Support/Error.h"\r
+#include "llvm/Support/ErrorHandling.h"\r
+#include "llvm/Support/YAMLTraits.h"\r
+#include "llvm/Support/raw_ostream.h"\r
+#include <algorithm>\r
+#include <cassert>\r
+#include <cstdint>\r
+#include <vector>\r
+\r
+using namespace llvm;\r
+using namespace llvm::codeview;\r
+using namespace llvm::CodeViewYAML;\r
+using namespace llvm::CodeViewYAML::detail;\r
+using namespace llvm::yaml;\r
+\r
+LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)\r
+LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)\r
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)\r
+\r
+LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)\r
+LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)\r
+\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)\r
+LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)\r
+\r
+LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)\r
+LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)\r
+LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)\r
+LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)\r
+LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)\r
+\r
+LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)\r
+LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)\r
+\r
+namespace llvm {\r
+namespace CodeViewYAML {\r
+namespace detail {\r
+\r
+struct LeafRecordBase {\r
+ TypeLeafKind Kind;\r
+\r
+ explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}\r
+ virtual ~LeafRecordBase() = default;\r
+\r
+ virtual void map(yaml::IO &io) = 0;\r
+ virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;\r
+ virtual Error fromCodeViewRecord(CVType Type) = 0;\r
+};\r
+\r
+template <typename T> struct LeafRecordImpl : public LeafRecordBase {\r
+ explicit LeafRecordImpl(TypeLeafKind K)\r
+ : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}\r
+\r
+ void map(yaml::IO &io) override;\r
+\r
+ Error fromCodeViewRecord(CVType Type) override {\r
+ return TypeDeserializer::deserializeAs<T>(Type, Record);\r
+ }\r
+\r
+ CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {\r
+ TS.writeLeafType(Record);\r
+ return CVType(Kind, TS.records().back());\r
+ }\r
+\r
+ mutable T Record;\r
+};\r
+\r
+template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {\r
+ explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}\r
+\r
+ void map(yaml::IO &io) override;\r
+ CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;\r
+ Error fromCodeViewRecord(CVType Type) override;\r
+\r
+ std::vector<MemberRecord> Members;\r
+};\r
+\r
+struct MemberRecordBase {\r
+ TypeLeafKind Kind;\r
+\r
+ explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}\r
+ virtual ~MemberRecordBase() = default;\r
+\r
+ virtual void map(yaml::IO &io) = 0;\r
+ virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;\r
+};\r
+\r
+template <typename T> struct MemberRecordImpl : public MemberRecordBase {\r
+ explicit MemberRecordImpl(TypeLeafKind K)\r
+ : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}\r
+\r
+ void map(yaml::IO &io) override;\r
+\r
+ void writeTo(ContinuationRecordBuilder &CRB) override {\r
+ CRB.writeMemberType(Record);\r
+ }\r
+\r
+ mutable T Record;\r
+};\r
+\r
+} // end namespace detail\r
+} // end namespace CodeViewYAML\r
+} // end namespace llvm\r
+\r
+void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {\r
+ OS << G;\r
+}\r
+\r
+StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {\r
+ if (Scalar.size() != 38)\r
+ return "GUID strings are 38 characters long";\r
+ if (Scalar[0] != '{' || Scalar[37] != '}')\r
+ return "GUID is not enclosed in {}";\r
+ if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||\r
+ Scalar[24] != '-')\r
+ return "GUID sections are not properly delineated with dashes";\r
+\r
+ uint8_t *OutBuffer = S.Guid;\r
+ for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {\r
+ if (*Iter == '-' || *Iter == '{' || *Iter == '}') {\r
+ ++Iter;\r
+ continue;\r
+ }\r
+ uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);\r
+ Value |= llvm::hexDigitValue(*Iter++);\r
+ *OutBuffer++ = Value;\r
+ }\r
+\r
+ return "";\r
+}\r
+\r
+void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,\r
+ raw_ostream &OS) {\r
+ OS << S.getIndex();\r
+}\r
+\r
+StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,\r
+ TypeIndex &S) {\r
+ uint32_t I;\r
+ StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);\r
+ S.setIndex(I);\r
+ return Result;\r
+}\r
+\r
+void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {\r
+ S.print(OS, S.isSigned());\r
+}\r
+\r
+StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {\r
+ S = APSInt(Scalar);\r
+ return "";\r
+}\r
+\r
+void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,\r
+ TypeLeafKind &Value) {\r
+#define CV_TYPE(name, val) io.enumCase(Value, #name, name);\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+#undef CV_TYPE\r
+}\r
+\r
+void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(\r
+ IO &IO, PointerToMemberRepresentation &Value) {\r
+ IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);\r
+ IO.enumCase(Value, "SingleInheritanceData",\r
+ PointerToMemberRepresentation::SingleInheritanceData);\r
+ IO.enumCase(Value, "MultipleInheritanceData",\r
+ PointerToMemberRepresentation::MultipleInheritanceData);\r
+ IO.enumCase(Value, "VirtualInheritanceData",\r
+ PointerToMemberRepresentation::VirtualInheritanceData);\r
+ IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);\r
+ IO.enumCase(Value, "SingleInheritanceFunction",\r
+ PointerToMemberRepresentation::SingleInheritanceFunction);\r
+ IO.enumCase(Value, "MultipleInheritanceFunction",\r
+ PointerToMemberRepresentation::MultipleInheritanceFunction);\r
+ IO.enumCase(Value, "VirtualInheritanceFunction",\r
+ PointerToMemberRepresentation::VirtualInheritanceFunction);\r
+ IO.enumCase(Value, "GeneralFunction",\r
+ PointerToMemberRepresentation::GeneralFunction);\r
+}\r
+\r
+void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(\r
+ IO &IO, VFTableSlotKind &Kind) {\r
+ IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);\r
+ IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);\r
+ IO.enumCase(Kind, "This", VFTableSlotKind::This);\r
+ IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);\r
+ IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);\r
+ IO.enumCase(Kind, "Near", VFTableSlotKind::Near);\r
+ IO.enumCase(Kind, "Far", VFTableSlotKind::Far);\r
+}\r
+\r
+void ScalarEnumerationTraits<CallingConvention>::enumeration(\r
+ IO &IO, CallingConvention &Value) {\r
+ IO.enumCase(Value, "NearC", CallingConvention::NearC);\r
+ IO.enumCase(Value, "FarC", CallingConvention::FarC);\r
+ IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);\r
+ IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);\r
+ IO.enumCase(Value, "NearFast", CallingConvention::NearFast);\r
+ IO.enumCase(Value, "FarFast", CallingConvention::FarFast);\r
+ IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);\r
+ IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);\r
+ IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);\r
+ IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);\r
+ IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);\r
+ IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);\r
+ IO.enumCase(Value, "Generic", CallingConvention::Generic);\r
+ IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);\r
+ IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);\r
+ IO.enumCase(Value, "SHCall", CallingConvention::SHCall);\r
+ IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);\r
+ IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);\r
+ IO.enumCase(Value, "TriCall", CallingConvention::TriCall);\r
+ IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);\r
+ IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);\r
+ IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);\r
+ IO.enumCase(Value, "Inline", CallingConvention::Inline);\r
+ IO.enumCase(Value, "NearVector", CallingConvention::NearVector);\r
+}\r
+\r
+void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,\r
+ PointerKind &Kind) {\r
+ IO.enumCase(Kind, "Near16", PointerKind::Near16);\r
+ IO.enumCase(Kind, "Far16", PointerKind::Far16);\r
+ IO.enumCase(Kind, "Huge16", PointerKind::Huge16);\r
+ IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);\r
+ IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);\r
+ IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);\r
+ IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);\r
+ IO.enumCase(Kind, "BasedOnSegmentAddress",\r
+ PointerKind::BasedOnSegmentAddress);\r
+ IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);\r
+ IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);\r
+ IO.enumCase(Kind, "Near32", PointerKind::Near32);\r
+ IO.enumCase(Kind, "Far32", PointerKind::Far32);\r
+ IO.enumCase(Kind, "Near64", PointerKind::Near64);\r
+}\r
+\r
+void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,\r
+ PointerMode &Mode) {\r
+ IO.enumCase(Mode, "Pointer", PointerMode::Pointer);\r
+ IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);\r
+ IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);\r
+ IO.enumCase(Mode, "PointerToMemberFunction",\r
+ PointerMode::PointerToMemberFunction);\r
+ IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);\r
+}\r
+\r
+void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {\r
+ IO.enumCase(Value, "None", HfaKind::None);\r
+ IO.enumCase(Value, "Float", HfaKind::Float);\r
+ IO.enumCase(Value, "Double", HfaKind::Double);\r
+ IO.enumCase(Value, "Other", HfaKind::Other);\r
+}\r
+\r
+void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,\r
+ MemberAccess &Access) {\r
+ IO.enumCase(Access, "None", MemberAccess::None);\r
+ IO.enumCase(Access, "Private", MemberAccess::Private);\r
+ IO.enumCase(Access, "Protected", MemberAccess::Protected);\r
+ IO.enumCase(Access, "Public", MemberAccess::Public);\r
+}\r
+\r
+void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,\r
+ MethodKind &Kind) {\r
+ IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);\r
+ IO.enumCase(Kind, "Virtual", MethodKind::Virtual);\r
+ IO.enumCase(Kind, "Static", MethodKind::Static);\r
+ IO.enumCase(Kind, "Friend", MethodKind::Friend);\r
+ IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);\r
+ IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);\r
+ IO.enumCase(Kind, "PureIntroducingVirtual",\r
+ MethodKind::PureIntroducingVirtual);\r
+}\r
+\r
+void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(\r
+ IO &IO, WindowsRTClassKind &Value) {\r
+ IO.enumCase(Value, "None", WindowsRTClassKind::None);\r
+ IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);\r
+ IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);\r
+ IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);\r
+}\r
+\r
+void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {\r
+ IO.enumCase(Value, "Near", LabelType::Near);\r
+ IO.enumCase(Value, "Far", LabelType::Far);\r
+}\r
+\r
+void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,\r
+ PointerOptions &Options) {\r
+ IO.bitSetCase(Options, "None", PointerOptions::None);\r
+ IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);\r
+ IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);\r
+ IO.bitSetCase(Options, "Const", PointerOptions::Const);\r
+ IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);\r
+ IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);\r
+ IO.bitSetCase(Options, "WinRTSmartPointer",\r
+ PointerOptions::WinRTSmartPointer);\r
+}\r
+\r
+void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,\r
+ ModifierOptions &Options) {\r
+ IO.bitSetCase(Options, "None", ModifierOptions::None);\r
+ IO.bitSetCase(Options, "Const", ModifierOptions::Const);\r
+ IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);\r
+ IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);\r
+}\r
+\r
+void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,\r
+ FunctionOptions &Options) {\r
+ IO.bitSetCase(Options, "None", FunctionOptions::None);\r
+ IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);\r
+ IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);\r
+ IO.bitSetCase(Options, "ConstructorWithVirtualBases",\r
+ FunctionOptions::ConstructorWithVirtualBases);\r
+}\r
+\r
+void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {\r
+ IO.bitSetCase(Options, "None", ClassOptions::None);\r
+ IO.bitSetCase(Options, "HasConstructorOrDestructor",\r
+ ClassOptions::HasConstructorOrDestructor);\r
+ IO.bitSetCase(Options, "HasOverloadedOperator",\r
+ ClassOptions::HasOverloadedOperator);\r
+ IO.bitSetCase(Options, "Nested", ClassOptions::Nested);\r
+ IO.bitSetCase(Options, "ContainsNestedClass",\r
+ ClassOptions::ContainsNestedClass);\r
+ IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",\r
+ ClassOptions::HasOverloadedAssignmentOperator);\r
+ IO.bitSetCase(Options, "HasConversionOperator",\r
+ ClassOptions::HasConversionOperator);\r
+ IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);\r
+ IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);\r
+ IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);\r
+ IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);\r
+ IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);\r
+}\r
+\r
+void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {\r
+ IO.bitSetCase(Options, "None", MethodOptions::None);\r
+ IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);\r
+ IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);\r
+ IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);\r
+ IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);\r
+ IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);\r
+}\r
+\r
+void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {\r
+ IO.mapRequired("ContainingType", MPI.ContainingType);\r
+ IO.mapRequired("Representation", MPI.Representation);\r
+}\r
+\r
+namespace llvm {\r
+namespace CodeViewYAML {\r
+namespace detail {\r
+\r
+template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {\r
+ IO.mapRequired("ModifiedType", Record.ModifiedType);\r
+ IO.mapRequired("Modifiers", Record.Modifiers);\r
+}\r
+\r
+template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {\r
+ IO.mapRequired("ReturnType", Record.ReturnType);\r
+ IO.mapRequired("CallConv", Record.CallConv);\r
+ IO.mapRequired("Options", Record.Options);\r
+ IO.mapRequired("ParameterCount", Record.ParameterCount);\r
+ IO.mapRequired("ArgumentList", Record.ArgumentList);\r
+}\r
+\r
+template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {\r
+ IO.mapRequired("ReturnType", Record.ReturnType);\r
+ IO.mapRequired("ClassType", Record.ClassType);\r
+ IO.mapRequired("ThisType", Record.ThisType);\r
+ IO.mapRequired("CallConv", Record.CallConv);\r
+ IO.mapRequired("Options", Record.Options);\r
+ IO.mapRequired("ParameterCount", Record.ParameterCount);\r
+ IO.mapRequired("ArgumentList", Record.ArgumentList);\r
+ IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);\r
+}\r
+\r
+template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {\r
+ IO.mapRequired("Mode", Record.Mode);\r
+}\r
+\r
+template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {\r
+ IO.mapRequired("ClassType", Record.ClassType);\r
+ IO.mapRequired("FunctionType", Record.FunctionType);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {\r
+ IO.mapRequired("ArgIndices", Record.ArgIndices);\r
+}\r
+\r
+template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {\r
+ IO.mapRequired("StringIndices", Record.StringIndices);\r
+}\r
+\r
+template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {\r
+ IO.mapRequired("ReferentType", Record.ReferentType);\r
+ IO.mapRequired("Attrs", Record.Attrs);\r
+ IO.mapOptional("MemberInfo", Record.MemberInfo);\r
+}\r
+\r
+template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {\r
+ IO.mapRequired("ElementType", Record.ElementType);\r
+ IO.mapRequired("IndexType", Record.IndexType);\r
+ IO.mapRequired("Size", Record.Size);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+void LeafRecordImpl<FieldListRecord>::map(IO &IO) {\r
+ IO.mapRequired("FieldList", Members);\r
+}\r
+\r
+} // end namespace detail\r
+} // end namespace CodeViewYAML\r
+} // end namespace llvm\r
+\r
+namespace {\r
+\r
+class MemberRecordConversionVisitor : public TypeVisitorCallbacks {\r
+public:\r
+ explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)\r
+ : Records(Records) {}\r
+\r
+#define TYPE_RECORD(EnumName, EnumVal, Name)\r
+#define MEMBER_RECORD(EnumName, EnumVal, Name) \\r
+ Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \\r
+ return visitKnownMemberImpl(Record); \\r
+ }\r
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)\r
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+private:\r
+ template <typename T> Error visitKnownMemberImpl(T &Record) {\r
+ TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());\r
+ auto Impl = std::make_shared<MemberRecordImpl<T>>(K);\r
+ Impl->Record = Record;\r
+ Records.push_back(MemberRecord{Impl});\r
+ return Error::success();\r
+ }\r
+\r
+ std::vector<MemberRecord> &Records;\r
+};\r
+\r
+} // end anonymous namespace\r
+\r
+Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {\r
+ MemberRecordConversionVisitor V(Members);\r
+ return visitMemberRecordStream(Type.content(), V);\r
+}\r
+\r
+CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(\r
+ AppendingTypeTableBuilder &TS) const {\r
+ ContinuationRecordBuilder CRB;\r
+ CRB.begin(ContinuationRecordKind::FieldList);\r
+ for (const auto &Member : Members) {\r
+ Member.Member->writeTo(CRB);\r
+ }\r
+ TS.insertRecord(CRB);\r
+ return CVType(Kind, TS.records().back());\r
+}\r
+\r
+void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {\r
+ io.mapRequired("Type", Record.Type);\r
+ io.mapRequired("Attrs", Record.Attrs.Attrs);\r
+ io.mapRequired("VFTableOffset", Record.VFTableOffset);\r
+ io.mapRequired("Name", Record.Name);\r
+}\r
+\r
+namespace llvm {\r
+namespace CodeViewYAML {\r
+namespace detail {\r
+\r
+template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {\r
+ IO.mapRequired("MemberCount", Record.MemberCount);\r
+ IO.mapRequired("Options", Record.Options);\r
+ IO.mapRequired("FieldList", Record.FieldList);\r
+ IO.mapRequired("Name", Record.Name);\r
+ IO.mapRequired("UniqueName", Record.UniqueName);\r
+ IO.mapRequired("DerivationList", Record.DerivationList);\r
+ IO.mapRequired("VTableShape", Record.VTableShape);\r
+ IO.mapRequired("Size", Record.Size);\r
+}\r
+\r
+template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {\r
+ IO.mapRequired("MemberCount", Record.MemberCount);\r
+ IO.mapRequired("Options", Record.Options);\r
+ IO.mapRequired("FieldList", Record.FieldList);\r
+ IO.mapRequired("Name", Record.Name);\r
+ IO.mapRequired("UniqueName", Record.UniqueName);\r
+ IO.mapRequired("Size", Record.Size);\r
+}\r
+\r
+template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {\r
+ IO.mapRequired("NumEnumerators", Record.MemberCount);\r
+ IO.mapRequired("Options", Record.Options);\r
+ IO.mapRequired("FieldList", Record.FieldList);\r
+ IO.mapRequired("Name", Record.Name);\r
+ IO.mapRequired("UniqueName", Record.UniqueName);\r
+ IO.mapRequired("UnderlyingType", Record.UnderlyingType);\r
+}\r
+\r
+template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {\r
+ IO.mapRequired("Type", Record.Type);\r
+ IO.mapRequired("BitSize", Record.BitSize);\r
+ IO.mapRequired("BitOffset", Record.BitOffset);\r
+}\r
+\r
+template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {\r
+ IO.mapRequired("Slots", Record.Slots);\r
+}\r
+\r
+template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {\r
+ IO.mapRequired("Guid", Record.Guid);\r
+ IO.mapRequired("Age", Record.Age);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {\r
+ IO.mapRequired("Id", Record.Id);\r
+ IO.mapRequired("String", Record.String);\r
+}\r
+\r
+template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {\r
+ IO.mapRequired("ParentScope", Record.ParentScope);\r
+ IO.mapRequired("FunctionType", Record.FunctionType);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {\r
+ IO.mapRequired("UDT", Record.UDT);\r
+ IO.mapRequired("SourceFile", Record.SourceFile);\r
+ IO.mapRequired("LineNumber", Record.LineNumber);\r
+}\r
+\r
+template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {\r
+ IO.mapRequired("UDT", Record.UDT);\r
+ IO.mapRequired("SourceFile", Record.SourceFile);\r
+ IO.mapRequired("LineNumber", Record.LineNumber);\r
+ IO.mapRequired("Module", Record.Module);\r
+}\r
+\r
+template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {\r
+ IO.mapRequired("ArgIndices", Record.ArgIndices);\r
+}\r
+\r
+template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {\r
+ IO.mapRequired("CompleteClass", Record.CompleteClass);\r
+ IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);\r
+ IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);\r
+ IO.mapRequired("MethodNames", Record.MethodNames);\r
+}\r
+\r
+template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {\r
+ IO.mapRequired("Methods", Record.Methods);\r
+}\r
+\r
+template <> void LeafRecordImpl<PrecompRecord>::map(IO &IO) {\r
+ IO.mapRequired("StartTypeIndex", Record.StartTypeIndex);\r
+ IO.mapRequired("TypesCount", Record.TypesCount);\r
+ IO.mapRequired("Signature", Record.Signature);\r
+ IO.mapRequired("PrecompFilePath", Record.PrecompFilePath);\r
+}\r
+\r
+template <> void LeafRecordImpl<EndPrecompRecord>::map(IO &IO) {\r
+ IO.mapRequired("Signature", Record.Signature);\r
+}\r
+\r
+template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {\r
+ MappingTraits<OneMethodRecord>::mapping(IO, Record);\r
+}\r
+\r
+template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {\r
+ IO.mapRequired("NumOverloads", Record.NumOverloads);\r
+ IO.mapRequired("MethodList", Record.MethodList);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {\r
+ IO.mapRequired("Type", Record.Type);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {\r
+ IO.mapRequired("Attrs", Record.Attrs.Attrs);\r
+ IO.mapRequired("Type", Record.Type);\r
+ IO.mapRequired("FieldOffset", Record.FieldOffset);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {\r
+ IO.mapRequired("Attrs", Record.Attrs.Attrs);\r
+ IO.mapRequired("Type", Record.Type);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {\r
+ IO.mapRequired("Attrs", Record.Attrs.Attrs);\r
+ IO.mapRequired("Value", Record.Value);\r
+ IO.mapRequired("Name", Record.Name);\r
+}\r
+\r
+template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {\r
+ IO.mapRequired("Type", Record.Type);\r
+}\r
+\r
+template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {\r
+ IO.mapRequired("Attrs", Record.Attrs.Attrs);\r
+ IO.mapRequired("Type", Record.Type);\r
+ IO.mapRequired("Offset", Record.Offset);\r
+}\r
+\r
+template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {\r
+ IO.mapRequired("Attrs", Record.Attrs.Attrs);\r
+ IO.mapRequired("BaseType", Record.BaseType);\r
+ IO.mapRequired("VBPtrType", Record.VBPtrType);\r
+ IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);\r
+ IO.mapRequired("VTableIndex", Record.VTableIndex);\r
+}\r
+\r
+template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {\r
+ IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);\r
+}\r
+\r
+} // end namespace detail\r
+} // end namespace CodeViewYAML\r
+} // end namespace llvm\r
+\r
+template <typename T>\r
+static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {\r
+ LeafRecord Result;\r
+\r
+ auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());\r
+ if (auto EC = Impl->fromCodeViewRecord(Type))\r
+ return std::move(EC);\r
+ Result.Leaf = Impl;\r
+ return Result;\r
+}\r
+\r
+Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {\r
+#define TYPE_RECORD(EnumName, EnumVal, ClassName) \\r
+ case EnumName: \\r
+ return fromCodeViewRecordImpl<ClassName##Record>(Type);\r
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \\r
+ TYPE_RECORD(EnumName, EnumVal, ClassName)\r
+#define MEMBER_RECORD(EnumName, EnumVal, ClassName)\r
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)\r
+ switch (Type.kind()) {\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+ default:\r
+ llvm_unreachable("Unknown leaf kind!");\r
+ }\r
+ return make_error<CodeViewError>(cv_error_code::corrupt_record);\r
+}\r
+\r
+CVType\r
+LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {\r
+ return Leaf->toCodeViewRecord(Serializer);\r
+}\r
+\r
+namespace llvm {\r
+namespace yaml {\r
+\r
+template <> struct MappingTraits<LeafRecordBase> {\r
+ static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }\r
+};\r
+\r
+template <> struct MappingTraits<MemberRecordBase> {\r
+ static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }\r
+};\r
+\r
+} // end namespace yaml\r
+} // end namespace llvm\r
+\r
+template <typename ConcreteType>\r
+static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,\r
+ LeafRecord &Obj) {\r
+ if (!IO.outputting())\r
+ Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);\r
+\r
+ if (Kind == LF_FIELDLIST)\r
+ Obj.Leaf->map(IO);\r
+ else\r
+ IO.mapRequired(Class, *Obj.Leaf);\r
+}\r
+\r
+void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {\r
+ TypeLeafKind Kind;\r
+ if (IO.outputting())\r
+ Kind = Obj.Leaf->Kind;\r
+ IO.mapRequired("Kind", Kind);\r
+\r
+#define TYPE_RECORD(EnumName, EnumVal, ClassName) \\r
+ case EnumName: \\r
+ mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \\r
+ break;\r
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \\r
+ TYPE_RECORD(EnumName, EnumVal, ClassName)\r
+#define MEMBER_RECORD(EnumName, EnumVal, ClassName)\r
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)\r
+ switch (Kind) {\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+ default: { llvm_unreachable("Unknown leaf kind!"); }\r
+ }\r
+}\r
+\r
+template <typename ConcreteType>\r
+static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,\r
+ MemberRecord &Obj) {\r
+ if (!IO.outputting())\r
+ Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);\r
+\r
+ IO.mapRequired(Class, *Obj.Member);\r
+}\r
+\r
+void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {\r
+ TypeLeafKind Kind;\r
+ if (IO.outputting())\r
+ Kind = Obj.Member->Kind;\r
+ IO.mapRequired("Kind", Kind);\r
+\r
+#define MEMBER_RECORD(EnumName, EnumVal, ClassName) \\r
+ case EnumName: \\r
+ mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \\r
+ break;\r
+#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \\r
+ MEMBER_RECORD(EnumName, EnumVal, ClassName)\r
+#define TYPE_RECORD(EnumName, EnumVal, ClassName)\r
+#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)\r
+ switch (Kind) {\r
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"\r
+ default: { llvm_unreachable("Unknown member kind!"); }\r
+ }\r
+}\r
+\r
+std::vector<LeafRecord>\r
+llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugTorP,\r
+ StringRef SectionName) {\r
+ ExitOnError Err("Invalid " + std::string(SectionName) + " section!");\r
+ BinaryStreamReader Reader(DebugTorP, support::little);\r
+ CVTypeArray Types;\r
+ uint32_t Magic;\r
+\r
+ Err(Reader.readInteger(Magic));\r
+ assert(Magic == COFF::DEBUG_SECTION_MAGIC &&\r
+ "Invalid .debug$T or .debug$P section!");\r
+\r
+ std::vector<LeafRecord> Result;\r
+ Err(Reader.readArray(Types, Reader.bytesRemaining()));\r
+ for (const auto &T : Types) {\r
+ auto CVT = Err(LeafRecord::fromCodeViewRecord(T));\r
+ Result.push_back(CVT);\r
+ }\r
+ return Result;\r
+}\r
+\r
+ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,\r
+ BumpPtrAllocator &Alloc,\r
+ StringRef SectionName) {\r
+ AppendingTypeTableBuilder TS(Alloc);\r
+ uint32_t Size = sizeof(uint32_t);\r
+ for (const auto &Leaf : Leafs) {\r
+ CVType T = Leaf.Leaf->toCodeViewRecord(TS);\r
+ Size += T.length();\r
+ assert(T.length() % 4 == 0 && "Improper type record alignment!");\r
+ }\r
+ uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);\r
+ MutableArrayRef<uint8_t> Output(ResultBuffer, Size);\r
+ BinaryStreamWriter Writer(Output, support::little);\r
+ ExitOnError Err("Error writing type record to " + std::string(SectionName) +\r
+ " section");\r
+ Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));\r
+ for (const auto &R : TS.records()) {\r
+ Err(Writer.writeBytes(R));\r
+ }\r
+ assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!");\r
+ return Output;\r
+}\r
--- /dev/null
+\r
+RUN: rm -rf %t1/\r
+RUN: mkdir %t1\r
+RUN: obj2yaml %S/Inputs/precomp-a.obj > %t1/precomp-a.yaml\r
+RUN: obj2yaml %S/Inputs/precomp.obj > %t1/precomp.yaml\r
+RUN: yaml2obj %t1/precomp-a.yaml > %t1/a.obj\r
+RUN: yaml2obj %t1/precomp.yaml > %t1/precomp.obj\r
+RUN: llvm-readobj -codeview %t1/a.obj | FileCheck %s -check-prefix PRECOMP\r
+RUN: llvm-readobj -codeview %t1/precomp.obj | FileCheck %s -check-prefix ENDPRECOMP\r
+RUN: llvm-pdbutil dump -types %t1/a.obj | FileCheck %s -check-prefix PDB-PRECOMP\r
+RUN: llvm-pdbutil dump -types %t1/precomp.obj | FileCheck %s -check-prefix PDB-ENDPRECOMP\r
+\r
+ENDPRECOMP: CodeViewTypes [\r
+ENDPRECOMP-NEXT: Section: .debug$P (3)\r
+ENDPRECOMP: EndPrecomp (0x1407) {\r
+ENDPRECOMP-NEXT: TypeLeafKind: LF_ENDPRECOMP (0x14)\r
+ENDPRECOMP-NEXT: Signature: 0x1116980E\r
+ENDPRECOMP-NEXT: }\r
+\r
+PRECOMP: CodeViewTypes [\r
+PRECOMP-NEXT: Section: .debug$T (3)\r
+PRECOMP-NEXT: Magic: 0x4\r
+PRECOMP-NEXT: Precomp (0x1000) {\r
+PRECOMP-NEXT: TypeLeafKind: LF_PRECOMP (0x1509)\r
+PRECOMP-NEXT: StartIndex: 0x1000\r
+PRECOMP-NEXT: Count: 0x407\r
+PRECOMP-NEXT: Signature: 0x1116980E\r
+\r
+PDB-PRECOMP: Types (.debug$T)\r
+PDB-PRECOMP-NEXT: ============================================================\r
+PDB-PRECOMP-NEXT: Showing 0 records\r
+PDB-PRECOMP-NEXT: 0x1000 | LF_PRECOMP [size = 60] start index = 0x1000, types count = 0x407, signature = 0x1116980E, precomp path = f:\svn\lld\test\coff\precomp\precomp.obj\r
+\r
+PDB-ENDPRECOMP: Precompiled Types (.debug$P)\r
+PDB-ENDPRECOMP-NEXT: ============================================================\r
+PDB-ENDPRECOMP-NEXT: Showing 0 records\r
+PDB-ENDPRECOMP: 0x1407 | LF_ENDPRECOMP [size = 8] signature = 0x1116980E\r
+\r
+# // precomp.h\r
+# #pragma once\r
+# int Function(char A);\r
+#\r
+# // precomp.cpp\r
+# // cl.exe precomp.cpp /Z7 /Ycprecomp.h /c\r
+# #include "precomp.h"\r
+#\r
+# // a.cpp\r
+# #include "precomp.h"\r
+# int main(void) {\r
+# Function('a');\r
+# return 0;\r
+# }\r
+#\r
+# // cl.exe a.cpp /Z7 /Yuprecomp.h /c\r
+#\r
+# // obj2yaml precomp.obj >precomp-precomp.yaml\r
+# // obj2yaml a.obj >precomp-a.yaml\r
static bool isDebugTSection(SectionRef Section, CVTypeArray &Types) {
BinaryStreamReader Reader;
- if (!isCodeViewDebugSubsection(Section, ".debug$T", Reader))
+ if (!isCodeViewDebugSubsection(Section, ".debug$T", Reader) &&
+ !isCodeViewDebugSubsection(Section, ".debug$P", Reader))
return false;
cantFail(Reader.readArray(Types, Reader.bytesRemaining()));
return true;
-//===- MinimalTypeDumper.cpp ---------------------------------- *- C++ --*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "MinimalTypeDumper.h"
-
-#include "FormatUtil.h"
-#include "LinePrinter.h"
-
-#include "llvm/DebugInfo/CodeView/CVRecord.h"
-#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
-#include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/Formatters.h"
-#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
-#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
-#include "llvm/Support/FormatVariadic.h"
-#include "llvm/Support/MathExtras.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-using namespace llvm::pdb;
-
-static std::string formatClassOptions(uint32_t IndentLevel,
- ClassOptions Options) {
- std::vector<std::string> Opts;
- PUSH_FLAG(ClassOptions, HasConstructorOrDestructor, Options,
- "has ctor / dtor");
- PUSH_FLAG(ClassOptions, ContainsNestedClass, Options,
- "contains nested class");
- PUSH_FLAG(ClassOptions, HasConversionOperator, Options,
- "conversion operator");
- PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref");
- PUSH_FLAG(ClassOptions, HasUniqueName, Options, "has unique name");
- PUSH_FLAG(ClassOptions, Intrinsic, Options, "intrin");
- PUSH_FLAG(ClassOptions, Nested, Options, "is nested");
- PUSH_FLAG(ClassOptions, HasOverloadedOperator, Options,
- "overloaded operator");
- PUSH_FLAG(ClassOptions, HasOverloadedAssignmentOperator, Options,
- "overloaded operator=");
- PUSH_FLAG(ClassOptions, Packed, Options, "packed");
- PUSH_FLAG(ClassOptions, Scoped, Options, "scoped");
- PUSH_FLAG(ClassOptions, Sealed, Options, "sealed");
-
- return typesetItemList(Opts, 4, IndentLevel, " | ");
-}
-
-static std::string pointerOptions(PointerOptions Options) {
- std::vector<std::string> Opts;
- PUSH_FLAG(PointerOptions, Flat32, Options, "flat32");
- PUSH_FLAG(PointerOptions, Volatile, Options, "volatile");
- PUSH_FLAG(PointerOptions, Const, Options, "const");
- PUSH_FLAG(PointerOptions, Unaligned, Options, "unaligned");
- PUSH_FLAG(PointerOptions, Restrict, Options, "restrict");
- PUSH_FLAG(PointerOptions, WinRTSmartPointer, Options, "winrt");
- if (Opts.empty())
- return "None";
- return join(Opts, " | ");
-}
-
-static std::string modifierOptions(ModifierOptions Options) {
- std::vector<std::string> Opts;
- PUSH_FLAG(ModifierOptions, Const, Options, "const");
- PUSH_FLAG(ModifierOptions, Volatile, Options, "volatile");
- PUSH_FLAG(ModifierOptions, Unaligned, Options, "unaligned");
- if (Opts.empty())
- return "None";
- return join(Opts, " | ");
-}
-
-static std::string formatCallingConvention(CallingConvention Convention) {
- switch (Convention) {
- RETURN_CASE(CallingConvention, AlphaCall, "alphacall");
- RETURN_CASE(CallingConvention, AM33Call, "am33call");
- RETURN_CASE(CallingConvention, ArmCall, "armcall");
- RETURN_CASE(CallingConvention, ClrCall, "clrcall");
- RETURN_CASE(CallingConvention, FarC, "far cdecl");
- RETURN_CASE(CallingConvention, FarFast, "far fastcall");
- RETURN_CASE(CallingConvention, FarPascal, "far pascal");
- RETURN_CASE(CallingConvention, FarStdCall, "far stdcall");
- RETURN_CASE(CallingConvention, FarSysCall, "far syscall");
- RETURN_CASE(CallingConvention, Generic, "generic");
- RETURN_CASE(CallingConvention, Inline, "inline");
- RETURN_CASE(CallingConvention, M32RCall, "m32rcall");
- RETURN_CASE(CallingConvention, MipsCall, "mipscall");
- RETURN_CASE(CallingConvention, NearC, "cdecl");
- RETURN_CASE(CallingConvention, NearFast, "fastcall");
- RETURN_CASE(CallingConvention, NearPascal, "pascal");
- RETURN_CASE(CallingConvention, NearStdCall, "stdcall");
- RETURN_CASE(CallingConvention, NearSysCall, "near syscall");
- RETURN_CASE(CallingConvention, NearVector, "vectorcall");
- RETURN_CASE(CallingConvention, PpcCall, "ppccall");
- RETURN_CASE(CallingConvention, SHCall, "shcall");
- RETURN_CASE(CallingConvention, SH5Call, "sh5call");
- RETURN_CASE(CallingConvention, ThisCall, "thiscall");
- RETURN_CASE(CallingConvention, TriCall, "tricall");
- }
- return formatUnknownEnum(Convention);
-}
-
-static std::string formatPointerMode(PointerMode Mode) {
- switch (Mode) {
- RETURN_CASE(PointerMode, LValueReference, "ref");
- RETURN_CASE(PointerMode, Pointer, "pointer");
- RETURN_CASE(PointerMode, PointerToDataMember, "data member pointer");
- RETURN_CASE(PointerMode, PointerToMemberFunction, "member fn pointer");
- RETURN_CASE(PointerMode, RValueReference, "rvalue ref");
- }
- return formatUnknownEnum(Mode);
-}
-
-static std::string memberAccess(MemberAccess Access) {
- switch (Access) {
- RETURN_CASE(MemberAccess, None, "");
- RETURN_CASE(MemberAccess, Private, "private");
- RETURN_CASE(MemberAccess, Protected, "protected");
- RETURN_CASE(MemberAccess, Public, "public");
- }
- return formatUnknownEnum(Access);
-}
-
-static std::string methodKind(MethodKind Kind) {
- switch (Kind) {
- RETURN_CASE(MethodKind, Vanilla, "");
- RETURN_CASE(MethodKind, Virtual, "virtual");
- RETURN_CASE(MethodKind, Static, "static");
- RETURN_CASE(MethodKind, Friend, "friend");
- RETURN_CASE(MethodKind, IntroducingVirtual, "intro virtual");
- RETURN_CASE(MethodKind, PureVirtual, "pure virtual");
- RETURN_CASE(MethodKind, PureIntroducingVirtual, "pure intro virtual");
- }
- return formatUnknownEnum(Kind);
-}
-
-static std::string pointerKind(PointerKind Kind) {
- switch (Kind) {
- RETURN_CASE(PointerKind, Near16, "ptr16");
- RETURN_CASE(PointerKind, Far16, "far ptr16");
- RETURN_CASE(PointerKind, Huge16, "huge ptr16");
- RETURN_CASE(PointerKind, BasedOnSegment, "segment based");
- RETURN_CASE(PointerKind, BasedOnValue, "value based");
- RETURN_CASE(PointerKind, BasedOnSegmentValue, "segment value based");
- RETURN_CASE(PointerKind, BasedOnAddress, "address based");
- RETURN_CASE(PointerKind, BasedOnSegmentAddress, "segment address based");
- RETURN_CASE(PointerKind, BasedOnType, "type based");
- RETURN_CASE(PointerKind, BasedOnSelf, "self based");
- RETURN_CASE(PointerKind, Near32, "ptr32");
- RETURN_CASE(PointerKind, Far32, "far ptr32");
- RETURN_CASE(PointerKind, Near64, "ptr64");
- }
- return formatUnknownEnum(Kind);
-}
-
-static std::string memberAttributes(const MemberAttributes &Attrs) {
- std::vector<std::string> Opts;
- std::string Access = memberAccess(Attrs.getAccess());
- std::string Kind = methodKind(Attrs.getMethodKind());
- if (!Access.empty())
- Opts.push_back(Access);
- if (!Kind.empty())
- Opts.push_back(Kind);
- MethodOptions Flags = Attrs.getFlags();
- PUSH_FLAG(MethodOptions, Pseudo, Flags, "pseudo");
- PUSH_FLAG(MethodOptions, NoInherit, Flags, "noinherit");
- PUSH_FLAG(MethodOptions, NoConstruct, Flags, "noconstruct");
- PUSH_FLAG(MethodOptions, CompilerGenerated, Flags, "compiler-generated");
- PUSH_FLAG(MethodOptions, Sealed, Flags, "sealed");
- return join(Opts, " ");
-}
-
-static std::string formatPointerAttrs(const PointerRecord &Record) {
- PointerMode Mode = Record.getMode();
- PointerOptions Opts = Record.getOptions();
- PointerKind Kind = Record.getPointerKind();
- return formatv("mode = {0}, opts = {1}, kind = {2}", formatPointerMode(Mode),
- pointerOptions(Opts), pointerKind(Kind));
-}
-
-static std::string formatFunctionOptions(FunctionOptions Options) {
- std::vector<std::string> Opts;
-
- PUSH_FLAG(FunctionOptions, CxxReturnUdt, Options, "returns cxx udt");
- PUSH_FLAG(FunctionOptions, ConstructorWithVirtualBases, Options,
- "constructor with virtual bases");
- PUSH_FLAG(FunctionOptions, Constructor, Options, "constructor");
- if (Opts.empty())
- return "None";
- return join(Opts, " | ");
-}
-
-Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
- // formatLine puts the newline at the beginning, so we use formatLine here
- // to start a new line, and then individual visit methods use format to
- // append to the existing line.
- if (!Hashes) {
- P.formatLine("{0} | {1} [size = {2}]",
- fmt_align(Index, AlignStyle::Right, Width),
- formatTypeLeafKind(Record.Type), Record.length());
- } else {
- std::string H;
- if (Index.toArrayIndex() >= HashValues.size()) {
- H = "(not present)";
- } else {
- uint32_t Hash = HashValues[Index.toArrayIndex()];
- Expected<uint32_t> MaybeHash = hashTypeRecord(Record);
- if (!MaybeHash)
- return MaybeHash.takeError();
- uint32_t OurHash = *MaybeHash;
- OurHash %= NumHashBuckets;
- if (Hash == OurHash)
- H = "0x" + utohexstr(Hash);
- else
- H = "0x" + utohexstr(Hash) + ", our hash = 0x" + utohexstr(OurHash);
- }
- P.formatLine("{0} | {1} [size = {2}, hash = {3}]",
- fmt_align(Index, AlignStyle::Right, Width),
- formatTypeLeafKind(Record.Type), Record.length(), H);
- }
- P.Indent(Width + 3);
- return Error::success();
-}
-Error MinimalTypeDumpVisitor::visitTypeEnd(CVType &Record) {
- P.Unindent(Width + 3);
- if (RecordBytes) {
- AutoIndent Indent(P, 9);
- P.formatBinary("Bytes", Record.RecordData, 0);
- }
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
- P.formatLine("- {0}", formatTypeLeafKind(Record.Kind));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
- if (RecordBytes) {
- AutoIndent Indent(P, 2);
- P.formatBinary("Bytes", Record.Data, 0);
- }
- return Error::success();
-}
-
-StringRef MinimalTypeDumpVisitor::getTypeName(TypeIndex TI) const {
- if (TI.isNoneType())
- return "";
- return Types.getTypeName(TI);
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- FieldListRecord &FieldList) {
- if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))
- return EC;
-
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- StringIdRecord &String) {
- P.format(" ID: {0}, String: {1}", String.getId(), String.getString());
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- ArgListRecord &Args) {
- auto Indices = Args.getIndices();
- if (Indices.empty())
- return Error::success();
-
- auto Max = std::max_element(Indices.begin(), Indices.end());
- uint32_t W = NumDigits(Max->getIndex()) + 2;
-
- for (auto I : Indices)
- P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
- getTypeName(I));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- StringListRecord &Strings) {
- auto Indices = Strings.getIndices();
- if (Indices.empty())
- return Error::success();
-
- auto Max = std::max_element(Indices.begin(), Indices.end());
- uint32_t W = NumDigits(Max->getIndex()) + 2;
-
- for (auto I : Indices)
- P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
- getTypeName(I));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- ClassRecord &Class) {
- P.format(" `{0}`", Class.Name);
- if (Class.hasUniqueName())
- P.formatLine("unique name: `{0}`", Class.UniqueName);
- P.formatLine("vtable: {0}, base list: {1}, field list: {2}",
- Class.VTableShape, Class.DerivationList, Class.FieldList);
- P.formatLine("options: {0}",
- formatClassOptions(P.getIndentLevel(), Class.Options));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- UnionRecord &Union) {
- P.format(" `{0}`", Union.Name);
- if (Union.hasUniqueName())
- P.formatLine("unique name: `{0}`", Union.UniqueName);
- P.formatLine("field list: {0}", Union.FieldList);
- P.formatLine("options: {0}",
- formatClassOptions(P.getIndentLevel(), Union.Options));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {
- P.format(" `{0}`", Enum.Name);
- if (Enum.hasUniqueName())
- P.formatLine("unique name: `{0}`", Enum.UniqueName);
- P.formatLine("field list: {0}, underlying type: {1}", Enum.FieldList,
- Enum.UnderlyingType);
- P.formatLine("options: {0}",
- formatClassOptions(P.getIndentLevel(), Enum.Options));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
- if (AT.Name.empty()) {
- P.formatLine("size: {0}, index type: {1}, element type: {2}", AT.Size,
- AT.IndexType, AT.ElementType);
- } else {
- P.formatLine("name: {0}, size: {1}, index type: {2}, element type: {3}",
- AT.Name, AT.Size, AT.IndexType, AT.ElementType);
- }
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- VFTableRecord &VFT) {
- P.formatLine("offset: {0}, complete class: {1}, overridden vftable: {2}",
- VFT.VFPtrOffset, VFT.CompleteClass, VFT.OverriddenVFTable);
- P.formatLine("method names: ");
- if (!VFT.MethodNames.empty()) {
- std::string Sep =
- formatv("\n{0}",
- fmt_repeat(' ', P.getIndentLevel() + strlen("method names: ")))
- .str();
- P.print(join(VFT.MethodNames, Sep));
- }
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- MemberFuncIdRecord &Id) {
- P.formatLine("name = {0}, type = {1}, class type = {2}", Id.Name,
- Id.FunctionType, Id.ClassType);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- ProcedureRecord &Proc) {
- P.formatLine("return type = {0}, # args = {1}, param list = {2}",
- Proc.ReturnType, Proc.ParameterCount, Proc.ArgumentList);
- P.formatLine("calling conv = {0}, options = {1}",
- formatCallingConvention(Proc.CallConv),
- formatFunctionOptions(Proc.Options));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- MemberFunctionRecord &MF) {
- P.formatLine("return type = {0}, # args = {1}, param list = {2}",
- MF.ReturnType, MF.ParameterCount, MF.ArgumentList);
- P.formatLine("class type = {0}, this type = {1}, this adjust = {2}",
- MF.ClassType, MF.ThisType, MF.ThisPointerAdjustment);
- P.formatLine("calling conv = {0}, options = {1}",
- formatCallingConvention(MF.CallConv),
- formatFunctionOptions(MF.Options));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- FuncIdRecord &Func) {
- P.formatLine("name = {0}, type = {1}, parent scope = {2}", Func.Name,
- Func.FunctionType, Func.ParentScope);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- TypeServer2Record &TS) {
- P.formatLine("name = {0}, age = {1}, guid = {2}", TS.Name, TS.Age, TS.Guid);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- PointerRecord &Ptr) {
- P.formatLine("referent = {0}, {1}", Ptr.ReferentType,
- formatPointerAttrs(Ptr));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- ModifierRecord &Mod) {
- P.formatLine("referent = {0}, modifiers = {1}", Mod.ModifiedType,
- modifierOptions(Mod.Modifiers));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- VFTableShapeRecord &Shape) {
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- UdtModSourceLineRecord &U) {
- P.formatLine("udt = {0}, mod = {1}, file = {2}, line = {3}", U.UDT, U.Module,
- U.SourceFile.getIndex(), U.LineNumber);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- UdtSourceLineRecord &U) {
- P.formatLine("udt = {0}, file = {1}, line = {2}", U.UDT,
- U.SourceFile.getIndex(), U.LineNumber);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- BitFieldRecord &BF) {
- P.formatLine("type = {0}, bit offset = {1}, # bits = {2}", BF.Type,
- BF.BitOffset, BF.BitSize);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(
- CVType &CVR, MethodOverloadListRecord &Overloads) {
- for (auto &M : Overloads.Methods)
- P.formatLine("- Method [type = {0}, vftable offset = {1}, attrs = {2}]",
- M.Type, M.VFTableOffset, memberAttributes(M.Attrs));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,
- BuildInfoRecord &BI) {
- auto Indices = BI.ArgIndices;
- if (Indices.empty())
- return Error::success();
-
- auto Max = std::max_element(Indices.begin(), Indices.end());
- uint32_t W = NumDigits(Max->getIndex()) + 2;
-
- for (auto I : Indices)
- P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),
- getTypeName(I));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &R) {
- std::string Type = (R.Mode == LabelType::Far) ? "far" : "near";
- P.format(" type = {0}", Type);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- NestedTypeRecord &Nested) {
- P.format(" [name = `{0}`, parent = {1}]", Nested.Name, Nested.Type);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- OneMethodRecord &Method) {
- P.format(" [name = `{0}`]", Method.Name);
- AutoIndent Indent(P);
- P.formatLine("type = {0}, vftable offset = {1}, attrs = {2}", Method.Type,
- Method.VFTableOffset, memberAttributes(Method.Attrs));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- OverloadedMethodRecord &Method) {
- P.format(" [name = `{0}`, # overloads = {1}, overload list = {2}]",
- Method.Name, Method.NumOverloads, Method.MethodList);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- DataMemberRecord &Field) {
- P.format(" [name = `{0}`, Type = {1}, offset = {2}, attrs = {3}]", Field.Name,
- Field.Type, Field.FieldOffset, memberAttributes(Field.Attrs));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- StaticDataMemberRecord &Field) {
- P.format(" [name = `{0}`, type = {1}, attrs = {2}]", Field.Name, Field.Type,
- memberAttributes(Field.Attrs));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- EnumeratorRecord &Enum) {
- P.format(" [{0} = {1}]", Enum.Name,
- Enum.Value.toString(10, Enum.Value.isSigned()));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- BaseClassRecord &Base) {
- AutoIndent Indent(P);
- P.formatLine("type = {0}, offset = {1}, attrs = {2}", Base.Type, Base.Offset,
- memberAttributes(Base.Attrs));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- VirtualBaseClassRecord &Base) {
- AutoIndent Indent(P);
- P.formatLine(
- "base = {0}, vbptr = {1}, vbptr offset = {2}, vtable index = {3}",
- Base.BaseType, Base.VBPtrType, Base.VBPtrOffset, Base.VTableIndex);
- P.formatLine("attrs = {0}", memberAttributes(Base.Attrs));
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- ListContinuationRecord &Cont) {
- P.format(" continuation = {0}", Cont.ContinuationIndex);
- return Error::success();
-}
-
-Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,
- VFPtrRecord &VFP) {
- P.format(" type = {0}", VFP.Type);
- return Error::success();
-}
+//===- MinimalTypeDumper.cpp ---------------------------------- *- C++ --*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "MinimalTypeDumper.h"\r
+\r
+#include "FormatUtil.h"\r
+#include "LinePrinter.h"\r
+\r
+#include "llvm/DebugInfo/CodeView/CVRecord.h"\r
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"\r
+#include "llvm/DebugInfo/CodeView/CodeView.h"\r
+#include "llvm/DebugInfo/CodeView/Formatters.h"\r
+#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"\r
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"\r
+#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"\r
+#include "llvm/Support/FormatVariadic.h"\r
+#include "llvm/Support/MathExtras.h"\r
+\r
+using namespace llvm;\r
+using namespace llvm::codeview;\r
+using namespace llvm::pdb;\r
+\r
+static std::string formatClassOptions(uint32_t IndentLevel,\r
+ ClassOptions Options) {\r
+ std::vector<std::string> Opts;\r
+ PUSH_FLAG(ClassOptions, HasConstructorOrDestructor, Options,\r
+ "has ctor / dtor");\r
+ PUSH_FLAG(ClassOptions, ContainsNestedClass, Options,\r
+ "contains nested class");\r
+ PUSH_FLAG(ClassOptions, HasConversionOperator, Options,\r
+ "conversion operator");\r
+ PUSH_FLAG(ClassOptions, ForwardReference, Options, "forward ref");\r
+ PUSH_FLAG(ClassOptions, HasUniqueName, Options, "has unique name");\r
+ PUSH_FLAG(ClassOptions, Intrinsic, Options, "intrin");\r
+ PUSH_FLAG(ClassOptions, Nested, Options, "is nested");\r
+ PUSH_FLAG(ClassOptions, HasOverloadedOperator, Options,\r
+ "overloaded operator");\r
+ PUSH_FLAG(ClassOptions, HasOverloadedAssignmentOperator, Options,\r
+ "overloaded operator=");\r
+ PUSH_FLAG(ClassOptions, Packed, Options, "packed");\r
+ PUSH_FLAG(ClassOptions, Scoped, Options, "scoped");\r
+ PUSH_FLAG(ClassOptions, Sealed, Options, "sealed");\r
+\r
+ return typesetItemList(Opts, 4, IndentLevel, " | ");\r
+}\r
+\r
+static std::string pointerOptions(PointerOptions Options) {\r
+ std::vector<std::string> Opts;\r
+ PUSH_FLAG(PointerOptions, Flat32, Options, "flat32");\r
+ PUSH_FLAG(PointerOptions, Volatile, Options, "volatile");\r
+ PUSH_FLAG(PointerOptions, Const, Options, "const");\r
+ PUSH_FLAG(PointerOptions, Unaligned, Options, "unaligned");\r
+ PUSH_FLAG(PointerOptions, Restrict, Options, "restrict");\r
+ PUSH_FLAG(PointerOptions, WinRTSmartPointer, Options, "winrt");\r
+ if (Opts.empty())\r
+ return "None";\r
+ return join(Opts, " | ");\r
+}\r
+\r
+static std::string modifierOptions(ModifierOptions Options) {\r
+ std::vector<std::string> Opts;\r
+ PUSH_FLAG(ModifierOptions, Const, Options, "const");\r
+ PUSH_FLAG(ModifierOptions, Volatile, Options, "volatile");\r
+ PUSH_FLAG(ModifierOptions, Unaligned, Options, "unaligned");\r
+ if (Opts.empty())\r
+ return "None";\r
+ return join(Opts, " | ");\r
+}\r
+\r
+static std::string formatCallingConvention(CallingConvention Convention) {\r
+ switch (Convention) {\r
+ RETURN_CASE(CallingConvention, AlphaCall, "alphacall");\r
+ RETURN_CASE(CallingConvention, AM33Call, "am33call");\r
+ RETURN_CASE(CallingConvention, ArmCall, "armcall");\r
+ RETURN_CASE(CallingConvention, ClrCall, "clrcall");\r
+ RETURN_CASE(CallingConvention, FarC, "far cdecl");\r
+ RETURN_CASE(CallingConvention, FarFast, "far fastcall");\r
+ RETURN_CASE(CallingConvention, FarPascal, "far pascal");\r
+ RETURN_CASE(CallingConvention, FarStdCall, "far stdcall");\r
+ RETURN_CASE(CallingConvention, FarSysCall, "far syscall");\r
+ RETURN_CASE(CallingConvention, Generic, "generic");\r
+ RETURN_CASE(CallingConvention, Inline, "inline");\r
+ RETURN_CASE(CallingConvention, M32RCall, "m32rcall");\r
+ RETURN_CASE(CallingConvention, MipsCall, "mipscall");\r
+ RETURN_CASE(CallingConvention, NearC, "cdecl");\r
+ RETURN_CASE(CallingConvention, NearFast, "fastcall");\r
+ RETURN_CASE(CallingConvention, NearPascal, "pascal");\r
+ RETURN_CASE(CallingConvention, NearStdCall, "stdcall");\r
+ RETURN_CASE(CallingConvention, NearSysCall, "near syscall");\r
+ RETURN_CASE(CallingConvention, NearVector, "vectorcall");\r
+ RETURN_CASE(CallingConvention, PpcCall, "ppccall");\r
+ RETURN_CASE(CallingConvention, SHCall, "shcall");\r
+ RETURN_CASE(CallingConvention, SH5Call, "sh5call");\r
+ RETURN_CASE(CallingConvention, ThisCall, "thiscall");\r
+ RETURN_CASE(CallingConvention, TriCall, "tricall");\r
+ }\r
+ return formatUnknownEnum(Convention);\r
+}\r
+\r
+static std::string formatPointerMode(PointerMode Mode) {\r
+ switch (Mode) {\r
+ RETURN_CASE(PointerMode, LValueReference, "ref");\r
+ RETURN_CASE(PointerMode, Pointer, "pointer");\r
+ RETURN_CASE(PointerMode, PointerToDataMember, "data member pointer");\r
+ RETURN_CASE(PointerMode, PointerToMemberFunction, "member fn pointer");\r
+ RETURN_CASE(PointerMode, RValueReference, "rvalue ref");\r
+ }\r
+ return formatUnknownEnum(Mode);\r
+}\r
+\r
+static std::string memberAccess(MemberAccess Access) {\r
+ switch (Access) {\r
+ RETURN_CASE(MemberAccess, None, "");\r
+ RETURN_CASE(MemberAccess, Private, "private");\r
+ RETURN_CASE(MemberAccess, Protected, "protected");\r
+ RETURN_CASE(MemberAccess, Public, "public");\r
+ }\r
+ return formatUnknownEnum(Access);\r
+}\r
+\r
+static std::string methodKind(MethodKind Kind) {\r
+ switch (Kind) {\r
+ RETURN_CASE(MethodKind, Vanilla, "");\r
+ RETURN_CASE(MethodKind, Virtual, "virtual");\r
+ RETURN_CASE(MethodKind, Static, "static");\r
+ RETURN_CASE(MethodKind, Friend, "friend");\r
+ RETURN_CASE(MethodKind, IntroducingVirtual, "intro virtual");\r
+ RETURN_CASE(MethodKind, PureVirtual, "pure virtual");\r
+ RETURN_CASE(MethodKind, PureIntroducingVirtual, "pure intro virtual");\r
+ }\r
+ return formatUnknownEnum(Kind);\r
+}\r
+\r
+static std::string pointerKind(PointerKind Kind) {\r
+ switch (Kind) {\r
+ RETURN_CASE(PointerKind, Near16, "ptr16");\r
+ RETURN_CASE(PointerKind, Far16, "far ptr16");\r
+ RETURN_CASE(PointerKind, Huge16, "huge ptr16");\r
+ RETURN_CASE(PointerKind, BasedOnSegment, "segment based");\r
+ RETURN_CASE(PointerKind, BasedOnValue, "value based");\r
+ RETURN_CASE(PointerKind, BasedOnSegmentValue, "segment value based");\r
+ RETURN_CASE(PointerKind, BasedOnAddress, "address based");\r
+ RETURN_CASE(PointerKind, BasedOnSegmentAddress, "segment address based");\r
+ RETURN_CASE(PointerKind, BasedOnType, "type based");\r
+ RETURN_CASE(PointerKind, BasedOnSelf, "self based");\r
+ RETURN_CASE(PointerKind, Near32, "ptr32");\r
+ RETURN_CASE(PointerKind, Far32, "far ptr32");\r
+ RETURN_CASE(PointerKind, Near64, "ptr64");\r
+ }\r
+ return formatUnknownEnum(Kind);\r
+}\r
+\r
+static std::string memberAttributes(const MemberAttributes &Attrs) {\r
+ std::vector<std::string> Opts;\r
+ std::string Access = memberAccess(Attrs.getAccess());\r
+ std::string Kind = methodKind(Attrs.getMethodKind());\r
+ if (!Access.empty())\r
+ Opts.push_back(Access);\r
+ if (!Kind.empty())\r
+ Opts.push_back(Kind);\r
+ MethodOptions Flags = Attrs.getFlags();\r
+ PUSH_FLAG(MethodOptions, Pseudo, Flags, "pseudo");\r
+ PUSH_FLAG(MethodOptions, NoInherit, Flags, "noinherit");\r
+ PUSH_FLAG(MethodOptions, NoConstruct, Flags, "noconstruct");\r
+ PUSH_FLAG(MethodOptions, CompilerGenerated, Flags, "compiler-generated");\r
+ PUSH_FLAG(MethodOptions, Sealed, Flags, "sealed");\r
+ return join(Opts, " ");\r
+}\r
+\r
+static std::string formatPointerAttrs(const PointerRecord &Record) {\r
+ PointerMode Mode = Record.getMode();\r
+ PointerOptions Opts = Record.getOptions();\r
+ PointerKind Kind = Record.getPointerKind();\r
+ return formatv("mode = {0}, opts = {1}, kind = {2}", formatPointerMode(Mode),\r
+ pointerOptions(Opts), pointerKind(Kind));\r
+}\r
+\r
+static std::string formatFunctionOptions(FunctionOptions Options) {\r
+ std::vector<std::string> Opts;\r
+\r
+ PUSH_FLAG(FunctionOptions, CxxReturnUdt, Options, "returns cxx udt");\r
+ PUSH_FLAG(FunctionOptions, ConstructorWithVirtualBases, Options,\r
+ "constructor with virtual bases");\r
+ PUSH_FLAG(FunctionOptions, Constructor, Options, "constructor");\r
+ if (Opts.empty())\r
+ return "None";\r
+ return join(Opts, " | ");\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {\r
+ // formatLine puts the newline at the beginning, so we use formatLine here\r
+ // to start a new line, and then individual visit methods use format to\r
+ // append to the existing line.\r
+ if (!Hashes) {\r
+ P.formatLine("{0} | {1} [size = {2}]",\r
+ fmt_align(Index, AlignStyle::Right, Width),\r
+ formatTypeLeafKind(Record.Type), Record.length());\r
+ } else {\r
+ std::string H;\r
+ if (Index.toArrayIndex() >= HashValues.size()) {\r
+ H = "(not present)";\r
+ } else {\r
+ uint32_t Hash = HashValues[Index.toArrayIndex()];\r
+ Expected<uint32_t> MaybeHash = hashTypeRecord(Record);\r
+ if (!MaybeHash)\r
+ return MaybeHash.takeError();\r
+ uint32_t OurHash = *MaybeHash;\r
+ OurHash %= NumHashBuckets;\r
+ if (Hash == OurHash)\r
+ H = "0x" + utohexstr(Hash);\r
+ else\r
+ H = "0x" + utohexstr(Hash) + ", our hash = 0x" + utohexstr(OurHash);\r
+ }\r
+ P.formatLine("{0} | {1} [size = {2}, hash = {3}]",\r
+ fmt_align(Index, AlignStyle::Right, Width),\r
+ formatTypeLeafKind(Record.Type), Record.length(), H);\r
+ }\r
+ P.Indent(Width + 3);\r
+ return Error::success();\r
+}\r
+Error MinimalTypeDumpVisitor::visitTypeEnd(CVType &Record) {\r
+ P.Unindent(Width + 3);\r
+ if (RecordBytes) {\r
+ AutoIndent Indent(P, 9);\r
+ P.formatBinary("Bytes", Record.RecordData, 0);\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {\r
+ P.formatLine("- {0}", formatTypeLeafKind(Record.Kind));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {\r
+ if (RecordBytes) {\r
+ AutoIndent Indent(P, 2);\r
+ P.formatBinary("Bytes", Record.Data, 0);\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+StringRef MinimalTypeDumpVisitor::getTypeName(TypeIndex TI) const {\r
+ if (TI.isNoneType())\r
+ return "";\r
+ return Types.getTypeName(TI);\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ FieldListRecord &FieldList) {\r
+ if (auto EC = codeview::visitMemberRecordStream(FieldList.Data, *this))\r
+ return EC;\r
+\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ StringIdRecord &String) {\r
+ P.format(" ID: {0}, String: {1}", String.getId(), String.getString());\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ ArgListRecord &Args) {\r
+ auto Indices = Args.getIndices();\r
+ if (Indices.empty())\r
+ return Error::success();\r
+\r
+ auto Max = std::max_element(Indices.begin(), Indices.end());\r
+ uint32_t W = NumDigits(Max->getIndex()) + 2;\r
+\r
+ for (auto I : Indices)\r
+ P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),\r
+ getTypeName(I));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ StringListRecord &Strings) {\r
+ auto Indices = Strings.getIndices();\r
+ if (Indices.empty())\r
+ return Error::success();\r
+\r
+ auto Max = std::max_element(Indices.begin(), Indices.end());\r
+ uint32_t W = NumDigits(Max->getIndex()) + 2;\r
+\r
+ for (auto I : Indices)\r
+ P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),\r
+ getTypeName(I));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ ClassRecord &Class) {\r
+ P.format(" `{0}`", Class.Name);\r
+ if (Class.hasUniqueName())\r
+ P.formatLine("unique name: `{0}`", Class.UniqueName);\r
+ P.formatLine("vtable: {0}, base list: {1}, field list: {2}",\r
+ Class.VTableShape, Class.DerivationList, Class.FieldList);\r
+ P.formatLine("options: {0}",\r
+ formatClassOptions(P.getIndentLevel(), Class.Options));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ UnionRecord &Union) {\r
+ P.format(" `{0}`", Union.Name);\r
+ if (Union.hasUniqueName())\r
+ P.formatLine("unique name: `{0}`", Union.UniqueName);\r
+ P.formatLine("field list: {0}", Union.FieldList);\r
+ P.formatLine("options: {0}",\r
+ formatClassOptions(P.getIndentLevel(), Union.Options));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {\r
+ P.format(" `{0}`", Enum.Name);\r
+ if (Enum.hasUniqueName())\r
+ P.formatLine("unique name: `{0}`", Enum.UniqueName);\r
+ P.formatLine("field list: {0}, underlying type: {1}", Enum.FieldList,\r
+ Enum.UnderlyingType);\r
+ P.formatLine("options: {0}",\r
+ formatClassOptions(P.getIndentLevel(), Enum.Options));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {\r
+ if (AT.Name.empty()) {\r
+ P.formatLine("size: {0}, index type: {1}, element type: {2}", AT.Size,\r
+ AT.IndexType, AT.ElementType);\r
+ } else {\r
+ P.formatLine("name: {0}, size: {1}, index type: {2}, element type: {3}",\r
+ AT.Name, AT.Size, AT.IndexType, AT.ElementType);\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ VFTableRecord &VFT) {\r
+ P.formatLine("offset: {0}, complete class: {1}, overridden vftable: {2}",\r
+ VFT.VFPtrOffset, VFT.CompleteClass, VFT.OverriddenVFTable);\r
+ P.formatLine("method names: ");\r
+ if (!VFT.MethodNames.empty()) {\r
+ std::string Sep =\r
+ formatv("\n{0}",\r
+ fmt_repeat(' ', P.getIndentLevel() + strlen("method names: ")))\r
+ .str();\r
+ P.print(join(VFT.MethodNames, Sep));\r
+ }\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ MemberFuncIdRecord &Id) {\r
+ P.formatLine("name = {0}, type = {1}, class type = {2}", Id.Name,\r
+ Id.FunctionType, Id.ClassType);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ ProcedureRecord &Proc) {\r
+ P.formatLine("return type = {0}, # args = {1}, param list = {2}",\r
+ Proc.ReturnType, Proc.ParameterCount, Proc.ArgumentList);\r
+ P.formatLine("calling conv = {0}, options = {1}",\r
+ formatCallingConvention(Proc.CallConv),\r
+ formatFunctionOptions(Proc.Options));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ MemberFunctionRecord &MF) {\r
+ P.formatLine("return type = {0}, # args = {1}, param list = {2}",\r
+ MF.ReturnType, MF.ParameterCount, MF.ArgumentList);\r
+ P.formatLine("class type = {0}, this type = {1}, this adjust = {2}",\r
+ MF.ClassType, MF.ThisType, MF.ThisPointerAdjustment);\r
+ P.formatLine("calling conv = {0}, options = {1}",\r
+ formatCallingConvention(MF.CallConv),\r
+ formatFunctionOptions(MF.Options));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ FuncIdRecord &Func) {\r
+ P.formatLine("name = {0}, type = {1}, parent scope = {2}", Func.Name,\r
+ Func.FunctionType, Func.ParentScope);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ TypeServer2Record &TS) {\r
+ P.formatLine("name = {0}, age = {1}, guid = {2}", TS.Name, TS.Age, TS.Guid);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ PointerRecord &Ptr) {\r
+ P.formatLine("referent = {0}, {1}", Ptr.ReferentType,\r
+ formatPointerAttrs(Ptr));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ ModifierRecord &Mod) {\r
+ P.formatLine("referent = {0}, modifiers = {1}", Mod.ModifiedType,\r
+ modifierOptions(Mod.Modifiers));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ VFTableShapeRecord &Shape) {\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ UdtModSourceLineRecord &U) {\r
+ P.formatLine("udt = {0}, mod = {1}, file = {2}, line = {3}", U.UDT, U.Module,\r
+ U.SourceFile.getIndex(), U.LineNumber);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ UdtSourceLineRecord &U) {\r
+ P.formatLine("udt = {0}, file = {1}, line = {2}", U.UDT,\r
+ U.SourceFile.getIndex(), U.LineNumber);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ BitFieldRecord &BF) {\r
+ P.formatLine("type = {0}, bit offset = {1}, # bits = {2}", BF.Type,\r
+ BF.BitOffset, BF.BitSize);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(\r
+ CVType &CVR, MethodOverloadListRecord &Overloads) {\r
+ for (auto &M : Overloads.Methods)\r
+ P.formatLine("- Method [type = {0}, vftable offset = {1}, attrs = {2}]",\r
+ M.Type, M.VFTableOffset, memberAttributes(M.Attrs));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ BuildInfoRecord &BI) {\r
+ auto Indices = BI.ArgIndices;\r
+ if (Indices.empty())\r
+ return Error::success();\r
+\r
+ auto Max = std::max_element(Indices.begin(), Indices.end());\r
+ uint32_t W = NumDigits(Max->getIndex()) + 2;\r
+\r
+ for (auto I : Indices)\r
+ P.formatLine("{0}: `{1}`", fmt_align(I, AlignStyle::Right, W),\r
+ getTypeName(I));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR, LabelRecord &R) {\r
+ std::string Type = (R.Mode == LabelType::Far) ? "far" : "near";\r
+ P.format(" type = {0}", Type);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ PrecompRecord &Precomp) {\r
+ P.format(" start index = {0:X+}, types count = {1:X+}, signature = {2:X+},"\r
+ " precomp path = {3}",\r
+ Precomp.StartTypeIndex, Precomp.TypesCount, Precomp.Signature,\r
+ Precomp.PrecompFilePath);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownRecord(CVType &CVR,\r
+ EndPrecompRecord &EP) {\r
+ P.format(" signature = {0:X+}", EP.Signature);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ NestedTypeRecord &Nested) {\r
+ P.format(" [name = `{0}`, parent = {1}]", Nested.Name, Nested.Type);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ OneMethodRecord &Method) {\r
+ P.format(" [name = `{0}`]", Method.Name);\r
+ AutoIndent Indent(P);\r
+ P.formatLine("type = {0}, vftable offset = {1}, attrs = {2}", Method.Type,\r
+ Method.VFTableOffset, memberAttributes(Method.Attrs));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ OverloadedMethodRecord &Method) {\r
+ P.format(" [name = `{0}`, # overloads = {1}, overload list = {2}]",\r
+ Method.Name, Method.NumOverloads, Method.MethodList);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ DataMemberRecord &Field) {\r
+ P.format(" [name = `{0}`, Type = {1}, offset = {2}, attrs = {3}]", Field.Name,\r
+ Field.Type, Field.FieldOffset, memberAttributes(Field.Attrs));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ StaticDataMemberRecord &Field) {\r
+ P.format(" [name = `{0}`, type = {1}, attrs = {2}]", Field.Name, Field.Type,\r
+ memberAttributes(Field.Attrs));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ EnumeratorRecord &Enum) {\r
+ P.format(" [{0} = {1}]", Enum.Name,\r
+ Enum.Value.toString(10, Enum.Value.isSigned()));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ BaseClassRecord &Base) {\r
+ AutoIndent Indent(P);\r
+ P.formatLine("type = {0}, offset = {1}, attrs = {2}", Base.Type, Base.Offset,\r
+ memberAttributes(Base.Attrs));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ VirtualBaseClassRecord &Base) {\r
+ AutoIndent Indent(P);\r
+ P.formatLine(\r
+ "base = {0}, vbptr = {1}, vbptr offset = {2}, vtable index = {3}",\r
+ Base.BaseType, Base.VBPtrType, Base.VBPtrOffset, Base.VTableIndex);\r
+ P.formatLine("attrs = {0}", memberAttributes(Base.Attrs));\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ ListContinuationRecord &Cont) {\r
+ P.format(" continuation = {0}", Cont.ContinuationIndex);\r
+ return Error::success();\r
+}\r
+\r
+Error MinimalTypeDumpVisitor::visitKnownMember(CVMemberRecord &CVR,\r
+ VFPtrRecord &VFP) {\r
+ P.format(" type = {0}", VFP.Type);\r
+ return Error::success();\r
+}\r
if (NewYAMLSection.Name == ".debug$S")
NewYAMLSection.DebugS = CodeViewYAML::fromDebugS(sectionData, SC);
else if (NewYAMLSection.Name == ".debug$T")
- NewYAMLSection.DebugT = CodeViewYAML::fromDebugT(sectionData);
+ NewYAMLSection.DebugT = CodeViewYAML::fromDebugT(sectionData,
+ NewYAMLSection.Name);
+ else if (NewYAMLSection.Name == ".debug$P")
+ NewYAMLSection.DebugP = CodeViewYAML::fromDebugT(sectionData,
+ NewYAMLSection.Name);
else if (NewYAMLSection.Name == ".debug$H")
NewYAMLSection.DebugH = CodeViewYAML::fromDebugH(sectionData);
}
} else if (S.Name == ".debug$T") {
if (S.SectionData.binary_size() == 0)
- S.SectionData = CodeViewYAML::toDebugT(S.DebugT, CP.Allocator);
+ S.SectionData = CodeViewYAML::toDebugT(S.DebugT, CP.Allocator, S.Name);
+ } else if (S.Name == ".debug$P") {
+ if (S.SectionData.binary_size() == 0)
+ S.SectionData = CodeViewYAML::toDebugT(S.DebugP, CP.Allocator, S.Name);
} else if (S.Name == ".debug$H") {
if (S.DebugH.hasValue() && S.SectionData.binary_size() == 0)
S.SectionData = CodeViewYAML::toDebugH(*S.DebugH, CP.Allocator);
-//===- llvm/unittest/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp --------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
-
-#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
-#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
-#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
-#include "llvm/Support/Allocator.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-using namespace llvm::codeview;
-
-class TypeIndexIteratorTest : public testing::Test {
-public:
- TypeIndexIteratorTest() {}
-
- void SetUp() override {
- Refs.clear();
- TTB = make_unique<AppendingTypeTableBuilder>(Storage);
- CRB = make_unique<ContinuationRecordBuilder>();
- Symbols.clear();
- }
-
- void TearDown() override {
- CRB.reset();
- TTB.reset();
- }
-
-protected:
- template <typename... Indices>
- bool checkTypeReferences(uint32_t RecordIndex, Indices &&... TIs) const {
- EXPECT_EQ(sizeof...(Indices), countRefs(RecordIndex));
-
- // Choose between type or symbol records. The checking code doesn't care
- // which we have.
- std::vector<ArrayRef<uint8_t>> CVRecords;
- if (Symbols.empty()) {
- CVRecords = TTB->records();
- } else {
- for (const CVSymbol &S : Symbols)
- CVRecords.push_back(S.data());
- }
-
- return checkTypeReferencesImpl(RecordIndex, CVRecords,
- std::forward<Indices>(TIs)...);
- }
-
- template <typename... T> void writeFieldList(T &&... MemberRecords) {
- CRB->begin(ContinuationRecordKind::FieldList);
- writeFieldListImpl(std::forward<T>(MemberRecords)...);
- auto Records = CRB->end(TTB->nextTypeIndex());
- ASSERT_EQ(1u, Records.size());
- TTB->insertRecordBytes(Records.front().RecordData);
- discoverAllTypeIndices();
- }
-
- template <typename... T> void writeTypeRecords(T &&... Records) {
- writeTypeRecordsImpl(std::forward<T>(Records)...);
- ASSERT_EQ(sizeof...(T), TTB->records().size());
- discoverAllTypeIndices();
- }
-
- template <typename... T> void writeSymbolRecords(T &&... Records) {
- writeSymbolRecordsImpl(std::forward<T>(Records)...);
- ASSERT_EQ(sizeof...(T), Symbols.size());
- discoverTypeIndicesInSymbols();
- }
-
- std::unique_ptr<AppendingTypeTableBuilder> TTB;
-
-private:
- uint32_t countRefs(uint32_t RecordIndex) const {
- auto &R = Refs[RecordIndex];
- uint32_t Count = 0;
- for (auto &Ref : R) {
- Count += Ref.Count;
- }
- return Count;
- }
-
- bool checkOneTypeReference(uint32_t RecordIndex, ArrayRef<uint8_t> RecordData,
- TypeIndex TI) const {
- RecordData = RecordData.drop_front(sizeof(RecordPrefix));
- auto &RefList = Refs[RecordIndex];
- for (auto &Ref : RefList) {
- uint32_t Offset = Ref.Offset;
- ArrayRef<uint8_t> Loc = RecordData.drop_front(Offset);
- ArrayRef<TypeIndex> Indices(
- reinterpret_cast<const TypeIndex *>(Loc.data()), Ref.Count);
- if (llvm::any_of(Indices,
- [TI](const TypeIndex &Other) { return Other == TI; }))
- return true;
- }
- return false;
- }
-
- template <typename... Indices>
- bool checkTypeReferencesImpl(uint32_t RecordIndex,
- ArrayRef<ArrayRef<uint8_t>> CVRecords) const {
- return true;
- }
-
- template <typename... Indices>
- bool checkTypeReferencesImpl(uint32_t RecordIndex,
- ArrayRef<ArrayRef<uint8_t>> CVRecords,
- TypeIndex TI, Indices &&... Rest) const {
- ArrayRef<uint8_t> Record = CVRecords[RecordIndex];
- bool Success = checkOneTypeReference(RecordIndex, Record, TI);
- EXPECT_TRUE(Success);
- return Success & checkTypeReferencesImpl(RecordIndex, CVRecords,
- std::forward<Indices>(Rest)...);
- }
-
- void discoverAllTypeIndices() {
- Refs.resize(TTB->records().size());
- for (uint32_t I = 0; I < TTB->records().size(); ++I) {
- ArrayRef<uint8_t> Data = TTB->records()[I];
- discoverTypeIndices(Data, Refs[I]);
- }
- }
-
- void discoverTypeIndicesInSymbols() {
- Refs.resize(Symbols.size());
- for (uint32_t I = 0; I < Symbols.size(); ++I)
- discoverTypeIndicesInSymbol(Symbols[I], Refs[I]);
- }
-
- // Helper function to write out a field list record with the given list
- // of member records.
- void writeFieldListImpl() {}
-
- template <typename RecType, typename... Rest>
- void writeFieldListImpl(RecType &&Record, Rest &&... Records) {
- CRB->writeMemberType(Record);
- writeFieldListImpl(std::forward<Rest>(Records)...);
- }
-
- // Helper function to write out a list of type records.
- void writeTypeRecordsImpl() {}
-
- template <typename RecType, typename... Rest>
- void writeTypeRecordsImpl(RecType &&Record, Rest &&... Records) {
- TTB->writeLeafType(Record);
- writeTypeRecordsImpl(std::forward<Rest>(Records)...);
- }
-
- // Helper function to write out a list of symbol records.
- void writeSymbolRecordsImpl() {}
-
- template <typename RecType, typename... Rest>
- void writeSymbolRecordsImpl(RecType &&Record, Rest &&... Records) {
- Symbols.push_back(SymbolSerializer::writeOneSymbol(Record, Storage,
- CodeViewContainer::Pdb));
- writeSymbolRecordsImpl(std::forward<Rest>(Records)...);
- }
-
- std::vector<SmallVector<TiReference, 4>> Refs;
- std::unique_ptr<ContinuationRecordBuilder> CRB;
- std::vector<CVSymbol> Symbols;
- BumpPtrAllocator Storage;
-};
-
-namespace leafs {
-static FuncIdRecord FuncId(TypeIndex(1), TypeIndex(2), "FuncId");
-static MemberFuncIdRecord MemFuncId(TypeIndex(3), TypeIndex(4), "FuncId");
-static StringIdRecord StringId(TypeIndex(5), "TheString");
-static struct {
- std::vector<TypeIndex> Ids = {TypeIndex(6), TypeIndex(7), TypeIndex(8)};
- StringListRecord Record{TypeRecordKind::StringList, Ids};
-} StringList;
-static struct {
- std::vector<TypeIndex> Ids = {TypeIndex(9), TypeIndex(10), TypeIndex(11)};
- BuildInfoRecord Record{Ids};
-} BuildInfo;
-static UdtSourceLineRecord UdtSourceLine(TypeIndex(12), TypeIndex(13), 0);
-static UdtModSourceLineRecord UdtModSourceLine(TypeIndex(14), TypeIndex(15), 0,
- 0);
-static ModifierRecord Modifier(TypeIndex(16), ModifierOptions::None);
-static ProcedureRecord Procedure(TypeIndex(17), CallingConvention::PpcCall,
- FunctionOptions::None, 0, TypeIndex(18));
-static MemberFunctionRecord MemberFunction(TypeIndex(19), TypeIndex(20),
- TypeIndex(21),
- CallingConvention::ThisCall,
- FunctionOptions::None, 2,
- TypeIndex(22), 0);
-static struct {
- std::vector<TypeIndex> Ids = {TypeIndex(23), TypeIndex(24), TypeIndex(25)};
- ArgListRecord Record{TypeRecordKind::ArgList, Ids};
-} ArgList;
-static ArrayRecord Array(TypeIndex(26), TypeIndex(27), 10, "MyArray");
-static ClassRecord Class(TypeRecordKind::Class, 3, ClassOptions::None,
- TypeIndex(28), TypeIndex(29), TypeIndex(30), 10,
- "MyClass", "MyClassUniqueName");
-static ClassRecord Struct(TypeRecordKind::Struct, 3, ClassOptions::None,
- TypeIndex(31), TypeIndex(32), TypeIndex(33), 10,
- "MyClass", "MyClassUniqueName");
-static UnionRecord Union(1, ClassOptions::None, TypeIndex(34), 10, "MyUnion",
- "MyUnionUniqueName");
-static EnumRecord Enum(1, ClassOptions::None, TypeIndex(35), "MyEnum",
- "EnumUniqueName", TypeIndex(36));
-static BitFieldRecord BitField(TypeIndex(37), 1, 0);
-static VFTableRecord VFTable(TypeIndex(38), TypeIndex(39), 1, "VFT", {});
-static VFTableShapeRecord VTableShape({});
-static struct {
- const TypeIndex T1{40};
- const TypeIndex T2{41};
- const TypeIndex T3{42};
- const TypeIndex T4{43};
-
- std::vector<OneMethodRecord> Methods{
- {T1, MemberAccess::Public, MethodKind::IntroducingVirtual,
- MethodOptions::None, 0, "Method1"},
- {T2, MemberAccess::Public, MethodKind::PureVirtual, MethodOptions::None,
- 0, "Method1"},
- {T3, MemberAccess::Public, MethodKind::PureIntroducingVirtual,
- MethodOptions::None, 0, "Method1"},
- {T4, MemberAccess::Public, MethodKind::Static, MethodOptions::None, 0,
- "Method1"}};
-
- MethodOverloadListRecord Record{Methods};
-} MethodOverloadList;
-static PointerRecord Pointer(TypeIndex(44), PointerKind::Near32,
- PointerMode::Pointer, PointerOptions::Const, 3);
-static PointerRecord MemberPointer(
- TypeIndex(45), PointerKind::Near32, PointerMode::PointerToDataMember,
- PointerOptions::Const, 3,
- MemberPointerInfo(TypeIndex(46),
- PointerToMemberRepresentation::GeneralData));
-}
-
-namespace members {
-static BaseClassRecord BaseClass(MemberAccess::Public, TypeIndex(47), 0);
-static EnumeratorRecord Enumerator(MemberAccess::Public,
- APSInt(APInt(8, 3, false)), "Test");
-DataMemberRecord DataMember(MemberAccess::Public, TypeIndex(48), 0, "Test");
-OverloadedMethodRecord OverloadedMethod(3, TypeIndex(49), "MethodList");
-static struct {
- const TypeIndex T1{50};
- const TypeIndex T2{51};
- const TypeIndex T3{52};
- const TypeIndex T4{53};
- OneMethodRecord R1{T1,
- MemberAccess::Public,
- MethodKind::IntroducingVirtual,
- MethodOptions::None,
- 0,
- "M1"};
- OneMethodRecord R2{T2,
- MemberAccess::Public,
- MethodKind::PureVirtual,
- MethodOptions::None,
- 0,
- "M2"};
- OneMethodRecord R3{T3,
- MemberAccess::Public,
- MethodKind::PureIntroducingVirtual,
- MethodOptions::None,
- 0,
- "M3"};
- OneMethodRecord R4{T4,
- MemberAccess::Protected,
- MethodKind::Vanilla,
- MethodOptions::CompilerGenerated,
- 0,
- "M4"};
-} OneMethod;
-static NestedTypeRecord NestedType(TypeIndex(54), "MyClass");
-static StaticDataMemberRecord StaticDataMember(MemberAccess::Public,
- TypeIndex(55), "Foo");
-static VirtualBaseClassRecord VirtualBaseClass(TypeRecordKind::VirtualBaseClass,
- MemberAccess::Public,
- TypeIndex(56), TypeIndex(57), 0,
- 0);
-static VFPtrRecord VFPtr(TypeIndex(58));
-static ListContinuationRecord Continuation(TypeIndex(59));
-}
-
-TEST_F(TypeIndexIteratorTest, FuncId) {
- using namespace leafs;
- writeTypeRecords(FuncId);
- checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);
-}
-
-TEST_F(TypeIndexIteratorTest, MemFuncId) {
- using namespace leafs;
- writeTypeRecords(MemFuncId);
- checkTypeReferences(0, MemFuncId.ClassType, MemFuncId.FunctionType);
-}
-
-TEST_F(TypeIndexIteratorTest, StringId) {
- using namespace leafs;
- writeTypeRecords(StringId);
- checkTypeReferences(0, StringId.Id);
-}
-
-TEST_F(TypeIndexIteratorTest, SubstrList) {
- using namespace leafs;
- writeTypeRecords(StringList.Record);
- checkTypeReferences(0, StringList.Ids[0], StringList.Ids[1],
- StringList.Ids[2]);
-}
-
-TEST_F(TypeIndexIteratorTest, BuildInfo) {
- using namespace leafs;
- writeTypeRecords(BuildInfo.Record);
- checkTypeReferences(0, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);
-}
-
-TEST_F(TypeIndexIteratorTest, UdtSrcLine) {
- using namespace leafs;
- writeTypeRecords(UdtSourceLine);
- checkTypeReferences(0, UdtSourceLine.UDT, UdtSourceLine.SourceFile);
-}
-
-TEST_F(TypeIndexIteratorTest, UdtModSrcLine) {
- using namespace leafs;
- writeTypeRecords(UdtModSourceLine);
- checkTypeReferences(0, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);
-}
-
-TEST_F(TypeIndexIteratorTest, Modifier) {
- using namespace leafs;
- writeTypeRecords(Modifier);
- checkTypeReferences(0, Modifier.ModifiedType);
-}
-
-TEST_F(TypeIndexIteratorTest, Procedure) {
- using namespace leafs;
- writeTypeRecords(Procedure);
- checkTypeReferences(0, Procedure.ReturnType, Procedure.ArgumentList);
-}
-
-TEST_F(TypeIndexIteratorTest, MemFunc) {
- using namespace leafs;
- writeTypeRecords(MemberFunction);
- checkTypeReferences(0, MemberFunction.ReturnType, MemberFunction.ClassType,
- MemberFunction.ThisType, MemberFunction.ArgumentList);
-}
-
-TEST_F(TypeIndexIteratorTest, ArgList) {
- using namespace leafs;
- writeTypeRecords(ArgList.Record);
- checkTypeReferences(0, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);
-}
-
-TEST_F(TypeIndexIteratorTest, Array) {
- using namespace leafs;
- writeTypeRecords(Array);
- checkTypeReferences(0, Array.ElementType, Array.IndexType);
-}
-
-TEST_F(TypeIndexIteratorTest, Class) {
- using namespace leafs;
- writeTypeRecords(Class);
- checkTypeReferences(0, Class.FieldList, Class.DerivationList,
- Class.VTableShape);
-}
-
-TEST_F(TypeIndexIteratorTest, Struct) {
- using namespace leafs;
- writeTypeRecords(Struct);
- checkTypeReferences(0, Struct.FieldList, Struct.DerivationList,
- Struct.VTableShape);
-}
-
-TEST_F(TypeIndexIteratorTest, Union) {
- using namespace leafs;
- writeTypeRecords(Union);
- checkTypeReferences(0, Union.FieldList);
-}
-
-TEST_F(TypeIndexIteratorTest, Enum) {
- using namespace leafs;
- writeTypeRecords(Enum);
- checkTypeReferences(0, Enum.FieldList, Enum.UnderlyingType);
-}
-
-TEST_F(TypeIndexIteratorTest, Bitfield) {
- using namespace leafs;
- writeTypeRecords(BitField);
- checkTypeReferences(0, BitField.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, VTable) {
- using namespace leafs;
- writeTypeRecords(VFTable);
- checkTypeReferences(0, VFTable.CompleteClass, VFTable.OverriddenVFTable);
-}
-
-TEST_F(TypeIndexIteratorTest, VTShape) {
- using namespace leafs;
- writeTypeRecords(VTableShape);
- checkTypeReferences(0);
-}
-
-TEST_F(TypeIndexIteratorTest, OverloadList) {
- using namespace leafs;
- writeTypeRecords(MethodOverloadList.Record);
- checkTypeReferences(0, MethodOverloadList.T1, MethodOverloadList.T2,
- MethodOverloadList.T3, MethodOverloadList.T4);
-}
-
-TEST_F(TypeIndexIteratorTest, Pointer) {
- using namespace leafs;
- writeTypeRecords(Pointer);
- checkTypeReferences(0, Pointer.ReferentType);
-}
-
-TEST_F(TypeIndexIteratorTest, MemberPointer) {
- using namespace leafs;
- writeTypeRecords(MemberPointer);
- checkTypeReferences(0, MemberPointer.ReferentType,
- MemberPointer.MemberInfo->ContainingType);
-}
-
-TEST_F(TypeIndexIteratorTest, ManyTypes) {
-
- using namespace leafs;
- writeTypeRecords(FuncId, MemFuncId, StringId, StringList.Record,
- BuildInfo.Record, UdtSourceLine, UdtModSourceLine, Modifier,
- Procedure, MemberFunction, ArgList.Record, Array, Class,
- Union, Enum, BitField, VFTable, VTableShape,
- MethodOverloadList.Record, Pointer, MemberPointer);
-
- checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);
- checkTypeReferences(1, MemFuncId.ClassType, MemFuncId.FunctionType);
- checkTypeReferences(2, StringId.Id);
- checkTypeReferences(3, StringList.Ids[0], StringList.Ids[1],
- StringList.Ids[2]);
- checkTypeReferences(4, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);
- checkTypeReferences(5, UdtSourceLine.UDT, UdtSourceLine.SourceFile);
- checkTypeReferences(6, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);
- checkTypeReferences(7, Modifier.ModifiedType);
- checkTypeReferences(8, Procedure.ReturnType, Procedure.ArgumentList);
- checkTypeReferences(9, MemberFunction.ReturnType, MemberFunction.ClassType,
- MemberFunction.ThisType, MemberFunction.ArgumentList);
- checkTypeReferences(10, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);
- checkTypeReferences(11, Array.ElementType, Array.IndexType);
- checkTypeReferences(12, Class.FieldList, Class.DerivationList,
- Class.VTableShape);
- checkTypeReferences(13, Union.FieldList);
- checkTypeReferences(14, Enum.FieldList, Enum.UnderlyingType);
- checkTypeReferences(15, BitField.Type);
- checkTypeReferences(16, VFTable.CompleteClass, VFTable.OverriddenVFTable);
- checkTypeReferences(17);
- checkTypeReferences(18, MethodOverloadList.T1, MethodOverloadList.T2,
- MethodOverloadList.T3, MethodOverloadList.T4);
- checkTypeReferences(19, Pointer.ReferentType);
- checkTypeReferences(20, MemberPointer.ReferentType,
- MemberPointer.MemberInfo->ContainingType);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListBaseClass) {
- using namespace members;
- writeFieldList(BaseClass);
- checkTypeReferences(0, BaseClass.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListEnumerator) {
- using namespace members;
- writeFieldList(Enumerator);
- checkTypeReferences(0);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListMember) {
- using namespace members;
- writeFieldList(DataMember);
- checkTypeReferences(0, DataMember.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListMethod) {
- using namespace members;
- writeFieldList(OverloadedMethod);
- checkTypeReferences(0, OverloadedMethod.MethodList);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListOneMethod) {
- using namespace members;
- writeFieldList(OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4);
- checkTypeReferences(0, OneMethod.T1, OneMethod.T2, OneMethod.T3,
- OneMethod.T4);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListNestedType) {
- using namespace members;
- writeFieldList(NestedType);
- checkTypeReferences(0, NestedType.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListStaticMember) {
- using namespace members;
- writeFieldList(StaticDataMember);
- checkTypeReferences(0, StaticDataMember.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListVirtualBase) {
- using namespace members;
- writeFieldList(VirtualBaseClass);
- checkTypeReferences(0, VirtualBaseClass.BaseType, VirtualBaseClass.VBPtrType);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListVFTable) {
- using namespace members;
- writeFieldList(VFPtr);
- checkTypeReferences(0, VFPtr.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, FieldListContinuation) {
- using namespace members;
- writeFieldList(Continuation);
- checkTypeReferences(0, Continuation.ContinuationIndex);
-}
-
-TEST_F(TypeIndexIteratorTest, ManyMembers) {
- using namespace members;
- writeFieldList(BaseClass, Enumerator, DataMember, OverloadedMethod,
- OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4,
- NestedType, StaticDataMember, VirtualBaseClass, VFPtr,
- Continuation);
-
- checkTypeReferences(
- 0, BaseClass.Type, DataMember.Type, OverloadedMethod.MethodList,
- OneMethod.T1, OneMethod.T2, OneMethod.T3, OneMethod.T4, NestedType.Type,
- StaticDataMember.Type, VirtualBaseClass.BaseType,
- VirtualBaseClass.VBPtrType, VFPtr.Type, Continuation.ContinuationIndex);
-}
-
-TEST_F(TypeIndexIteratorTest, ProcSym) {
- ProcSym GS(SymbolRecordKind::GlobalProcSym);
- GS.FunctionType = TypeIndex::Float32();
- ProcSym LS(SymbolRecordKind::ProcSym);
- LS.FunctionType = TypeIndex::Float64();
- writeSymbolRecords(GS, LS);
- checkTypeReferences(0, GS.FunctionType);
- checkTypeReferences(1, LS.FunctionType);
-}
-
-TEST_F(TypeIndexIteratorTest, DataSym) {
- DataSym DS(SymbolRecordKind::GlobalData);
- DS.Type = TypeIndex::Float32();
- writeSymbolRecords(DS);
- checkTypeReferences(0, DS.Type);
-}
-
-TEST_F(TypeIndexIteratorTest, RegisterSym) {
- RegisterSym Reg(SymbolRecordKind::RegisterSym);
- Reg.Index = TypeIndex::UInt32();
- Reg.Register = RegisterId::EAX;
- Reg.Name = "Target";
- writeSymbolRecords(Reg);
- checkTypeReferences(0, Reg.Index);
-}
-
-TEST_F(TypeIndexIteratorTest, CallerSym) {
- CallerSym Callees(SymbolRecordKind::CalleeSym);
- Callees.Indices.push_back(TypeIndex(1));
- Callees.Indices.push_back(TypeIndex(2));
- Callees.Indices.push_back(TypeIndex(3));
- CallerSym Callers(SymbolRecordKind::CallerSym);
- Callers.Indices.push_back(TypeIndex(4));
- Callers.Indices.push_back(TypeIndex(5));
- Callers.Indices.push_back(TypeIndex(6));
- CallerSym Inlinees(SymbolRecordKind::InlineesSym);
- Inlinees.Indices.push_back(TypeIndex(7));
- Inlinees.Indices.push_back(TypeIndex(8));
- Inlinees.Indices.push_back(TypeIndex(9));
- writeSymbolRecords(Callees, Callers, Inlinees);
- checkTypeReferences(0, TypeIndex(1), TypeIndex(2), TypeIndex(3));
- checkTypeReferences(1, TypeIndex(4), TypeIndex(5), TypeIndex(6));
- checkTypeReferences(2, TypeIndex(7), TypeIndex(8), TypeIndex(9));
-}
-
+//===- llvm/unittest/DebugInfo/CodeView/TypeIndexDiscoveryTest.cpp --------===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"\r
+\r
+#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"\r
+#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"\r
+#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"\r
+#include "llvm/Support/Allocator.h"\r
+\r
+#include "gmock/gmock.h"\r
+#include "gtest/gtest.h"\r
+\r
+using namespace llvm;\r
+using namespace llvm::codeview;\r
+\r
+class TypeIndexIteratorTest : public testing::Test {\r
+public:\r
+ TypeIndexIteratorTest() {}\r
+\r
+ void SetUp() override {\r
+ Refs.clear();\r
+ TTB = make_unique<AppendingTypeTableBuilder>(Storage);\r
+ CRB = make_unique<ContinuationRecordBuilder>();\r
+ Symbols.clear();\r
+ }\r
+\r
+ void TearDown() override {\r
+ CRB.reset();\r
+ TTB.reset();\r
+ }\r
+\r
+protected:\r
+ template <typename... Indices>\r
+ bool checkTypeReferences(uint32_t RecordIndex, Indices &&... TIs) const {\r
+ EXPECT_EQ(sizeof...(Indices), countRefs(RecordIndex));\r
+\r
+ // Choose between type or symbol records. The checking code doesn't care\r
+ // which we have.\r
+ std::vector<ArrayRef<uint8_t>> CVRecords;\r
+ if (Symbols.empty()) {\r
+ CVRecords = TTB->records();\r
+ } else {\r
+ for (const CVSymbol &S : Symbols)\r
+ CVRecords.push_back(S.data());\r
+ }\r
+\r
+ return checkTypeReferencesImpl(RecordIndex, CVRecords,\r
+ std::forward<Indices>(TIs)...);\r
+ }\r
+\r
+ template <typename... T> void writeFieldList(T &&... MemberRecords) {\r
+ CRB->begin(ContinuationRecordKind::FieldList);\r
+ writeFieldListImpl(std::forward<T>(MemberRecords)...);\r
+ auto Records = CRB->end(TTB->nextTypeIndex());\r
+ ASSERT_EQ(1u, Records.size());\r
+ TTB->insertRecordBytes(Records.front().RecordData);\r
+ discoverAllTypeIndices();\r
+ }\r
+\r
+ template <typename... T> void writeTypeRecords(T &&... Records) {\r
+ writeTypeRecordsImpl(std::forward<T>(Records)...);\r
+ ASSERT_EQ(sizeof...(T), TTB->records().size());\r
+ discoverAllTypeIndices();\r
+ }\r
+\r
+ template <typename... T> void writeSymbolRecords(T &&... Records) {\r
+ writeSymbolRecordsImpl(std::forward<T>(Records)...);\r
+ ASSERT_EQ(sizeof...(T), Symbols.size());\r
+ discoverTypeIndicesInSymbols();\r
+ }\r
+\r
+ std::unique_ptr<AppendingTypeTableBuilder> TTB;\r
+\r
+private:\r
+ uint32_t countRefs(uint32_t RecordIndex) const {\r
+ auto &R = Refs[RecordIndex];\r
+ uint32_t Count = 0;\r
+ for (auto &Ref : R) {\r
+ Count += Ref.Count;\r
+ }\r
+ return Count;\r
+ }\r
+\r
+ bool checkOneTypeReference(uint32_t RecordIndex, ArrayRef<uint8_t> RecordData,\r
+ TypeIndex TI) const {\r
+ RecordData = RecordData.drop_front(sizeof(RecordPrefix));\r
+ auto &RefList = Refs[RecordIndex];\r
+ for (auto &Ref : RefList) {\r
+ uint32_t Offset = Ref.Offset;\r
+ ArrayRef<uint8_t> Loc = RecordData.drop_front(Offset);\r
+ ArrayRef<TypeIndex> Indices(\r
+ reinterpret_cast<const TypeIndex *>(Loc.data()), Ref.Count);\r
+ if (llvm::any_of(Indices,\r
+ [TI](const TypeIndex &Other) { return Other == TI; }))\r
+ return true;\r
+ }\r
+ return false;\r
+ }\r
+\r
+ template <typename... Indices>\r
+ bool checkTypeReferencesImpl(uint32_t RecordIndex,\r
+ ArrayRef<ArrayRef<uint8_t>> CVRecords) const {\r
+ return true;\r
+ }\r
+\r
+ template <typename... Indices>\r
+ bool checkTypeReferencesImpl(uint32_t RecordIndex,\r
+ ArrayRef<ArrayRef<uint8_t>> CVRecords,\r
+ TypeIndex TI, Indices &&... Rest) const {\r
+ ArrayRef<uint8_t> Record = CVRecords[RecordIndex];\r
+ bool Success = checkOneTypeReference(RecordIndex, Record, TI);\r
+ EXPECT_TRUE(Success);\r
+ return Success & checkTypeReferencesImpl(RecordIndex, CVRecords,\r
+ std::forward<Indices>(Rest)...);\r
+ }\r
+\r
+ void discoverAllTypeIndices() {\r
+ Refs.resize(TTB->records().size());\r
+ for (uint32_t I = 0; I < TTB->records().size(); ++I) {\r
+ ArrayRef<uint8_t> Data = TTB->records()[I];\r
+ discoverTypeIndices(Data, Refs[I]);\r
+ }\r
+ }\r
+\r
+ void discoverTypeIndicesInSymbols() {\r
+ Refs.resize(Symbols.size());\r
+ for (uint32_t I = 0; I < Symbols.size(); ++I)\r
+ discoverTypeIndicesInSymbol(Symbols[I], Refs[I]);\r
+ }\r
+\r
+ // Helper function to write out a field list record with the given list\r
+ // of member records.\r
+ void writeFieldListImpl() {}\r
+\r
+ template <typename RecType, typename... Rest>\r
+ void writeFieldListImpl(RecType &&Record, Rest &&... Records) {\r
+ CRB->writeMemberType(Record);\r
+ writeFieldListImpl(std::forward<Rest>(Records)...);\r
+ }\r
+\r
+ // Helper function to write out a list of type records.\r
+ void writeTypeRecordsImpl() {}\r
+\r
+ template <typename RecType, typename... Rest>\r
+ void writeTypeRecordsImpl(RecType &&Record, Rest &&... Records) {\r
+ TTB->writeLeafType(Record);\r
+ writeTypeRecordsImpl(std::forward<Rest>(Records)...);\r
+ }\r
+\r
+ // Helper function to write out a list of symbol records.\r
+ void writeSymbolRecordsImpl() {}\r
+\r
+ template <typename RecType, typename... Rest>\r
+ void writeSymbolRecordsImpl(RecType &&Record, Rest &&... Records) {\r
+ Symbols.push_back(SymbolSerializer::writeOneSymbol(Record, Storage,\r
+ CodeViewContainer::Pdb));\r
+ writeSymbolRecordsImpl(std::forward<Rest>(Records)...);\r
+ }\r
+\r
+ std::vector<SmallVector<TiReference, 4>> Refs;\r
+ std::unique_ptr<ContinuationRecordBuilder> CRB;\r
+ std::vector<CVSymbol> Symbols;\r
+ BumpPtrAllocator Storage;\r
+};\r
+\r
+namespace leafs {\r
+static FuncIdRecord FuncId(TypeIndex(1), TypeIndex(2), "FuncId");\r
+static MemberFuncIdRecord MemFuncId(TypeIndex(3), TypeIndex(4), "FuncId");\r
+static StringIdRecord StringId(TypeIndex(5), "TheString");\r
+static struct {\r
+ std::vector<TypeIndex> Ids = {TypeIndex(6), TypeIndex(7), TypeIndex(8)};\r
+ StringListRecord Record{TypeRecordKind::StringList, Ids};\r
+} StringList;\r
+static struct {\r
+ std::vector<TypeIndex> Ids = {TypeIndex(9), TypeIndex(10), TypeIndex(11)};\r
+ BuildInfoRecord Record{Ids};\r
+} BuildInfo;\r
+static UdtSourceLineRecord UdtSourceLine(TypeIndex(12), TypeIndex(13), 0);\r
+static UdtModSourceLineRecord UdtModSourceLine(TypeIndex(14), TypeIndex(15), 0,\r
+ 0);\r
+static ModifierRecord Modifier(TypeIndex(16), ModifierOptions::None);\r
+static ProcedureRecord Procedure(TypeIndex(17), CallingConvention::PpcCall,\r
+ FunctionOptions::None, 0, TypeIndex(18));\r
+static MemberFunctionRecord MemberFunction(TypeIndex(19), TypeIndex(20),\r
+ TypeIndex(21),\r
+ CallingConvention::ThisCall,\r
+ FunctionOptions::None, 2,\r
+ TypeIndex(22), 0);\r
+static struct {\r
+ std::vector<TypeIndex> Ids = {TypeIndex(23), TypeIndex(24), TypeIndex(25)};\r
+ ArgListRecord Record{TypeRecordKind::ArgList, Ids};\r
+} ArgList;\r
+static ArrayRecord Array(TypeIndex(26), TypeIndex(27), 10, "MyArray");\r
+static ClassRecord Class(TypeRecordKind::Class, 3, ClassOptions::None,\r
+ TypeIndex(28), TypeIndex(29), TypeIndex(30), 10,\r
+ "MyClass", "MyClassUniqueName");\r
+static ClassRecord Struct(TypeRecordKind::Struct, 3, ClassOptions::None,\r
+ TypeIndex(31), TypeIndex(32), TypeIndex(33), 10,\r
+ "MyClass", "MyClassUniqueName");\r
+static UnionRecord Union(1, ClassOptions::None, TypeIndex(34), 10, "MyUnion",\r
+ "MyUnionUniqueName");\r
+static EnumRecord Enum(1, ClassOptions::None, TypeIndex(35), "MyEnum",\r
+ "EnumUniqueName", TypeIndex(36));\r
+static BitFieldRecord BitField(TypeIndex(37), 1, 0);\r
+static VFTableRecord VFTable(TypeIndex(38), TypeIndex(39), 1, "VFT", {});\r
+static VFTableShapeRecord VTableShape({});\r
+static struct {\r
+ const TypeIndex T1{40};\r
+ const TypeIndex T2{41};\r
+ const TypeIndex T3{42};\r
+ const TypeIndex T4{43};\r
+\r
+ std::vector<OneMethodRecord> Methods{\r
+ {T1, MemberAccess::Public, MethodKind::IntroducingVirtual,\r
+ MethodOptions::None, 0, "Method1"},\r
+ {T2, MemberAccess::Public, MethodKind::PureVirtual, MethodOptions::None,\r
+ 0, "Method1"},\r
+ {T3, MemberAccess::Public, MethodKind::PureIntroducingVirtual,\r
+ MethodOptions::None, 0, "Method1"},\r
+ {T4, MemberAccess::Public, MethodKind::Static, MethodOptions::None, 0,\r
+ "Method1"}};\r
+\r
+ MethodOverloadListRecord Record{Methods};\r
+} MethodOverloadList;\r
+static PointerRecord Pointer(TypeIndex(44), PointerKind::Near32,\r
+ PointerMode::Pointer, PointerOptions::Const, 3);\r
+static PointerRecord MemberPointer(\r
+ TypeIndex(45), PointerKind::Near32, PointerMode::PointerToDataMember,\r
+ PointerOptions::Const, 3,\r
+ MemberPointerInfo(TypeIndex(46),\r
+ PointerToMemberRepresentation::GeneralData));\r
+}\r
+\r
+namespace members {\r
+static BaseClassRecord BaseClass(MemberAccess::Public, TypeIndex(47), 0);\r
+static EnumeratorRecord Enumerator(MemberAccess::Public,\r
+ APSInt(APInt(8, 3, false)), "Test");\r
+DataMemberRecord DataMember(MemberAccess::Public, TypeIndex(48), 0, "Test");\r
+OverloadedMethodRecord OverloadedMethod(3, TypeIndex(49), "MethodList");\r
+static struct {\r
+ const TypeIndex T1{50};\r
+ const TypeIndex T2{51};\r
+ const TypeIndex T3{52};\r
+ const TypeIndex T4{53};\r
+ OneMethodRecord R1{T1,\r
+ MemberAccess::Public,\r
+ MethodKind::IntroducingVirtual,\r
+ MethodOptions::None,\r
+ 0,\r
+ "M1"};\r
+ OneMethodRecord R2{T2,\r
+ MemberAccess::Public,\r
+ MethodKind::PureVirtual,\r
+ MethodOptions::None,\r
+ 0,\r
+ "M2"};\r
+ OneMethodRecord R3{T3,\r
+ MemberAccess::Public,\r
+ MethodKind::PureIntroducingVirtual,\r
+ MethodOptions::None,\r
+ 0,\r
+ "M3"};\r
+ OneMethodRecord R4{T4,\r
+ MemberAccess::Protected,\r
+ MethodKind::Vanilla,\r
+ MethodOptions::CompilerGenerated,\r
+ 0,\r
+ "M4"};\r
+} OneMethod;\r
+static NestedTypeRecord NestedType(TypeIndex(54), "MyClass");\r
+static StaticDataMemberRecord StaticDataMember(MemberAccess::Public,\r
+ TypeIndex(55), "Foo");\r
+static VirtualBaseClassRecord VirtualBaseClass(TypeRecordKind::VirtualBaseClass,\r
+ MemberAccess::Public,\r
+ TypeIndex(56), TypeIndex(57), 0,\r
+ 0);\r
+static VFPtrRecord VFPtr(TypeIndex(58));\r
+static ListContinuationRecord Continuation(TypeIndex(59));\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FuncId) {\r
+ using namespace leafs;\r
+ writeTypeRecords(FuncId);\r
+ checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, MemFuncId) {\r
+ using namespace leafs;\r
+ writeTypeRecords(MemFuncId);\r
+ checkTypeReferences(0, MemFuncId.ClassType, MemFuncId.FunctionType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, StringId) {\r
+ using namespace leafs;\r
+ writeTypeRecords(StringId);\r
+ checkTypeReferences(0, StringId.Id);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, SubstrList) {\r
+ using namespace leafs;\r
+ writeTypeRecords(StringList.Record);\r
+ checkTypeReferences(0, StringList.Ids[0], StringList.Ids[1],\r
+ StringList.Ids[2]);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, BuildInfo) {\r
+ using namespace leafs;\r
+ writeTypeRecords(BuildInfo.Record);\r
+ checkTypeReferences(0, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, UdtSrcLine) {\r
+ using namespace leafs;\r
+ writeTypeRecords(UdtSourceLine);\r
+ checkTypeReferences(0, UdtSourceLine.UDT, UdtSourceLine.SourceFile);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, UdtModSrcLine) {\r
+ using namespace leafs;\r
+ writeTypeRecords(UdtModSourceLine);\r
+ checkTypeReferences(0, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Modifier) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Modifier);\r
+ checkTypeReferences(0, Modifier.ModifiedType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Procedure) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Procedure);\r
+ checkTypeReferences(0, Procedure.ReturnType, Procedure.ArgumentList);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, MemFunc) {\r
+ using namespace leafs;\r
+ writeTypeRecords(MemberFunction);\r
+ checkTypeReferences(0, MemberFunction.ReturnType, MemberFunction.ClassType,\r
+ MemberFunction.ThisType, MemberFunction.ArgumentList);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, ArgList) {\r
+ using namespace leafs;\r
+ writeTypeRecords(ArgList.Record);\r
+ checkTypeReferences(0, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Array) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Array);\r
+ checkTypeReferences(0, Array.ElementType, Array.IndexType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Class) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Class);\r
+ checkTypeReferences(0, Class.FieldList, Class.DerivationList,\r
+ Class.VTableShape);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Struct) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Struct);\r
+ checkTypeReferences(0, Struct.FieldList, Struct.DerivationList,\r
+ Struct.VTableShape);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Union) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Union);\r
+ checkTypeReferences(0, Union.FieldList);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Enum) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Enum);\r
+ checkTypeReferences(0, Enum.FieldList, Enum.UnderlyingType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Bitfield) {\r
+ using namespace leafs;\r
+ writeTypeRecords(BitField);\r
+ checkTypeReferences(0, BitField.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, VTable) {\r
+ using namespace leafs;\r
+ writeTypeRecords(VFTable);\r
+ checkTypeReferences(0, VFTable.CompleteClass, VFTable.OverriddenVFTable);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, VTShape) {\r
+ using namespace leafs;\r
+ writeTypeRecords(VTableShape);\r
+ checkTypeReferences(0);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, OverloadList) {\r
+ using namespace leafs;\r
+ writeTypeRecords(MethodOverloadList.Record);\r
+ checkTypeReferences(0, MethodOverloadList.T1, MethodOverloadList.T2,\r
+ MethodOverloadList.T3, MethodOverloadList.T4);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Pointer) {\r
+ using namespace leafs;\r
+ writeTypeRecords(Pointer);\r
+ checkTypeReferences(0, Pointer.ReferentType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, MemberPointer) {\r
+ using namespace leafs;\r
+ writeTypeRecords(MemberPointer);\r
+ checkTypeReferences(0, MemberPointer.ReferentType,\r
+ MemberPointer.MemberInfo->ContainingType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, ManyTypes) {\r
+\r
+ using namespace leafs;\r
+ writeTypeRecords(FuncId, MemFuncId, StringId, StringList.Record,\r
+ BuildInfo.Record, UdtSourceLine, UdtModSourceLine, Modifier,\r
+ Procedure, MemberFunction, ArgList.Record, Array, Class,\r
+ Union, Enum, BitField, VFTable, VTableShape,\r
+ MethodOverloadList.Record, Pointer, MemberPointer);\r
+\r
+ checkTypeReferences(0, FuncId.FunctionType, FuncId.ParentScope);\r
+ checkTypeReferences(1, MemFuncId.ClassType, MemFuncId.FunctionType);\r
+ checkTypeReferences(2, StringId.Id);\r
+ checkTypeReferences(3, StringList.Ids[0], StringList.Ids[1],\r
+ StringList.Ids[2]);\r
+ checkTypeReferences(4, BuildInfo.Ids[0], BuildInfo.Ids[1], BuildInfo.Ids[2]);\r
+ checkTypeReferences(5, UdtSourceLine.UDT, UdtSourceLine.SourceFile);\r
+ checkTypeReferences(6, UdtModSourceLine.UDT, UdtModSourceLine.SourceFile);\r
+ checkTypeReferences(7, Modifier.ModifiedType);\r
+ checkTypeReferences(8, Procedure.ReturnType, Procedure.ArgumentList);\r
+ checkTypeReferences(9, MemberFunction.ReturnType, MemberFunction.ClassType,\r
+ MemberFunction.ThisType, MemberFunction.ArgumentList);\r
+ checkTypeReferences(10, ArgList.Ids[0], ArgList.Ids[1], ArgList.Ids[2]);\r
+ checkTypeReferences(11, Array.ElementType, Array.IndexType);\r
+ checkTypeReferences(12, Class.FieldList, Class.DerivationList,\r
+ Class.VTableShape);\r
+ checkTypeReferences(13, Union.FieldList);\r
+ checkTypeReferences(14, Enum.FieldList, Enum.UnderlyingType);\r
+ checkTypeReferences(15, BitField.Type);\r
+ checkTypeReferences(16, VFTable.CompleteClass, VFTable.OverriddenVFTable);\r
+ checkTypeReferences(17);\r
+ checkTypeReferences(18, MethodOverloadList.T1, MethodOverloadList.T2,\r
+ MethodOverloadList.T3, MethodOverloadList.T4);\r
+ checkTypeReferences(19, Pointer.ReferentType);\r
+ checkTypeReferences(20, MemberPointer.ReferentType,\r
+ MemberPointer.MemberInfo->ContainingType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListBaseClass) {\r
+ using namespace members;\r
+ writeFieldList(BaseClass);\r
+ checkTypeReferences(0, BaseClass.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListEnumerator) {\r
+ using namespace members;\r
+ writeFieldList(Enumerator);\r
+ checkTypeReferences(0);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListMember) {\r
+ using namespace members;\r
+ writeFieldList(DataMember);\r
+ checkTypeReferences(0, DataMember.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListMethod) {\r
+ using namespace members;\r
+ writeFieldList(OverloadedMethod);\r
+ checkTypeReferences(0, OverloadedMethod.MethodList);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListOneMethod) {\r
+ using namespace members;\r
+ writeFieldList(OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4);\r
+ checkTypeReferences(0, OneMethod.T1, OneMethod.T2, OneMethod.T3,\r
+ OneMethod.T4);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListNestedType) {\r
+ using namespace members;\r
+ writeFieldList(NestedType);\r
+ checkTypeReferences(0, NestedType.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListStaticMember) {\r
+ using namespace members;\r
+ writeFieldList(StaticDataMember);\r
+ checkTypeReferences(0, StaticDataMember.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListVirtualBase) {\r
+ using namespace members;\r
+ writeFieldList(VirtualBaseClass);\r
+ checkTypeReferences(0, VirtualBaseClass.BaseType, VirtualBaseClass.VBPtrType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListVFTable) {\r
+ using namespace members;\r
+ writeFieldList(VFPtr);\r
+ checkTypeReferences(0, VFPtr.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, FieldListContinuation) {\r
+ using namespace members;\r
+ writeFieldList(Continuation);\r
+ checkTypeReferences(0, Continuation.ContinuationIndex);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, ManyMembers) {\r
+ using namespace members;\r
+ writeFieldList(BaseClass, Enumerator, DataMember, OverloadedMethod,\r
+ OneMethod.R1, OneMethod.R2, OneMethod.R3, OneMethod.R4,\r
+ NestedType, StaticDataMember, VirtualBaseClass, VFPtr,\r
+ Continuation);\r
+\r
+ checkTypeReferences(\r
+ 0, BaseClass.Type, DataMember.Type, OverloadedMethod.MethodList,\r
+ OneMethod.T1, OneMethod.T2, OneMethod.T3, OneMethod.T4, NestedType.Type,\r
+ StaticDataMember.Type, VirtualBaseClass.BaseType,\r
+ VirtualBaseClass.VBPtrType, VFPtr.Type, Continuation.ContinuationIndex);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, ProcSym) {\r
+ ProcSym GS(SymbolRecordKind::GlobalProcSym);\r
+ GS.FunctionType = TypeIndex::Float32();\r
+ ProcSym LS(SymbolRecordKind::ProcSym);\r
+ LS.FunctionType = TypeIndex::Float64();\r
+ writeSymbolRecords(GS, LS);\r
+ checkTypeReferences(0, GS.FunctionType);\r
+ checkTypeReferences(1, LS.FunctionType);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, DataSym) {\r
+ DataSym DS(SymbolRecordKind::GlobalData);\r
+ DS.Type = TypeIndex::Float32();\r
+ writeSymbolRecords(DS);\r
+ checkTypeReferences(0, DS.Type);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, RegisterSym) {\r
+ RegisterSym Reg(SymbolRecordKind::RegisterSym);\r
+ Reg.Index = TypeIndex::UInt32();\r
+ Reg.Register = RegisterId::EAX;\r
+ Reg.Name = "Target";\r
+ writeSymbolRecords(Reg);\r
+ checkTypeReferences(0, Reg.Index);\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, CallerSym) {\r
+ CallerSym Callees(SymbolRecordKind::CalleeSym);\r
+ Callees.Indices.push_back(TypeIndex(1));\r
+ Callees.Indices.push_back(TypeIndex(2));\r
+ Callees.Indices.push_back(TypeIndex(3));\r
+ CallerSym Callers(SymbolRecordKind::CallerSym);\r
+ Callers.Indices.push_back(TypeIndex(4));\r
+ Callers.Indices.push_back(TypeIndex(5));\r
+ Callers.Indices.push_back(TypeIndex(6));\r
+ CallerSym Inlinees(SymbolRecordKind::InlineesSym);\r
+ Inlinees.Indices.push_back(TypeIndex(7));\r
+ Inlinees.Indices.push_back(TypeIndex(8));\r
+ Inlinees.Indices.push_back(TypeIndex(9));\r
+ writeSymbolRecords(Callees, Callers, Inlinees);\r
+ checkTypeReferences(0, TypeIndex(1), TypeIndex(2), TypeIndex(3));\r
+ checkTypeReferences(1, TypeIndex(4), TypeIndex(5), TypeIndex(6));\r
+ checkTypeReferences(2, TypeIndex(7), TypeIndex(8), TypeIndex(9));\r
+}\r
+\r
+TEST_F(TypeIndexIteratorTest, Precomp) {\r
+ PrecompRecord P(TypeRecordKind::Precomp);\r
+ P.StartTypeIndex = TypeIndex::FirstNonSimpleIndex;\r
+ P.TypesCount = 100;\r
+ P.Signature = 0x12345678;\r
+ P.PrecompFilePath = "C:/precomp.obj";\r
+\r
+ EndPrecompRecord EP(TypeRecordKind::EndPrecomp);\r
+ EP.Signature = P.Signature;\r
+\r
+ writeTypeRecords(P, EP);\r
+ checkTypeReferences(0);\r
+}\r
projects / platform / upstream / llvm.git / commitdiff