| //===- DIARawSymbol.cpp - DIA implementation of IPDBRawSymbol ---*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h" | |
| #include "llvm/ADT/ArrayRef.h" | |
| #include "llvm/ADT/STLExtras.h" | |
| #include "llvm/DebugInfo/CodeView/Formatters.h" | |
| #include "llvm/DebugInfo/PDB/DIA/DIAEnumLineNumbers.h" | |
| #include "llvm/DebugInfo/PDB/DIA/DIAEnumSymbols.h" | |
| #include "llvm/DebugInfo/PDB/DIA/DIALineNumber.h" | |
| #include "llvm/DebugInfo/PDB/DIA/DIASession.h" | |
| #include "llvm/DebugInfo/PDB/DIA/DIAUtils.h" | |
| #include "llvm/DebugInfo/PDB/PDBExtras.h" | |
| #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h" | |
| #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h" | |
| #include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h" | |
| #include "llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h" | |
| #include "llvm/Support/ConvertUTF.h" | |
| #include "llvm/Support/raw_ostream.h" | |
| using namespace llvm; | |
| using namespace llvm::pdb; | |
| namespace { | |
| Variant VariantFromVARIANT(const VARIANT &V) { | |
| Variant Result; | |
| switch (V.vt) { | |
| case VT_I1: | |
| Result.Value.Int8 = V.cVal; | |
| Result.Type = PDB_VariantType::Int8; | |
| break; | |
| case VT_I2: | |
| Result.Value.Int16 = V.iVal; | |
| Result.Type = PDB_VariantType::Int16; | |
| break; | |
| case VT_I4: | |
| Result.Value.Int32 = V.intVal; | |
| Result.Type = PDB_VariantType::Int32; | |
| break; | |
| case VT_I8: | |
| Result.Value.Int64 = V.llVal; | |
| Result.Type = PDB_VariantType::Int64; | |
| break; | |
| case VT_UI1: | |
| Result.Value.UInt8 = V.bVal; | |
| Result.Type = PDB_VariantType::UInt8; | |
| break; | |
| case VT_UI2: | |
| Result.Value.UInt16 = V.uiVal; | |
| Result.Type = PDB_VariantType::UInt16; | |
| break; | |
| case VT_UI4: | |
| Result.Value.UInt32 = V.uintVal; | |
| Result.Type = PDB_VariantType::UInt32; | |
| break; | |
| case VT_UI8: | |
| Result.Value.UInt64 = V.ullVal; | |
| Result.Type = PDB_VariantType::UInt64; | |
| break; | |
| case VT_BOOL: | |
| Result.Value.Bool = (V.boolVal == VARIANT_TRUE) ? true : false; | |
| Result.Type = PDB_VariantType::Bool; | |
| break; | |
| case VT_R4: | |
| Result.Value.Single = V.fltVal; | |
| Result.Type = PDB_VariantType::Single; | |
| break; | |
| case VT_R8: | |
| Result.Value.Double = V.dblVal; | |
| Result.Type = PDB_VariantType::Double; | |
| break; | |
| case VT_BSTR: { | |
| const char *SrcBytes = reinterpret_cast<const char *>(V.bstrVal); | |
| llvm::ArrayRef<char> SrcByteArray(SrcBytes, SysStringByteLen(V.bstrVal)); | |
| std::string Result8; | |
| if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8)) | |
| Result.Value.String = nullptr; | |
| Result.Value.String = new char[Result8.length() + 1]; | |
| ::strcpy(Result.Value.String, Result8.c_str()); | |
| Result.Type = PDB_VariantType::String; | |
| break; | |
| } | |
| default: | |
| Result.Type = PDB_VariantType::Unknown; | |
| break; | |
| } | |
| return Result; | |
| } | |
| template <typename ArgType> | |
| ArgType PrivateGetDIAValue(IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) { | |
| ArgType Value; | |
| if (S_OK == (Symbol->*Method)(&Value)) | |
| return static_cast<ArgType>(Value); | |
| return ArgType(); | |
| } | |
| template <typename ArgType, typename RetType> | |
| RetType PrivateGetDIAValue(IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) { | |
| ArgType Value; | |
| if (S_OK == (Symbol->*Method)(&Value)) | |
| return static_cast<RetType>(Value); | |
| return RetType(); | |
| } | |
| std::string | |
| PrivateGetDIAValue(IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) { | |
| return invokeBstrMethod(*Symbol, Method); | |
| } | |
| codeview::GUID | |
| PrivateGetDIAValue(IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(GUID *)) { | |
| GUID Result; | |
| if (S_OK != (Symbol->*Method)(&Result)) | |
| return codeview::GUID(); | |
| static_assert(sizeof(codeview::GUID) == sizeof(GUID), | |
| "GUID is the wrong size!"); | |
| codeview::GUID IdResult; | |
| ::memcpy(&IdResult, &Result, sizeof(GUID)); | |
| return IdResult; | |
| } | |
| template <typename PrintType, typename ArgType> | |
| void DumpDIAValueAs(llvm::raw_ostream &OS, int Indent, StringRef Name, | |
| IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) { | |
| ArgType Value; | |
| if (S_OK == (Symbol->*Method)(&Value)) | |
| dumpSymbolField(OS, Name, static_cast<PrintType>(Value), Indent); | |
| } | |
| void DumpDIAIdValue(llvm::raw_ostream &OS, int Indent, StringRef Name, | |
| IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(DWORD *), | |
| const IPDBSession &Session, PdbSymbolIdField FieldId, | |
| PdbSymbolIdField ShowFlags, PdbSymbolIdField RecurseFlags) { | |
| DWORD Value; | |
| if (S_OK == (Symbol->*Method)(&Value)) | |
| dumpSymbolIdField(OS, Name, Value, Indent, Session, FieldId, ShowFlags, | |
| RecurseFlags); | |
| } | |
| template <typename ArgType> | |
| void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name, | |
| IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) { | |
| ArgType Value; | |
| if (S_OK == (Symbol->*Method)(&Value)) | |
| dumpSymbolField(OS, Name, Value, Indent); | |
| } | |
| void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name, | |
| IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) { | |
| BSTR Value = nullptr; | |
| if (S_OK != (Symbol->*Method)(&Value)) | |
| return; | |
| const char *Bytes = reinterpret_cast<const char *>(Value); | |
| ArrayRef<char> ByteArray(Bytes, ::SysStringByteLen(Value)); | |
| std::string Result; | |
| if (llvm::convertUTF16ToUTF8String(ByteArray, Result)) | |
| dumpSymbolField(OS, Name, Result, Indent); | |
| ::SysFreeString(Value); | |
| } | |
| void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name, | |
| IDiaSymbol *Symbol, | |
| HRESULT (__stdcall IDiaSymbol::*Method)(VARIANT *)) { | |
| VARIANT Value; | |
| Value.vt = VT_EMPTY; | |
| if (S_OK != (Symbol->*Method)(&Value)) | |
| return; | |
| Variant V = VariantFromVARIANT(Value); | |
| dumpSymbolField(OS, Name, V, Indent); | |
| } | |
| } // namespace | |
| namespace llvm { | |
| llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const GUID &G) { | |
| StringRef GuidBytes(reinterpret_cast<const char *>(&G), sizeof(G)); | |
| codeview::detail::GuidAdapter A(GuidBytes); | |
| A.format(OS, ""); | |
| return OS; | |
| } | |
| } // namespace llvm | |
| DIARawSymbol::DIARawSymbol(const DIASession &PDBSession, | |
| CComPtr<IDiaSymbol> DiaSymbol) | |
| : Session(PDBSession), Symbol(DiaSymbol) {} | |
| #define RAW_ID_METHOD_DUMP(Stream, Method, Session, FieldId, ShowFlags, \ | |
| RecurseFlags) \ | |
| DumpDIAIdValue(Stream, Indent, StringRef{#Method}, Symbol, \ | |
| &IDiaSymbol::get_##Method, Session, FieldId, ShowFlags, \ | |
| RecurseFlags); | |
| #define RAW_METHOD_DUMP(Stream, Method) \ | |
| DumpDIAValue(Stream, Indent, StringRef{#Method}, Symbol, \ | |
| &IDiaSymbol::get_##Method); | |
| #define RAW_METHOD_DUMP_AS(Stream, Method, Type) \ | |
| DumpDIAValueAs<Type>(Stream, Indent, StringRef{#Method}, Symbol, \ | |
| &IDiaSymbol::get_##Method); | |
| void DIARawSymbol::dump(raw_ostream &OS, int Indent, | |
| PdbSymbolIdField ShowIdFields, | |
| PdbSymbolIdField RecurseIdFields) const { | |
| RAW_ID_METHOD_DUMP(OS, symIndexId, Session, PdbSymbolIdField::SymIndexId, | |
| ShowIdFields, RecurseIdFields); | |
| RAW_METHOD_DUMP_AS(OS, symTag, PDB_SymType); | |
| RAW_METHOD_DUMP(OS, access); | |
| RAW_METHOD_DUMP(OS, addressOffset); | |
| RAW_METHOD_DUMP(OS, addressSection); | |
| RAW_METHOD_DUMP(OS, age); | |
| RAW_METHOD_DUMP(OS, arrayIndexTypeId); | |
| RAW_METHOD_DUMP(OS, backEndMajor); | |
| RAW_METHOD_DUMP(OS, backEndMinor); | |
| RAW_METHOD_DUMP(OS, backEndBuild); | |
| RAW_METHOD_DUMP(OS, backEndQFE); | |
| RAW_METHOD_DUMP(OS, baseDataOffset); | |
| RAW_METHOD_DUMP(OS, baseDataSlot); | |
| RAW_METHOD_DUMP(OS, baseSymbolId); | |
| RAW_METHOD_DUMP_AS(OS, baseType, PDB_BuiltinType); | |
| RAW_METHOD_DUMP(OS, bitPosition); | |
| RAW_METHOD_DUMP_AS(OS, callingConvention, PDB_CallingConv); | |
| RAW_ID_METHOD_DUMP(OS, classParentId, Session, PdbSymbolIdField::ClassParent, | |
| ShowIdFields, RecurseIdFields); | |
| RAW_METHOD_DUMP(OS, compilerName); | |
| RAW_METHOD_DUMP(OS, count); | |
| RAW_METHOD_DUMP(OS, countLiveRanges); | |
| RAW_METHOD_DUMP(OS, frontEndMajor); | |
| RAW_METHOD_DUMP(OS, frontEndMinor); | |
| RAW_METHOD_DUMP(OS, frontEndBuild); | |
| RAW_METHOD_DUMP(OS, frontEndQFE); | |
| RAW_ID_METHOD_DUMP(OS, lexicalParentId, Session, | |
| PdbSymbolIdField::LexicalParent, ShowIdFields, | |
| RecurseIdFields); | |
| RAW_METHOD_DUMP(OS, libraryName); | |
| RAW_METHOD_DUMP(OS, liveRangeStartAddressOffset); | |
| RAW_METHOD_DUMP(OS, liveRangeStartAddressSection); | |
| RAW_METHOD_DUMP(OS, liveRangeStartRelativeVirtualAddress); | |
| RAW_METHOD_DUMP(OS, localBasePointerRegisterId); | |
| RAW_METHOD_DUMP(OS, lowerBoundId); | |
| RAW_METHOD_DUMP(OS, memorySpaceKind); | |
| RAW_METHOD_DUMP(OS, name); | |
| RAW_METHOD_DUMP(OS, numberOfAcceleratorPointerTags); | |
| RAW_METHOD_DUMP(OS, numberOfColumns); | |
| RAW_METHOD_DUMP(OS, numberOfModifiers); | |
| RAW_METHOD_DUMP(OS, numberOfRegisterIndices); | |
| RAW_METHOD_DUMP(OS, numberOfRows); | |
| RAW_METHOD_DUMP(OS, objectFileName); | |
| RAW_METHOD_DUMP(OS, oemId); | |
| RAW_METHOD_DUMP(OS, oemSymbolId); | |
| RAW_METHOD_DUMP(OS, offsetInUdt); | |
| RAW_METHOD_DUMP(OS, platform); | |
| RAW_METHOD_DUMP(OS, rank); | |
| RAW_METHOD_DUMP(OS, registerId); | |
| RAW_METHOD_DUMP(OS, registerType); | |
| RAW_METHOD_DUMP(OS, relativeVirtualAddress); | |
| RAW_METHOD_DUMP(OS, samplerSlot); | |
| RAW_METHOD_DUMP(OS, signature); | |
| RAW_METHOD_DUMP(OS, sizeInUdt); | |
| RAW_METHOD_DUMP(OS, slot); | |
| RAW_METHOD_DUMP(OS, sourceFileName); | |
| RAW_METHOD_DUMP(OS, stride); | |
| RAW_METHOD_DUMP(OS, subTypeId); | |
| RAW_METHOD_DUMP(OS, symbolsFileName); | |
| RAW_METHOD_DUMP(OS, targetOffset); | |
| RAW_METHOD_DUMP(OS, targetRelativeVirtualAddress); | |
| RAW_METHOD_DUMP(OS, targetVirtualAddress); | |
| RAW_METHOD_DUMP(OS, targetSection); | |
| RAW_METHOD_DUMP(OS, textureSlot); | |
| RAW_METHOD_DUMP(OS, timeStamp); | |
| RAW_METHOD_DUMP(OS, token); | |
| RAW_ID_METHOD_DUMP(OS, typeId, Session, PdbSymbolIdField::Type, ShowIdFields, | |
| RecurseIdFields); | |
| RAW_METHOD_DUMP(OS, uavSlot); | |
| RAW_METHOD_DUMP(OS, undecoratedName); | |
| RAW_ID_METHOD_DUMP(OS, unmodifiedTypeId, Session, | |
| PdbSymbolIdField::UnmodifiedType, ShowIdFields, | |
| RecurseIdFields); | |
| RAW_METHOD_DUMP(OS, upperBoundId); | |
| RAW_METHOD_DUMP(OS, virtualBaseDispIndex); | |
| RAW_METHOD_DUMP(OS, virtualBaseOffset); | |
| RAW_METHOD_DUMP(OS, virtualTableShapeId); | |
| RAW_METHOD_DUMP_AS(OS, dataKind, PDB_DataKind); | |
| RAW_METHOD_DUMP(OS, guid); | |
| RAW_METHOD_DUMP(OS, offset); | |
| RAW_METHOD_DUMP(OS, thisAdjust); | |
| RAW_METHOD_DUMP(OS, virtualBasePointerOffset); | |
| RAW_METHOD_DUMP_AS(OS, locationType, PDB_LocType); | |
| RAW_METHOD_DUMP(OS, machineType); | |
| RAW_METHOD_DUMP(OS, thunkOrdinal); | |
| RAW_METHOD_DUMP(OS, length); | |
| RAW_METHOD_DUMP(OS, liveRangeLength); | |
| RAW_METHOD_DUMP(OS, virtualAddress); | |
| RAW_METHOD_DUMP_AS(OS, udtKind, PDB_UdtType); | |
| RAW_METHOD_DUMP(OS, constructor); | |
| RAW_METHOD_DUMP(OS, customCallingConvention); | |
| RAW_METHOD_DUMP(OS, farReturn); | |
| RAW_METHOD_DUMP(OS, code); | |
| RAW_METHOD_DUMP(OS, compilerGenerated); | |
| RAW_METHOD_DUMP(OS, constType); | |
| RAW_METHOD_DUMP(OS, editAndContinueEnabled); | |
| RAW_METHOD_DUMP(OS, function); | |
| RAW_METHOD_DUMP(OS, stride); | |
| RAW_METHOD_DUMP(OS, noStackOrdering); | |
| RAW_METHOD_DUMP(OS, hasAlloca); | |
| RAW_METHOD_DUMP(OS, hasAssignmentOperator); | |
| RAW_METHOD_DUMP(OS, isCTypes); | |
| RAW_METHOD_DUMP(OS, hasCastOperator); | |
| RAW_METHOD_DUMP(OS, hasDebugInfo); | |
| RAW_METHOD_DUMP(OS, hasEH); | |
| RAW_METHOD_DUMP(OS, hasEHa); | |
| RAW_METHOD_DUMP(OS, hasInlAsm); | |
| RAW_METHOD_DUMP(OS, framePointerPresent); | |
| RAW_METHOD_DUMP(OS, inlSpec); | |
| RAW_METHOD_DUMP(OS, interruptReturn); | |
| RAW_METHOD_DUMP(OS, hasLongJump); | |
| RAW_METHOD_DUMP(OS, hasManagedCode); | |
| RAW_METHOD_DUMP(OS, hasNestedTypes); | |
| RAW_METHOD_DUMP(OS, noInline); | |
| RAW_METHOD_DUMP(OS, noReturn); | |
| RAW_METHOD_DUMP(OS, optimizedCodeDebugInfo); | |
| RAW_METHOD_DUMP(OS, overloadedOperator); | |
| RAW_METHOD_DUMP(OS, hasSEH); | |
| RAW_METHOD_DUMP(OS, hasSecurityChecks); | |
| RAW_METHOD_DUMP(OS, hasSetJump); | |
| RAW_METHOD_DUMP(OS, strictGSCheck); | |
| RAW_METHOD_DUMP(OS, isAcceleratorGroupSharedLocal); | |
| RAW_METHOD_DUMP(OS, isAcceleratorPointerTagLiveRange); | |
| RAW_METHOD_DUMP(OS, isAcceleratorStubFunction); | |
| RAW_METHOD_DUMP(OS, isAggregated); | |
| RAW_METHOD_DUMP(OS, intro); | |
| RAW_METHOD_DUMP(OS, isCVTCIL); | |
| RAW_METHOD_DUMP(OS, isConstructorVirtualBase); | |
| RAW_METHOD_DUMP(OS, isCxxReturnUdt); | |
| RAW_METHOD_DUMP(OS, isDataAligned); | |
| RAW_METHOD_DUMP(OS, isHLSLData); | |
| RAW_METHOD_DUMP(OS, isHotpatchable); | |
| RAW_METHOD_DUMP(OS, indirectVirtualBaseClass); | |
| RAW_METHOD_DUMP(OS, isInterfaceUdt); | |
| RAW_METHOD_DUMP(OS, intrinsic); | |
| RAW_METHOD_DUMP(OS, isLTCG); | |
| RAW_METHOD_DUMP(OS, isLocationControlFlowDependent); | |
| RAW_METHOD_DUMP(OS, isMSILNetmodule); | |
| RAW_METHOD_DUMP(OS, isMatrixRowMajor); | |
| RAW_METHOD_DUMP(OS, managed); | |
| RAW_METHOD_DUMP(OS, msil); | |
| RAW_METHOD_DUMP(OS, isMultipleInheritance); | |
| RAW_METHOD_DUMP(OS, isNaked); | |
| RAW_METHOD_DUMP(OS, nested); | |
| RAW_METHOD_DUMP(OS, isOptimizedAway); | |
| RAW_METHOD_DUMP(OS, packed); | |
| RAW_METHOD_DUMP(OS, isPointerBasedOnSymbolValue); | |
| RAW_METHOD_DUMP(OS, isPointerToDataMember); | |
| RAW_METHOD_DUMP(OS, isPointerToMemberFunction); | |
| RAW_METHOD_DUMP(OS, pure); | |
| RAW_METHOD_DUMP(OS, RValueReference); | |
| RAW_METHOD_DUMP(OS, isRefUdt); | |
| RAW_METHOD_DUMP(OS, reference); | |
| RAW_METHOD_DUMP(OS, restrictedType); | |
| RAW_METHOD_DUMP(OS, isReturnValue); | |
| RAW_METHOD_DUMP(OS, isSafeBuffers); | |
| RAW_METHOD_DUMP(OS, scoped); | |
| RAW_METHOD_DUMP(OS, isSdl); | |
| RAW_METHOD_DUMP(OS, isSingleInheritance); | |
| RAW_METHOD_DUMP(OS, isSplitted); | |
| RAW_METHOD_DUMP(OS, isStatic); | |
| RAW_METHOD_DUMP(OS, isStripped); | |
| RAW_METHOD_DUMP(OS, unalignedType); | |
| RAW_METHOD_DUMP(OS, notReached); | |
| RAW_METHOD_DUMP(OS, isValueUdt); | |
| RAW_METHOD_DUMP(OS, virtual); | |
| RAW_METHOD_DUMP(OS, virtualBaseClass); | |
| RAW_METHOD_DUMP(OS, isVirtualInheritance); | |
| RAW_METHOD_DUMP(OS, volatileType); | |
| RAW_METHOD_DUMP(OS, wasInlined); | |
| RAW_METHOD_DUMP(OS, unused); | |
| RAW_METHOD_DUMP(OS, value); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findChildren(PDB_SymType Type) const { | |
| enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type); | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != | |
| Symbol->findChildrenEx(EnumVal, nullptr, nsNone, &DiaEnumerator)) { | |
| if (S_OK != Symbol->findChildren(EnumVal, nullptr, nsNone, &DiaEnumerator)) | |
| return nullptr; | |
| } | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findChildren(PDB_SymType Type, StringRef Name, | |
| PDB_NameSearchFlags Flags) const { | |
| llvm::SmallVector<UTF16, 32> Name16; | |
| llvm::convertUTF8ToUTF16String(Name, Name16); | |
| enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type); | |
| DWORD CompareFlags = static_cast<DWORD>(Flags); | |
| wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data()); | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != | |
| Symbol->findChildrenEx(EnumVal, Name16Str, CompareFlags, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findChildrenByAddr(PDB_SymType Type, StringRef Name, | |
| PDB_NameSearchFlags Flags, uint32_t Section, | |
| uint32_t Offset) const { | |
| llvm::SmallVector<UTF16, 32> Name16; | |
| llvm::convertUTF8ToUTF16String(Name, Name16); | |
| enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type); | |
| DWORD CompareFlags = static_cast<DWORD>(Flags); | |
| wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data()); | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != Symbol->findChildrenExByAddr(EnumVal, Name16Str, CompareFlags, | |
| Section, Offset, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findChildrenByVA(PDB_SymType Type, StringRef Name, | |
| PDB_NameSearchFlags Flags, uint64_t VA) const { | |
| llvm::SmallVector<UTF16, 32> Name16; | |
| llvm::convertUTF8ToUTF16String(Name, Name16); | |
| enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type); | |
| DWORD CompareFlags = static_cast<DWORD>(Flags); | |
| wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data()); | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != Symbol->findChildrenExByVA(EnumVal, Name16Str, CompareFlags, VA, | |
| &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findChildrenByRVA(PDB_SymType Type, StringRef Name, | |
| PDB_NameSearchFlags Flags, uint32_t RVA) const { | |
| llvm::SmallVector<UTF16, 32> Name16; | |
| llvm::convertUTF8ToUTF16String(Name, Name16); | |
| enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type); | |
| DWORD CompareFlags = static_cast<DWORD>(Flags); | |
| wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data()); | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != Symbol->findChildrenExByRVA(EnumVal, Name16Str, CompareFlags, RVA, | |
| &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findInlineFramesByAddr(uint32_t Section, uint32_t Offset) const { | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != Symbol->findInlineFramesByAddr(Section, Offset, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findInlineFramesByRVA(uint32_t RVA) const { | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != Symbol->findInlineFramesByRVA(RVA, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumSymbols> | |
| DIARawSymbol::findInlineFramesByVA(uint64_t VA) const { | |
| CComPtr<IDiaEnumSymbols> DiaEnumerator; | |
| if (S_OK != Symbol->findInlineFramesByVA(VA, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumSymbols>(Session, DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumLineNumbers> DIARawSymbol::findInlineeLines() const { | |
| CComPtr<IDiaEnumLineNumbers> DiaEnumerator; | |
| if (S_OK != Symbol->findInlineeLines(&DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumLineNumbers> | |
| DIARawSymbol::findInlineeLinesByAddr(uint32_t Section, uint32_t Offset, | |
| uint32_t Length) const { | |
| CComPtr<IDiaEnumLineNumbers> DiaEnumerator; | |
| if (S_OK != | |
| Symbol->findInlineeLinesByAddr(Section, Offset, Length, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumLineNumbers> | |
| DIARawSymbol::findInlineeLinesByRVA(uint32_t RVA, uint32_t Length) const { | |
| CComPtr<IDiaEnumLineNumbers> DiaEnumerator; | |
| if (S_OK != Symbol->findInlineeLinesByRVA(RVA, Length, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator); | |
| } | |
| std::unique_ptr<IPDBEnumLineNumbers> | |
| DIARawSymbol::findInlineeLinesByVA(uint64_t VA, uint32_t Length) const { | |
| CComPtr<IDiaEnumLineNumbers> DiaEnumerator; | |
| if (S_OK != Symbol->findInlineeLinesByVA(VA, Length, &DiaEnumerator)) | |
| return nullptr; | |
| return std::make_unique<DIAEnumLineNumbers>(DiaEnumerator); | |
| } | |
| void DIARawSymbol::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const { | |
| bytes.clear(); | |
| DWORD DataSize = 0; | |
| Symbol->get_dataBytes(0, &DataSize, nullptr); | |
| if (DataSize == 0) | |
| return; | |
| bytes.resize(DataSize); | |
| Symbol->get_dataBytes(DataSize, &DataSize, bytes.data()); | |
| } | |
| std::string DIARawSymbol::getUndecoratedNameEx(PDB_UndnameFlags Flags) const { | |
| CComBSTR Result16; | |
| if (S_OK != Symbol->get_undecoratedNameEx((DWORD)Flags, &Result16)) | |
| return std::string(); | |
| const char *SrcBytes = reinterpret_cast<const char *>(Result16.m_str); | |
| llvm::ArrayRef<char> SrcByteArray(SrcBytes, Result16.ByteLength()); | |
| std::string Result8; | |
| if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8)) | |
| return std::string(); | |
| return Result8; | |
| } | |
| PDB_MemberAccess DIARawSymbol::getAccess() const { | |
| return PrivateGetDIAValue<DWORD, PDB_MemberAccess>(Symbol, | |
| &IDiaSymbol::get_access); | |
| } | |
| uint32_t DIARawSymbol::getAddressOffset() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressOffset); | |
| } | |
| uint32_t DIARawSymbol::getAddressSection() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressSection); | |
| } | |
| uint32_t DIARawSymbol::getAge() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_age); | |
| } | |
| SymIndexId DIARawSymbol::getArrayIndexTypeId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_arrayIndexTypeId); | |
| } | |
| void DIARawSymbol::getBackEndVersion(VersionInfo &Version) const { | |
| Version.Major = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndMajor); | |
| Version.Minor = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndMinor); | |
| Version.Build = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndBuild); | |
| Version.QFE = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndQFE); | |
| } | |
| uint32_t DIARawSymbol::getBaseDataOffset() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataOffset); | |
| } | |
| uint32_t DIARawSymbol::getBaseDataSlot() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataSlot); | |
| } | |
| SymIndexId DIARawSymbol::getBaseSymbolId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseSymbolId); | |
| } | |
| PDB_BuiltinType DIARawSymbol::getBuiltinType() const { | |
| return PrivateGetDIAValue<DWORD, PDB_BuiltinType>(Symbol, | |
| &IDiaSymbol::get_baseType); | |
| } | |
| uint32_t DIARawSymbol::getBitPosition() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_bitPosition); | |
| } | |
| PDB_CallingConv DIARawSymbol::getCallingConvention() const { | |
| return PrivateGetDIAValue<DWORD, PDB_CallingConv>( | |
| Symbol, &IDiaSymbol::get_callingConvention); | |
| } | |
| SymIndexId DIARawSymbol::getClassParentId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_classParentId); | |
| } | |
| std::string DIARawSymbol::getCompilerName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerName); | |
| } | |
| uint32_t DIARawSymbol::getCount() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_count); | |
| } | |
| uint32_t DIARawSymbol::getCountLiveRanges() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_countLiveRanges); | |
| } | |
| void DIARawSymbol::getFrontEndVersion(VersionInfo &Version) const { | |
| Version.Major = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndMajor); | |
| Version.Minor = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndMinor); | |
| Version.Build = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndBuild); | |
| Version.QFE = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndQFE); | |
| } | |
| PDB_Lang DIARawSymbol::getLanguage() const { | |
| return PrivateGetDIAValue<DWORD, PDB_Lang>(Symbol, &IDiaSymbol::get_language); | |
| } | |
| SymIndexId DIARawSymbol::getLexicalParentId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lexicalParentId); | |
| } | |
| std::string DIARawSymbol::getLibraryName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_libraryName); | |
| } | |
| uint32_t DIARawSymbol::getLiveRangeStartAddressOffset() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_liveRangeStartAddressOffset); | |
| } | |
| uint32_t DIARawSymbol::getLiveRangeStartAddressSection() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_liveRangeStartAddressSection); | |
| } | |
| uint32_t DIARawSymbol::getLiveRangeStartRelativeVirtualAddress() const { | |
| return PrivateGetDIAValue( | |
| Symbol, &IDiaSymbol::get_liveRangeStartRelativeVirtualAddress); | |
| } | |
| codeview::RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const { | |
| return PrivateGetDIAValue<DWORD, codeview::RegisterId>( | |
| Symbol, &IDiaSymbol::get_localBasePointerRegisterId); | |
| } | |
| SymIndexId DIARawSymbol::getLowerBoundId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lowerBoundId); | |
| } | |
| uint32_t DIARawSymbol::getMemorySpaceKind() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_memorySpaceKind); | |
| } | |
| std::string DIARawSymbol::getName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_name); | |
| } | |
| uint32_t DIARawSymbol::getNumberOfAcceleratorPointerTags() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_numberOfAcceleratorPointerTags); | |
| } | |
| uint32_t DIARawSymbol::getNumberOfColumns() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfColumns); | |
| } | |
| uint32_t DIARawSymbol::getNumberOfModifiers() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfModifiers); | |
| } | |
| uint32_t DIARawSymbol::getNumberOfRegisterIndices() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRegisterIndices); | |
| } | |
| uint32_t DIARawSymbol::getNumberOfRows() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRows); | |
| } | |
| std::string DIARawSymbol::getObjectFileName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_objectFileName); | |
| } | |
| uint32_t DIARawSymbol::getOemId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemId); | |
| } | |
| SymIndexId DIARawSymbol::getOemSymbolId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemSymbolId); | |
| } | |
| uint32_t DIARawSymbol::getOffsetInUdt() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offsetInUdt); | |
| } | |
| PDB_Cpu DIARawSymbol::getPlatform() const { | |
| return PrivateGetDIAValue<DWORD, PDB_Cpu>(Symbol, &IDiaSymbol::get_platform); | |
| } | |
| uint32_t DIARawSymbol::getRank() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_rank); | |
| } | |
| codeview::RegisterId DIARawSymbol::getRegisterId() const { | |
| return PrivateGetDIAValue<DWORD, codeview::RegisterId>( | |
| Symbol, &IDiaSymbol::get_registerId); | |
| } | |
| uint32_t DIARawSymbol::getRegisterType() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_registerType); | |
| } | |
| uint32_t DIARawSymbol::getRelativeVirtualAddress() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_relativeVirtualAddress); | |
| } | |
| uint32_t DIARawSymbol::getSamplerSlot() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_samplerSlot); | |
| } | |
| uint32_t DIARawSymbol::getSignature() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_signature); | |
| } | |
| uint32_t DIARawSymbol::getSizeInUdt() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sizeInUdt); | |
| } | |
| uint32_t DIARawSymbol::getSlot() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_slot); | |
| } | |
| std::string DIARawSymbol::getSourceFileName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sourceFileName); | |
| } | |
| std::unique_ptr<IPDBLineNumber> DIARawSymbol::getSrcLineOnTypeDefn() const { | |
| CComPtr<IDiaLineNumber> LineNumber; | |
| if (FAILED(Symbol->getSrcLineOnTypeDefn(&LineNumber)) || !LineNumber) | |
| return nullptr; | |
| return std::make_unique<DIALineNumber>(LineNumber); | |
| } | |
| uint32_t DIARawSymbol::getStride() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_stride); | |
| } | |
| SymIndexId DIARawSymbol::getSubTypeId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_subTypeId); | |
| } | |
| std::string DIARawSymbol::getSymbolsFileName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symbolsFileName); | |
| } | |
| SymIndexId DIARawSymbol::getSymIndexId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symIndexId); | |
| } | |
| uint32_t DIARawSymbol::getTargetOffset() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetOffset); | |
| } | |
| uint32_t DIARawSymbol::getTargetRelativeVirtualAddress() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_targetRelativeVirtualAddress); | |
| } | |
| uint64_t DIARawSymbol::getTargetVirtualAddress() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetVirtualAddress); | |
| } | |
| uint32_t DIARawSymbol::getTargetSection() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetSection); | |
| } | |
| uint32_t DIARawSymbol::getTextureSlot() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_textureSlot); | |
| } | |
| uint32_t DIARawSymbol::getTimeStamp() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_timeStamp); | |
| } | |
| uint32_t DIARawSymbol::getToken() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_token); | |
| } | |
| SymIndexId DIARawSymbol::getTypeId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_typeId); | |
| } | |
| uint32_t DIARawSymbol::getUavSlot() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_uavSlot); | |
| } | |
| std::string DIARawSymbol::getUndecoratedName() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_undecoratedName); | |
| } | |
| SymIndexId DIARawSymbol::getUnmodifiedTypeId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unmodifiedTypeId); | |
| } | |
| SymIndexId DIARawSymbol::getUpperBoundId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_upperBoundId); | |
| } | |
| Variant DIARawSymbol::getValue() const { | |
| VARIANT Value; | |
| Value.vt = VT_EMPTY; | |
| if (S_OK != Symbol->get_value(&Value)) | |
| return Variant(); | |
| return VariantFromVARIANT(Value); | |
| } | |
| uint32_t DIARawSymbol::getVirtualBaseDispIndex() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseDispIndex); | |
| } | |
| uint32_t DIARawSymbol::getVirtualBaseOffset() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseOffset); | |
| } | |
| SymIndexId DIARawSymbol::getVirtualTableShapeId() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualTableShapeId); | |
| } | |
| std::unique_ptr<PDBSymbolTypeBuiltin> | |
| DIARawSymbol::getVirtualBaseTableType() const { | |
| CComPtr<IDiaSymbol> TableType; | |
| if (FAILED(Symbol->get_virtualBaseTableType(&TableType)) || !TableType) | |
| return nullptr; | |
| auto RawVT = std::make_unique<DIARawSymbol>(Session, TableType); | |
| auto Pointer = | |
| PDBSymbol::createAs<PDBSymbolTypePointer>(Session, std::move(RawVT)); | |
| return unique_dyn_cast<PDBSymbolTypeBuiltin>(Pointer->getPointeeType()); | |
| } | |
| PDB_DataKind DIARawSymbol::getDataKind() const { | |
| return PrivateGetDIAValue<DWORD, PDB_DataKind>(Symbol, | |
| &IDiaSymbol::get_dataKind); | |
| } | |
| PDB_SymType DIARawSymbol::getSymTag() const { | |
| return PrivateGetDIAValue<DWORD, PDB_SymType>(Symbol, | |
| &IDiaSymbol::get_symTag); | |
| } | |
| codeview::GUID DIARawSymbol::getGuid() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_guid); | |
| } | |
| int32_t DIARawSymbol::getOffset() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offset); | |
| } | |
| int32_t DIARawSymbol::getThisAdjust() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_thisAdjust); | |
| } | |
| int32_t DIARawSymbol::getVirtualBasePointerOffset() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBasePointerOffset); | |
| } | |
| PDB_LocType DIARawSymbol::getLocationType() const { | |
| return PrivateGetDIAValue<DWORD, PDB_LocType>(Symbol, | |
| &IDiaSymbol::get_locationType); | |
| } | |
| PDB_Machine DIARawSymbol::getMachineType() const { | |
| return PrivateGetDIAValue<DWORD, PDB_Machine>(Symbol, | |
| &IDiaSymbol::get_machineType); | |
| } | |
| codeview::ThunkOrdinal DIARawSymbol::getThunkOrdinal() const { | |
| return PrivateGetDIAValue<DWORD, codeview::ThunkOrdinal>( | |
| Symbol, &IDiaSymbol::get_thunkOrdinal); | |
| } | |
| uint64_t DIARawSymbol::getLength() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_length); | |
| } | |
| uint64_t DIARawSymbol::getLiveRangeLength() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_liveRangeLength); | |
| } | |
| uint64_t DIARawSymbol::getVirtualAddress() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualAddress); | |
| } | |
| PDB_UdtType DIARawSymbol::getUdtKind() const { | |
| return PrivateGetDIAValue<DWORD, PDB_UdtType>(Symbol, | |
| &IDiaSymbol::get_udtKind); | |
| } | |
| bool DIARawSymbol::hasConstructor() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constructor); | |
| } | |
| bool DIARawSymbol::hasCustomCallingConvention() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_customCallingConvention); | |
| } | |
| bool DIARawSymbol::hasFarReturn() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_farReturn); | |
| } | |
| bool DIARawSymbol::isCode() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_code); | |
| } | |
| bool DIARawSymbol::isCompilerGenerated() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerGenerated); | |
| } | |
| bool DIARawSymbol::isConstType() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constType); | |
| } | |
| bool DIARawSymbol::isEditAndContinueEnabled() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_editAndContinueEnabled); | |
| } | |
| bool DIARawSymbol::isFunction() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_function); | |
| } | |
| bool DIARawSymbol::getAddressTaken() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressTaken); | |
| } | |
| bool DIARawSymbol::getNoStackOrdering() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noStackOrdering); | |
| } | |
| bool DIARawSymbol::hasAlloca() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAlloca); | |
| } | |
| bool DIARawSymbol::hasAssignmentOperator() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAssignmentOperator); | |
| } | |
| bool DIARawSymbol::hasCTypes() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCTypes); | |
| } | |
| bool DIARawSymbol::hasCastOperator() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasCastOperator); | |
| } | |
| bool DIARawSymbol::hasDebugInfo() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasDebugInfo); | |
| } | |
| bool DIARawSymbol::hasEH() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEH); | |
| } | |
| bool DIARawSymbol::hasEHa() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEHa); | |
| } | |
| bool DIARawSymbol::hasInlAsm() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasInlAsm); | |
| } | |
| bool DIARawSymbol::hasInlineAttribute() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_inlSpec); | |
| } | |
| bool DIARawSymbol::hasInterruptReturn() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_interruptReturn); | |
| } | |
| bool DIARawSymbol::hasFramePointer() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_framePointerPresent); | |
| } | |
| bool DIARawSymbol::hasLongJump() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasLongJump); | |
| } | |
| bool DIARawSymbol::hasManagedCode() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasManagedCode); | |
| } | |
| bool DIARawSymbol::hasNestedTypes() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasNestedTypes); | |
| } | |
| bool DIARawSymbol::hasNoInlineAttribute() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noInline); | |
| } | |
| bool DIARawSymbol::hasNoReturnAttribute() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noReturn); | |
| } | |
| bool DIARawSymbol::hasOptimizedCodeDebugInfo() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_optimizedCodeDebugInfo); | |
| } | |
| bool DIARawSymbol::hasOverloadedOperator() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_overloadedOperator); | |
| } | |
| bool DIARawSymbol::hasSEH() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSEH); | |
| } | |
| bool DIARawSymbol::hasSecurityChecks() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSecurityChecks); | |
| } | |
| bool DIARawSymbol::hasSetJump() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSetJump); | |
| } | |
| bool DIARawSymbol::hasStrictGSCheck() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_strictGSCheck); | |
| } | |
| bool DIARawSymbol::isAcceleratorGroupSharedLocal() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_isAcceleratorGroupSharedLocal); | |
| } | |
| bool DIARawSymbol::isAcceleratorPointerTagLiveRange() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_isAcceleratorPointerTagLiveRange); | |
| } | |
| bool DIARawSymbol::isAcceleratorStubFunction() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAcceleratorStubFunction); | |
| } | |
| bool DIARawSymbol::isAggregated() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAggregated); | |
| } | |
| bool DIARawSymbol::isIntroVirtualFunction() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intro); | |
| } | |
| bool DIARawSymbol::isCVTCIL() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCVTCIL); | |
| } | |
| bool DIARawSymbol::isConstructorVirtualBase() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isConstructorVirtualBase); | |
| } | |
| bool DIARawSymbol::isCxxReturnUdt() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCxxReturnUdt); | |
| } | |
| bool DIARawSymbol::isDataAligned() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isDataAligned); | |
| } | |
| bool DIARawSymbol::isHLSLData() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHLSLData); | |
| } | |
| bool DIARawSymbol::isHotpatchable() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHotpatchable); | |
| } | |
| bool DIARawSymbol::isIndirectVirtualBaseClass() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_indirectVirtualBaseClass); | |
| } | |
| bool DIARawSymbol::isInterfaceUdt() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isInterfaceUdt); | |
| } | |
| bool DIARawSymbol::isIntrinsic() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intrinsic); | |
| } | |
| bool DIARawSymbol::isLTCG() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isLTCG); | |
| } | |
| bool DIARawSymbol::isLocationControlFlowDependent() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_isLocationControlFlowDependent); | |
| } | |
| bool DIARawSymbol::isMSILNetmodule() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMSILNetmodule); | |
| } | |
| bool DIARawSymbol::isMatrixRowMajor() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMatrixRowMajor); | |
| } | |
| bool DIARawSymbol::isManagedCode() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_managed); | |
| } | |
| bool DIARawSymbol::isMSILCode() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_msil); | |
| } | |
| bool DIARawSymbol::isMultipleInheritance() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMultipleInheritance); | |
| } | |
| bool DIARawSymbol::isNaked() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isNaked); | |
| } | |
| bool DIARawSymbol::isNested() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_nested); | |
| } | |
| bool DIARawSymbol::isOptimizedAway() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isOptimizedAway); | |
| } | |
| bool DIARawSymbol::isPacked() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_packed); | |
| } | |
| bool DIARawSymbol::isPointerBasedOnSymbolValue() const { | |
| return PrivateGetDIAValue(Symbol, | |
| &IDiaSymbol::get_isPointerBasedOnSymbolValue); | |
| } | |
| bool DIARawSymbol::isPointerToDataMember() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToDataMember); | |
| } | |
| bool DIARawSymbol::isPointerToMemberFunction() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToMemberFunction); | |
| } | |
| bool DIARawSymbol::isPureVirtual() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_pure); | |
| } | |
| bool DIARawSymbol::isRValueReference() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_RValueReference); | |
| } | |
| bool DIARawSymbol::isRefUdt() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isRefUdt); | |
| } | |
| bool DIARawSymbol::isReference() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_reference); | |
| } | |
| bool DIARawSymbol::isRestrictedType() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_restrictedType); | |
| } | |
| bool DIARawSymbol::isReturnValue() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isReturnValue); | |
| } | |
| bool DIARawSymbol::isSafeBuffers() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSafeBuffers); | |
| } | |
| bool DIARawSymbol::isScoped() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_scoped); | |
| } | |
| bool DIARawSymbol::isSdl() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSdl); | |
| } | |
| bool DIARawSymbol::isSingleInheritance() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSingleInheritance); | |
| } | |
| bool DIARawSymbol::isSplitted() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSplitted); | |
| } | |
| bool DIARawSymbol::isStatic() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStatic); | |
| } | |
| bool DIARawSymbol::hasPrivateSymbols() const { | |
| // hasPrivateSymbols is the opposite of isStripped, but we expose | |
| // hasPrivateSymbols as a more intuitive interface. | |
| return !PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStripped); | |
| } | |
| bool DIARawSymbol::isUnalignedType() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unalignedType); | |
| } | |
| bool DIARawSymbol::isUnreached() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_notReached); | |
| } | |
| bool DIARawSymbol::isValueUdt() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isValueUdt); | |
| } | |
| bool DIARawSymbol::isVirtual() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtual); | |
| } | |
| bool DIARawSymbol::isVirtualBaseClass() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseClass); | |
| } | |
| bool DIARawSymbol::isVirtualInheritance() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isVirtualInheritance); | |
| } | |
| bool DIARawSymbol::isVolatileType() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_volatileType); | |
| } | |
| bool DIARawSymbol::wasInlined() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_wasInlined); | |
| } | |
| std::string DIARawSymbol::getUnused() const { | |
| return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unused); | |
| } |