lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp

   1 //===- DIARawSymbol.cpp - DIA implementation of IPDBRawSymbol ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/STLExtras.h"
  11 #include "llvm/DebugInfo/PDB/DIA/DIAEnumSymbols.h"
  12 #include "llvm/DebugInfo/PDB/DIA/DIARawSymbol.h"
  13 #include "llvm/DebugInfo/PDB/DIA/DIASession.h"
  14 #include "llvm/DebugInfo/PDB/PDBExtras.h"
  15 #include "llvm/Support/ConvertUTF.h"
  16 #include "llvm/Support/raw_ostream.h"
  17
  18 using namespace llvm;
  19
  20 namespace {
  21 Variant VariantFromVARIANT(const VARIANT &V) {
  22   Variant Result;
  23   switch (V.vt) {
  24   case VT_I1:
  25     Result.Int8 = V.cVal;
  26     Result.Type = PDB_VariantType::Int8;
  27     break;
  28   case VT_I2:
  29     Result.Int16 = V.iVal;
  30     Result.Type = PDB_VariantType::Int16;
  31     break;
  32   case VT_I4:
  33     Result.Int32 = V.intVal;
  34     Result.Type = PDB_VariantType::Int32;
  35     break;
  36   case VT_I8:
  37     Result.Int64 = V.llVal;
  38     Result.Type = PDB_VariantType::Int64;
  39     break;
  40   case VT_UI1:
  41     Result.UInt8 = V.bVal;
  42     Result.Type = PDB_VariantType::UInt8;
  43     break;
  44   case VT_UI2:
  45     Result.UInt16 = V.uiVal;
  46     Result.Type = PDB_VariantType::UInt16;
  47     break;
  48   case VT_UI4:
  49     Result.UInt32 = V.uintVal;
  50     Result.Type = PDB_VariantType::UInt32;
  51     break;
  52   case VT_UI8:
  53     Result.UInt64 = V.ullVal;
  54     Result.Type = PDB_VariantType::UInt64;
  55     break;
  56   case VT_BOOL:
  57     Result.Bool = (V.boolVal == VARIANT_TRUE) ? true : false;
  58     Result.Type = PDB_VariantType::Bool;
  59     break;
  60   case VT_R4:
  61     Result.Single = V.fltVal;
  62     Result.Type = PDB_VariantType::Single;
  63     break;
  64   case VT_R8:
  65     Result.Double = V.dblVal;
  66     Result.Type = PDB_VariantType::Double;
  67     break;
  68   default:
  69     Result.Type = PDB_VariantType::Unknown;
  70     break;
  71   }
  72   return Result;
  73 }
  74
  75 template <typename ArgType>
  76 ArgType PrivateGetDIAValue(IDiaSymbol *Symbol,
  77                            HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {
  78   ArgType Value;
  79   if (S_OK == (Symbol->*Method)(&Value))
  80     return static_cast<ArgType>(Value);
  81
  82   return ArgType();
  83 }
  84
  85 template <typename ArgType, typename RetType>
  86 RetType PrivateGetDIAValue(IDiaSymbol *Symbol,
  87                            HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {
  88   ArgType Value;
  89   if (S_OK == (Symbol->*Method)(&Value))
  90     return static_cast<RetType>(Value);
  91
  92   return RetType();
  93 }
  94
  95 std::string
  96 PrivateGetDIAValue(IDiaSymbol *Symbol,
  97                    HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) {
  98   CComBSTR Result16;
  99   if (S_OK != (Symbol->*Method)(&Result16))
 100     return std::string();
 101
 102   const char *SrcBytes = reinterpret_cast<const char *>(Result16.m_str);
 103   llvm::ArrayRef<char> SrcByteArray(SrcBytes, Result16.ByteLength());
 104   std::string Result8;
 105   if (!llvm::convertUTF16ToUTF8String(SrcByteArray, Result8))
 106     return std::string();
 107   return Result8;
 108 }
 109
 110 PDB_UniqueId
 111 PrivateGetDIAValue(IDiaSymbol *Symbol,
 112                    HRESULT (__stdcall IDiaSymbol::*Method)(GUID *)) {
 113   GUID Result;
 114   if (S_OK != (Symbol->*Method)(&Result))
 115     return PDB_UniqueId();
 116
 117   static_assert(sizeof(PDB_UniqueId) == sizeof(GUID),
 118                 "PDB_UniqueId is the wrong size!");
 119   PDB_UniqueId IdResult;
 120   ::memcpy(&IdResult, &Result, sizeof(GUID));
 121   return IdResult;
 122 }
 123
 124 template <typename ArgType>
 125 void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,
 126                   IDiaSymbol *Symbol,
 127                   HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {
 128   ArgType Value;
 129   if (S_OK == (Symbol->*Method)(&Value)) {
 130     OS << "\n";
 131     OS.indent(Indent);
 132     OS << Name << ": " << Value;
 133   }
 134 }
 135
 136 void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,
 137                   IDiaSymbol *Symbol,
 138                   HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) {
 139   BSTR Value = nullptr;
 140   if (S_OK != (Symbol->*Method)(&Value))
 141     return;
 142   const char *Bytes = reinterpret_cast<const char *>(Value);
 143   ArrayRef<char> ByteArray(Bytes, ::SysStringByteLen(Value));
 144   std::string Result;
 145   if (llvm::convertUTF16ToUTF8String(ByteArray, Result)) {
 146     OS << "\n";
 147     OS.indent(Indent);
 148     OS << Name << ": " << Result;
 149   }
 150   ::SysFreeString(Value);
 151 }
 152
 153 void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,
 154                   IDiaSymbol *Symbol,
 155                   HRESULT (__stdcall IDiaSymbol::*Method)(VARIANT *)) {
 156   VARIANT Value;
 157   Value.vt = VT_EMPTY;
 158   if (S_OK != (Symbol->*Method)(&Value))
 159     return;
 160   OS << "\n";
 161   OS.indent(Indent);
 162   Variant V = VariantFromVARIANT(Value);
 163   OS << V;
 164 }
 165 }
 166
 167 namespace llvm {
 168 raw_ostream &operator<<(raw_ostream &OS, const GUID &Guid) {
 169   const PDB_UniqueId *Id = reinterpret_cast<const PDB_UniqueId *>(&Guid);
 170   OS << *Id;
 171   return OS;
 172 }
 173 }
 174
 175 DIARawSymbol::DIARawSymbol(const DIASession &PDBSession,
 176                            CComPtr<IDiaSymbol> DiaSymbol)
 177     : Session(PDBSession), Symbol(DiaSymbol) {}
 178
 179 #define RAW_METHOD_DUMP(Stream, Method)                                        \
 180   DumpDIAValue(Stream, Indent, StringRef(#Method), Symbol, &IDiaSymbol::Method);
 181
 182 void DIARawSymbol::dump(raw_ostream &OS, int Indent,
 183                         PDB_DumpLevel Level) const {
 184   RAW_METHOD_DUMP(OS, get_access)
 185   RAW_METHOD_DUMP(OS, get_addressOffset)
 186   RAW_METHOD_DUMP(OS, get_addressSection)
 187   RAW_METHOD_DUMP(OS, get_age)
 188   RAW_METHOD_DUMP(OS, get_arrayIndexTypeId)
 189   RAW_METHOD_DUMP(OS, get_backEndMajor)
 190   RAW_METHOD_DUMP(OS, get_backEndMinor)
 191   RAW_METHOD_DUMP(OS, get_backEndBuild)
 192   RAW_METHOD_DUMP(OS, get_backEndQFE)
 193   RAW_METHOD_DUMP(OS, get_baseDataOffset)
 194   RAW_METHOD_DUMP(OS, get_baseDataSlot)
 195   RAW_METHOD_DUMP(OS, get_baseSymbolId)
 196   RAW_METHOD_DUMP(OS, get_baseType)
 197   RAW_METHOD_DUMP(OS, get_bitPosition)
 198   RAW_METHOD_DUMP(OS, get_callingConvention)
 199   RAW_METHOD_DUMP(OS, get_classParentId)
 200   RAW_METHOD_DUMP(OS, get_compilerName)
 201   RAW_METHOD_DUMP(OS, get_count)
 202   RAW_METHOD_DUMP(OS, get_countLiveRanges)
 203   RAW_METHOD_DUMP(OS, get_frontEndMajor)
 204   RAW_METHOD_DUMP(OS, get_frontEndMinor)
 205   RAW_METHOD_DUMP(OS, get_frontEndBuild)
 206   RAW_METHOD_DUMP(OS, get_frontEndQFE)
 207   RAW_METHOD_DUMP(OS, get_lexicalParentId)
 208   RAW_METHOD_DUMP(OS, get_libraryName)
 209   RAW_METHOD_DUMP(OS, get_liveRangeStartAddressOffset)
 210   RAW_METHOD_DUMP(OS, get_liveRangeStartAddressSection)
 211   RAW_METHOD_DUMP(OS, get_liveRangeStartRelativeVirtualAddress)
 212   RAW_METHOD_DUMP(OS, get_localBasePointerRegisterId)
 213   RAW_METHOD_DUMP(OS, get_lowerBoundId)
 214   RAW_METHOD_DUMP(OS, get_memorySpaceKind)
 215   RAW_METHOD_DUMP(OS, get_name)
 216   RAW_METHOD_DUMP(OS, get_numberOfAcceleratorPointerTags)
 217   RAW_METHOD_DUMP(OS, get_numberOfColumns)
 218   RAW_METHOD_DUMP(OS, get_numberOfModifiers)
 219   RAW_METHOD_DUMP(OS, get_numberOfRegisterIndices)
 220   RAW_METHOD_DUMP(OS, get_numberOfRows)
 221   RAW_METHOD_DUMP(OS, get_objectFileName)
 222   RAW_METHOD_DUMP(OS, get_oemId)
 223   RAW_METHOD_DUMP(OS, get_oemSymbolId)
 224   RAW_METHOD_DUMP(OS, get_offsetInUdt)
 225   RAW_METHOD_DUMP(OS, get_platform)
 226   RAW_METHOD_DUMP(OS, get_rank)
 227   RAW_METHOD_DUMP(OS, get_registerId)
 228   RAW_METHOD_DUMP(OS, get_registerType)
 229   RAW_METHOD_DUMP(OS, get_relativeVirtualAddress)
 230   RAW_METHOD_DUMP(OS, get_samplerSlot)
 231   RAW_METHOD_DUMP(OS, get_signature)
 232   RAW_METHOD_DUMP(OS, get_sizeInUdt)
 233   RAW_METHOD_DUMP(OS, get_slot)
 234   RAW_METHOD_DUMP(OS, get_sourceFileName)
 235   RAW_METHOD_DUMP(OS, get_stride)
 236   RAW_METHOD_DUMP(OS, get_subTypeId)
 237   RAW_METHOD_DUMP(OS, get_symbolsFileName)
 238   RAW_METHOD_DUMP(OS, get_symIndexId)
 239   RAW_METHOD_DUMP(OS, get_targetOffset)
 240   RAW_METHOD_DUMP(OS, get_targetRelativeVirtualAddress)
 241   RAW_METHOD_DUMP(OS, get_targetVirtualAddress)
 242   RAW_METHOD_DUMP(OS, get_targetSection)
 243   RAW_METHOD_DUMP(OS, get_textureSlot)
 244   RAW_METHOD_DUMP(OS, get_timeStamp)
 245   RAW_METHOD_DUMP(OS, get_token)
 246   RAW_METHOD_DUMP(OS, get_typeId)
 247   RAW_METHOD_DUMP(OS, get_uavSlot)
 248   RAW_METHOD_DUMP(OS, get_undecoratedName)
 249   RAW_METHOD_DUMP(OS, get_unmodifiedTypeId)
 250   RAW_METHOD_DUMP(OS, get_upperBoundId)
 251   RAW_METHOD_DUMP(OS, get_virtualBaseDispIndex)
 252   RAW_METHOD_DUMP(OS, get_virtualBaseOffset)
 253   RAW_METHOD_DUMP(OS, get_virtualTableShapeId)
 254   RAW_METHOD_DUMP(OS, get_dataKind)
 255   RAW_METHOD_DUMP(OS, get_symTag)
 256   RAW_METHOD_DUMP(OS, get_guid)
 257   RAW_METHOD_DUMP(OS, get_offset)
 258   RAW_METHOD_DUMP(OS, get_thisAdjust)
 259   RAW_METHOD_DUMP(OS, get_virtualBasePointerOffset)
 260   RAW_METHOD_DUMP(OS, get_locationType)
 261   RAW_METHOD_DUMP(OS, get_machineType)
 262   RAW_METHOD_DUMP(OS, get_thunkOrdinal)
 263   RAW_METHOD_DUMP(OS, get_length)
 264   RAW_METHOD_DUMP(OS, get_liveRangeLength)
 265   RAW_METHOD_DUMP(OS, get_virtualAddress)
 266   RAW_METHOD_DUMP(OS, get_udtKind)
 267   RAW_METHOD_DUMP(OS, get_constructor)
 268   RAW_METHOD_DUMP(OS, get_customCallingConvention)
 269   RAW_METHOD_DUMP(OS, get_farReturn)
 270   RAW_METHOD_DUMP(OS, get_code)
 271   RAW_METHOD_DUMP(OS, get_compilerGenerated)
 272   RAW_METHOD_DUMP(OS, get_constType)
 273   RAW_METHOD_DUMP(OS, get_editAndContinueEnabled)
 274   RAW_METHOD_DUMP(OS, get_function)
 275   RAW_METHOD_DUMP(OS, get_stride)
 276   RAW_METHOD_DUMP(OS, get_noStackOrdering)
 277   RAW_METHOD_DUMP(OS, get_hasAlloca)
 278   RAW_METHOD_DUMP(OS, get_hasAssignmentOperator)
 279   RAW_METHOD_DUMP(OS, get_isCTypes)
 280   RAW_METHOD_DUMP(OS, get_hasCastOperator)
 281   RAW_METHOD_DUMP(OS, get_hasDebugInfo)
 282   RAW_METHOD_DUMP(OS, get_hasEH)
 283   RAW_METHOD_DUMP(OS, get_hasEHa)
 284   RAW_METHOD_DUMP(OS, get_hasInlAsm)
 285   RAW_METHOD_DUMP(OS, get_framePointerPresent)
 286   RAW_METHOD_DUMP(OS, get_inlSpec)
 287   RAW_METHOD_DUMP(OS, get_interruptReturn)
 288   RAW_METHOD_DUMP(OS, get_hasLongJump)
 289   RAW_METHOD_DUMP(OS, get_hasManagedCode)
 290   RAW_METHOD_DUMP(OS, get_hasNestedTypes)
 291   RAW_METHOD_DUMP(OS, get_noInline)
 292   RAW_METHOD_DUMP(OS, get_noReturn)
 293   RAW_METHOD_DUMP(OS, get_optimizedCodeDebugInfo)
 294   RAW_METHOD_DUMP(OS, get_overloadedOperator)
 295   RAW_METHOD_DUMP(OS, get_hasSEH)
 296   RAW_METHOD_DUMP(OS, get_hasSecurityChecks)
 297   RAW_METHOD_DUMP(OS, get_hasSetJump)
 298   RAW_METHOD_DUMP(OS, get_strictGSCheck)
 299   RAW_METHOD_DUMP(OS, get_isAcceleratorGroupSharedLocal)
 300   RAW_METHOD_DUMP(OS, get_isAcceleratorPointerTagLiveRange)
 301   RAW_METHOD_DUMP(OS, get_isAcceleratorStubFunction)
 302   RAW_METHOD_DUMP(OS, get_isAggregated)
 303   RAW_METHOD_DUMP(OS, get_intro)
 304   RAW_METHOD_DUMP(OS, get_isCVTCIL)
 305   RAW_METHOD_DUMP(OS, get_isConstructorVirtualBase)
 306   RAW_METHOD_DUMP(OS, get_isCxxReturnUdt)
 307   RAW_METHOD_DUMP(OS, get_isDataAligned)
 308   RAW_METHOD_DUMP(OS, get_isHLSLData)
 309   RAW_METHOD_DUMP(OS, get_isHotpatchable)
 310   RAW_METHOD_DUMP(OS, get_indirectVirtualBaseClass)
 311   RAW_METHOD_DUMP(OS, get_isInterfaceUdt)
 312   RAW_METHOD_DUMP(OS, get_intrinsic)
 313   RAW_METHOD_DUMP(OS, get_isLTCG)
 314   RAW_METHOD_DUMP(OS, get_isLocationControlFlowDependent)
 315   RAW_METHOD_DUMP(OS, get_isMSILNetmodule)
 316   RAW_METHOD_DUMP(OS, get_isMatrixRowMajor)
 317   RAW_METHOD_DUMP(OS, get_managed)
 318   RAW_METHOD_DUMP(OS, get_msil)
 319   RAW_METHOD_DUMP(OS, get_isMultipleInheritance)
 320   RAW_METHOD_DUMP(OS, get_isNaked)
 321   RAW_METHOD_DUMP(OS, get_nested)
 322   RAW_METHOD_DUMP(OS, get_isOptimizedAway)
 323   RAW_METHOD_DUMP(OS, get_packed)
 324   RAW_METHOD_DUMP(OS, get_isPointerBasedOnSymbolValue)
 325   RAW_METHOD_DUMP(OS, get_isPointerToDataMember)
 326   RAW_METHOD_DUMP(OS, get_isPointerToMemberFunction)
 327   RAW_METHOD_DUMP(OS, get_pure)
 328   RAW_METHOD_DUMP(OS, get_RValueReference)
 329   RAW_METHOD_DUMP(OS, get_isRefUdt)
 330   RAW_METHOD_DUMP(OS, get_reference)
 331   RAW_METHOD_DUMP(OS, get_restrictedType)
 332   RAW_METHOD_DUMP(OS, get_isReturnValue)
 333   RAW_METHOD_DUMP(OS, get_isSafeBuffers)
 334   RAW_METHOD_DUMP(OS, get_scoped)
 335   RAW_METHOD_DUMP(OS, get_isSdl)
 336   RAW_METHOD_DUMP(OS, get_isSingleInheritance)
 337   RAW_METHOD_DUMP(OS, get_isSplitted)
 338   RAW_METHOD_DUMP(OS, get_isStatic)
 339   RAW_METHOD_DUMP(OS, get_isStripped)
 340   RAW_METHOD_DUMP(OS, get_unalignedType)
 341   RAW_METHOD_DUMP(OS, get_notReached)
 342   RAW_METHOD_DUMP(OS, get_isValueUdt)
 343   RAW_METHOD_DUMP(OS, get_virtual)
 344   RAW_METHOD_DUMP(OS, get_virtualBaseClass)
 345   RAW_METHOD_DUMP(OS, get_isVirtualInheritance)
 346   RAW_METHOD_DUMP(OS, get_volatileType)
 347   RAW_METHOD_DUMP(OS, get_wasInlined)
 348   RAW_METHOD_DUMP(OS, get_unused)
 349   RAW_METHOD_DUMP(OS, get_value)
 350 }
 351
 352 std::unique_ptr<IPDBEnumSymbols>
 353 DIARawSymbol::findChildren(PDB_SymType Type) const {
 354   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
 355
 356   CComPtr<IDiaEnumSymbols> DiaEnumerator;
 357   if (S_OK != Symbol->findChildrenEx(EnumVal, nullptr, nsNone, &DiaEnumerator))
 358     return nullptr;
 359
 360   return llvm::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);
 361 }
 362
 363 std::unique_ptr<IPDBEnumSymbols>
 364 DIARawSymbol::findChildren(PDB_SymType Type, StringRef Name,
 365                            PDB_NameSearchFlags Flags) const {
 366   llvm::SmallVector<UTF16, 32> Name16;
 367   llvm::convertUTF8ToUTF16String(Name, Name16);
 368
 369   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
 370   DWORD CompareFlags = static_cast<DWORD>(Flags);
 371   wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data());
 372
 373   CComPtr<IDiaEnumSymbols> DiaEnumerator;
 374   if (S_OK !=
 375       Symbol->findChildrenEx(EnumVal, Name16Str, CompareFlags, &DiaEnumerator))
 376     return nullptr;
 377
 378   return llvm::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);
 379 }
 380
 381 std::unique_ptr<IPDBEnumSymbols>
 382 DIARawSymbol::findChildrenByRVA(PDB_SymType Type, StringRef Name,
 383                                 PDB_NameSearchFlags Flags, uint32_t RVA) const {
 384   llvm::SmallVector<UTF16, 32> Name16;
 385   llvm::convertUTF8ToUTF16String(Name, Name16);
 386
 387   enum SymTagEnum EnumVal = static_cast<enum SymTagEnum>(Type);
 388   DWORD CompareFlags = static_cast<DWORD>(Flags);
 389   wchar_t *Name16Str = reinterpret_cast<wchar_t *>(Name16.data());
 390
 391   CComPtr<IDiaEnumSymbols> DiaEnumerator;
 392   if (S_OK !=
 393       Symbol->findChildrenExByRVA(EnumVal, Name16Str, CompareFlags, RVA,
 394                                   &DiaEnumerator))
 395     return nullptr;
 396
 397   return llvm::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);
 398 }
 399
 400 std::unique_ptr<IPDBEnumSymbols>
 401 DIARawSymbol::findInlineFramesByRVA(uint32_t RVA) const {
 402   CComPtr<IDiaEnumSymbols> DiaEnumerator;
 403   if (S_OK != Symbol->findInlineFramesByRVA(RVA, &DiaEnumerator))
 404     return nullptr;
 405
 406   return llvm::make_unique<DIAEnumSymbols>(Session, DiaEnumerator);
 407 }
 408
 409 void DIARawSymbol::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const {
 410   bytes.clear();
 411
 412   DWORD DataSize = 0;
 413   Symbol->get_dataBytes(0, &DataSize, nullptr);
 414   if (DataSize == 0)
 415     return;
 416
 417   bytes.resize(DataSize);
 418   Symbol->get_dataBytes(DataSize, &DataSize, bytes.data());
 419 }
 420
 421 PDB_MemberAccess DIARawSymbol::getAccess() const {
 422   return PrivateGetDIAValue<DWORD, PDB_MemberAccess>(Symbol,
 423                                                      &IDiaSymbol::get_access);
 424 }
 425
 426 uint32_t DIARawSymbol::getAddressOffset() const {
 427   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressOffset);
 428 }
 429
 430 uint32_t DIARawSymbol::getAddressSection() const {
 431   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressSection);
 432 }
 433
 434 uint32_t DIARawSymbol::getAge() const {
 435   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_age);
 436 }
 437
 438 uint32_t DIARawSymbol::getArrayIndexTypeId() const {
 439   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_arrayIndexTypeId);
 440 }
 441
 442 void DIARawSymbol::getBackEndVersion(VersionInfo &Version) const {
 443   Version.Major = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndMajor);
 444   Version.Minor = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndMinor);
 445   Version.Build = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndBuild);
 446   Version.QFE = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_backEndQFE);
 447 }
 448
 449 uint32_t DIARawSymbol::getBaseDataOffset() const {
 450   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataOffset);
 451 }
 452
 453 uint32_t DIARawSymbol::getBaseDataSlot() const {
 454   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataSlot);
 455 }
 456
 457 uint32_t DIARawSymbol::getBaseSymbolId() const {
 458   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseSymbolId);
 459 }
 460
 461 PDB_BuiltinType DIARawSymbol::getBuiltinType() const {
 462   return PrivateGetDIAValue<DWORD, PDB_BuiltinType>(Symbol,
 463                                                     &IDiaSymbol::get_baseType);
 464 }
 465
 466 uint32_t DIARawSymbol::getBitPosition() const {
 467   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_bitPosition);
 468 }
 469
 470 PDB_CallingConv DIARawSymbol::getCallingConvention() const {
 471   return PrivateGetDIAValue<DWORD, PDB_CallingConv>(
 472       Symbol, &IDiaSymbol::get_callingConvention);
 473 }
 474
 475 uint32_t DIARawSymbol::getClassParentId() const {
 476   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_classParentId);
 477 }
 478
 479 std::string DIARawSymbol::getCompilerName() const {
 480   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerName);
 481 }
 482
 483 uint32_t DIARawSymbol::getCount() const {
 484   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_count);
 485 }
 486
 487 uint32_t DIARawSymbol::getCountLiveRanges() const {
 488   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_countLiveRanges);
 489 }
 490
 491 void DIARawSymbol::getFrontEndVersion(VersionInfo &Version) const {
 492   Version.Major = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndMajor);
 493   Version.Minor = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndMinor);
 494   Version.Build = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndBuild);
 495   Version.QFE = PrivateGetDIAValue(Symbol, &IDiaSymbol::get_frontEndQFE);
 496 }
 497
 498 PDB_Lang DIARawSymbol::getLanguage() const {
 499   return PrivateGetDIAValue<DWORD, PDB_Lang>(Symbol, &IDiaSymbol::get_language);
 500 }
 501
 502 uint32_t DIARawSymbol::getLexicalParentId() const {
 503   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lexicalParentId);
 504 }
 505
 506 std::string DIARawSymbol::getLibraryName() const {
 507   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_libraryName);
 508 }
 509
 510 uint32_t DIARawSymbol::getLiveRangeStartAddressOffset() const {
 511   return PrivateGetDIAValue(Symbol,
 512                             &IDiaSymbol::get_liveRangeStartAddressOffset);
 513 }
 514
 515 uint32_t DIARawSymbol::getLiveRangeStartAddressSection() const {
 516   return PrivateGetDIAValue(Symbol,
 517                             &IDiaSymbol::get_liveRangeStartAddressSection);
 518 }
 519
 520 uint32_t DIARawSymbol::getLiveRangeStartRelativeVirtualAddress() const {
 521   return PrivateGetDIAValue(
 522       Symbol, &IDiaSymbol::get_liveRangeStartRelativeVirtualAddress);
 523 }
 524
 525 PDB_RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const {
 526   return PrivateGetDIAValue<DWORD, PDB_RegisterId>(
 527       Symbol, &IDiaSymbol::get_localBasePointerRegisterId);
 528 }
 529
 530 uint32_t DIARawSymbol::getLowerBoundId() const {
 531   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lowerBoundId);
 532 }
 533
 534 uint32_t DIARawSymbol::getMemorySpaceKind() const {
 535   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_memorySpaceKind);
 536 }
 537
 538 std::string DIARawSymbol::getName() const {
 539   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_name);
 540 }
 541
 542 uint32_t DIARawSymbol::getNumberOfAcceleratorPointerTags() const {
 543   return PrivateGetDIAValue(Symbol,
 544                             &IDiaSymbol::get_numberOfAcceleratorPointerTags);
 545 }
 546
 547 uint32_t DIARawSymbol::getNumberOfColumns() const {
 548   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfColumns);
 549 }
 550
 551 uint32_t DIARawSymbol::getNumberOfModifiers() const {
 552   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfModifiers);
 553 }
 554
 555 uint32_t DIARawSymbol::getNumberOfRegisterIndices() const {
 556   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRegisterIndices);
 557 }
 558
 559 uint32_t DIARawSymbol::getNumberOfRows() const {
 560   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRows);
 561 }
 562
 563 std::string DIARawSymbol::getObjectFileName() const {
 564   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_objectFileName);
 565 }
 566
 567 uint32_t DIARawSymbol::getOemId() const {
 568   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemId);
 569 }
 570
 571 uint32_t DIARawSymbol::getOemSymbolId() const {
 572   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemSymbolId);
 573 }
 574
 575 uint32_t DIARawSymbol::getOffsetInUdt() const {
 576   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offsetInUdt);
 577 }
 578
 579 PDB_Cpu DIARawSymbol::getPlatform() const {
 580   return PrivateGetDIAValue<DWORD, PDB_Cpu>(Symbol, &IDiaSymbol::get_platform);
 581 }
 582
 583 uint32_t DIARawSymbol::getRank() const {
 584   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_rank);
 585 }
 586
 587 PDB_RegisterId DIARawSymbol::getRegisterId() const {
 588   return PrivateGetDIAValue<DWORD, PDB_RegisterId>(Symbol,
 589                                                    &IDiaSymbol::get_registerId);
 590 }
 591
 592 uint32_t DIARawSymbol::getRegisterType() const {
 593   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_registerType);
 594 }
 595
 596 uint32_t DIARawSymbol::getRelativeVirtualAddress() const {
 597   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_relativeVirtualAddress);
 598 }
 599
 600 uint32_t DIARawSymbol::getSamplerSlot() const {
 601   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_samplerSlot);
 602 }
 603
 604 uint32_t DIARawSymbol::getSignature() const {
 605   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_signature);
 606 }
 607
 608 uint32_t DIARawSymbol::getSizeInUdt() const {
 609   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sizeInUdt);
 610 }
 611
 612 uint32_t DIARawSymbol::getSlot() const {
 613   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_slot);
 614 }
 615
 616 std::string DIARawSymbol::getSourceFileName() const {
 617   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sourceFileName);
 618 }
 619
 620 uint32_t DIARawSymbol::getStride() const {
 621   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_stride);
 622 }
 623
 624 uint32_t DIARawSymbol::getSubTypeId() const {
 625   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_subTypeId);
 626 }
 627
 628 std::string DIARawSymbol::getSymbolsFileName() const {
 629   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symbolsFileName);
 630 }
 631
 632 uint32_t DIARawSymbol::getSymIndexId() const {
 633   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symIndexId);
 634 }
 635
 636 uint32_t DIARawSymbol::getTargetOffset() const {
 637   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetOffset);
 638 }
 639
 640 uint32_t DIARawSymbol::getTargetRelativeVirtualAddress() const {
 641   return PrivateGetDIAValue(Symbol,
 642                             &IDiaSymbol::get_targetRelativeVirtualAddress);
 643 }
 644
 645 uint64_t DIARawSymbol::getTargetVirtualAddress() const {
 646   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetVirtualAddress);
 647 }
 648
 649 uint32_t DIARawSymbol::getTargetSection() const {
 650   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetSection);
 651 }
 652
 653 uint32_t DIARawSymbol::getTextureSlot() const {
 654   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_textureSlot);
 655 }
 656
 657 uint32_t DIARawSymbol::getTimeStamp() const {
 658   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_timeStamp);
 659 }
 660
 661 uint32_t DIARawSymbol::getToken() const {
 662   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_token);
 663 }
 664
 665 uint32_t DIARawSymbol::getTypeId() const {
 666   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_typeId);
 667 }
 668
 669 uint32_t DIARawSymbol::getUavSlot() const {
 670   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_uavSlot);
 671 }
 672
 673 std::string DIARawSymbol::getUndecoratedName() const {
 674   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_undecoratedName);
 675 }
 676
 677 uint32_t DIARawSymbol::getUnmodifiedTypeId() const {
 678   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unmodifiedTypeId);
 679 }
 680
 681 uint32_t DIARawSymbol::getUpperBoundId() const {
 682   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_upperBoundId);
 683 }
 684
 685 Variant DIARawSymbol::getValue() const {
 686   VARIANT Value;
 687   Value.vt = VT_EMPTY;
 688   if (S_OK != Symbol->get_value(&Value))
 689     return Variant();
 690
 691   return VariantFromVARIANT(Value);
 692 }
 693
 694 uint32_t DIARawSymbol::getVirtualBaseDispIndex() const {
 695   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseDispIndex);
 696 }
 697
 698 uint32_t DIARawSymbol::getVirtualBaseOffset() const {
 699   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseOffset);
 700 }
 701
 702 uint32_t DIARawSymbol::getVirtualTableShapeId() const {
 703   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualTableShapeId);
 704 }
 705
 706 PDB_DataKind DIARawSymbol::getDataKind() const {
 707   return PrivateGetDIAValue<DWORD, PDB_DataKind>(Symbol,
 708                                                  &IDiaSymbol::get_dataKind);
 709 }
 710
 711 PDB_SymType DIARawSymbol::getSymTag() const {
 712   return PrivateGetDIAValue<DWORD, PDB_SymType>(Symbol,
 713                                                 &IDiaSymbol::get_symTag);
 714 }
 715
 716 PDB_UniqueId DIARawSymbol::getGuid() const {
 717   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_guid);
 718 }
 719
 720 int32_t DIARawSymbol::getOffset() const {
 721   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offset);
 722 }
 723
 724 int32_t DIARawSymbol::getThisAdjust() const {
 725   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_thisAdjust);
 726 }
 727
 728 int32_t DIARawSymbol::getVirtualBasePointerOffset() const {
 729   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBasePointerOffset);
 730 }
 731
 732 PDB_LocType DIARawSymbol::getLocationType() const {
 733   return PrivateGetDIAValue<DWORD, PDB_LocType>(Symbol,
 734                                                 &IDiaSymbol::get_locationType);
 735 }
 736
 737 PDB_Machine DIARawSymbol::getMachineType() const {
 738   return PrivateGetDIAValue<DWORD, PDB_Machine>(Symbol,
 739                                                 &IDiaSymbol::get_machineType);
 740 }
 741
 742 PDB_ThunkOrdinal DIARawSymbol::getThunkOrdinal() const {
 743   return PrivateGetDIAValue<DWORD, PDB_ThunkOrdinal>(
 744       Symbol, &IDiaSymbol::get_thunkOrdinal);
 745 }
 746
 747 uint64_t DIARawSymbol::getLength() const {
 748   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_length);
 749 }
 750
 751 uint64_t DIARawSymbol::getLiveRangeLength() const {
 752   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_liveRangeLength);
 753 }
 754
 755 uint64_t DIARawSymbol::getVirtualAddress() const {
 756   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualAddress);
 757 }
 758
 759 PDB_UdtType DIARawSymbol::getUdtKind() const {
 760   return PrivateGetDIAValue<DWORD, PDB_UdtType>(Symbol,
 761                                                 &IDiaSymbol::get_udtKind);
 762 }
 763
 764 bool DIARawSymbol::hasConstructor() const {
 765   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constructor);
 766 }
 767
 768 bool DIARawSymbol::hasCustomCallingConvention() const {
 769   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_customCallingConvention);
 770 }
 771
 772 bool DIARawSymbol::hasFarReturn() const {
 773   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_farReturn);
 774 }
 775
 776 bool DIARawSymbol::isCode() const {
 777   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_code);
 778 }
 779
 780 bool DIARawSymbol::isCompilerGenerated() const {
 781   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerGenerated);
 782 }
 783
 784 bool DIARawSymbol::isConstType() const {
 785   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constType);
 786 }
 787
 788 bool DIARawSymbol::isEditAndContinueEnabled() const {
 789   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_editAndContinueEnabled);
 790 }
 791
 792 bool DIARawSymbol::isFunction() const {
 793   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_function);
 794 }
 795
 796 bool DIARawSymbol::getAddressTaken() const {
 797   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressTaken);
 798 }
 799
 800 bool DIARawSymbol::getNoStackOrdering() const {
 801   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noStackOrdering);
 802 }
 803
 804 bool DIARawSymbol::hasAlloca() const {
 805   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAlloca);
 806 }
 807
 808 bool DIARawSymbol::hasAssignmentOperator() const {
 809   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAssignmentOperator);
 810 }
 811
 812 bool DIARawSymbol::hasCTypes() const {
 813   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCTypes);
 814 }
 815
 816 bool DIARawSymbol::hasCastOperator() const {
 817   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasCastOperator);
 818 }
 819
 820 bool DIARawSymbol::hasDebugInfo() const {
 821   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasDebugInfo);
 822 }
 823
 824 bool DIARawSymbol::hasEH() const {
 825   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEH);
 826 }
 827
 828 bool DIARawSymbol::hasEHa() const {
 829   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEHa);
 830 }
 831
 832 bool DIARawSymbol::hasInlAsm() const {
 833   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasInlAsm);
 834 }
 835
 836 bool DIARawSymbol::hasInlineAttribute() const {
 837   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_inlSpec);
 838 }
 839
 840 bool DIARawSymbol::hasInterruptReturn() const {
 841   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_interruptReturn);
 842 }
 843
 844 bool DIARawSymbol::hasFramePointer() const {
 845   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_framePointerPresent);
 846 }
 847
 848 bool DIARawSymbol::hasLongJump() const {
 849   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasLongJump);
 850 }
 851
 852 bool DIARawSymbol::hasManagedCode() const {
 853   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasManagedCode);
 854 }
 855
 856 bool DIARawSymbol::hasNestedTypes() const {
 857   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasNestedTypes);
 858 }
 859
 860 bool DIARawSymbol::hasNoInlineAttribute() const {
 861   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noInline);
 862 }
 863
 864 bool DIARawSymbol::hasNoReturnAttribute() const {
 865   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noReturn);
 866 }
 867
 868 bool DIARawSymbol::hasOptimizedCodeDebugInfo() const {
 869   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_optimizedCodeDebugInfo);
 870 }
 871
 872 bool DIARawSymbol::hasOverloadedOperator() const {
 873   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_overloadedOperator);
 874 }
 875
 876 bool DIARawSymbol::hasSEH() const {
 877   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSEH);
 878 }
 879
 880 bool DIARawSymbol::hasSecurityChecks() const {
 881   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSecurityChecks);
 882 }
 883
 884 bool DIARawSymbol::hasSetJump() const {
 885   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSetJump);
 886 }
 887
 888 bool DIARawSymbol::hasStrictGSCheck() const {
 889   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_strictGSCheck);
 890 }
 891
 892 bool DIARawSymbol::isAcceleratorGroupSharedLocal() const {
 893   return PrivateGetDIAValue(Symbol,
 894                             &IDiaSymbol::get_isAcceleratorGroupSharedLocal);
 895 }
 896
 897 bool DIARawSymbol::isAcceleratorPointerTagLiveRange() const {
 898   return PrivateGetDIAValue(Symbol,
 899                             &IDiaSymbol::get_isAcceleratorPointerTagLiveRange);
 900 }
 901
 902 bool DIARawSymbol::isAcceleratorStubFunction() const {
 903   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAcceleratorStubFunction);
 904 }
 905
 906 bool DIARawSymbol::isAggregated() const {
 907   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAggregated);
 908 }
 909
 910 bool DIARawSymbol::isIntroVirtualFunction() const {
 911   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intro);
 912 }
 913
 914 bool DIARawSymbol::isCVTCIL() const {
 915   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCVTCIL);
 916 }
 917
 918 bool DIARawSymbol::isConstructorVirtualBase() const {
 919   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isConstructorVirtualBase);
 920 }
 921
 922 bool DIARawSymbol::isCxxReturnUdt() const {
 923   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCxxReturnUdt);
 924 }
 925
 926 bool DIARawSymbol::isDataAligned() const {
 927   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isDataAligned);
 928 }
 929
 930 bool DIARawSymbol::isHLSLData() const {
 931   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHLSLData);
 932 }
 933
 934 bool DIARawSymbol::isHotpatchable() const {
 935   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHotpatchable);
 936 }
 937
 938 bool DIARawSymbol::isIndirectVirtualBaseClass() const {
 939   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_indirectVirtualBaseClass);
 940 }
 941
 942 bool DIARawSymbol::isInterfaceUdt() const {
 943   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isInterfaceUdt);
 944 }
 945
 946 bool DIARawSymbol::isIntrinsic() const {
 947   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intrinsic);
 948 }
 949
 950 bool DIARawSymbol::isLTCG() const {
 951   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isLTCG);
 952 }
 953
 954 bool DIARawSymbol::isLocationControlFlowDependent() const {
 955   return PrivateGetDIAValue(Symbol,
 956                             &IDiaSymbol::get_isLocationControlFlowDependent);
 957 }
 958
 959 bool DIARawSymbol::isMSILNetmodule() const {
 960   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMSILNetmodule);
 961 }
 962
 963 bool DIARawSymbol::isMatrixRowMajor() const {
 964   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMatrixRowMajor);
 965 }
 966
 967 bool DIARawSymbol::isManagedCode() const {
 968   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_managed);
 969 }
 970
 971 bool DIARawSymbol::isMSILCode() const {
 972   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_msil);
 973 }
 974
 975 bool DIARawSymbol::isMultipleInheritance() const {
 976   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMultipleInheritance);
 977 }
 978
 979 bool DIARawSymbol::isNaked() const {
 980   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isNaked);
 981 }
 982
 983 bool DIARawSymbol::isNested() const {
 984   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_nested);
 985 }
 986
 987 bool DIARawSymbol::isOptimizedAway() const {
 988   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isOptimizedAway);
 989 }
 990
 991 bool DIARawSymbol::isPacked() const {
 992   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_packed);
 993 }
 994
 995 bool DIARawSymbol::isPointerBasedOnSymbolValue() const {
 996   return PrivateGetDIAValue(Symbol,
 997                             &IDiaSymbol::get_isPointerBasedOnSymbolValue);
 998 }
 999
1000 bool DIARawSymbol::isPointerToDataMember() const {
1001   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToDataMember);
1002 }
1003
1004 bool DIARawSymbol::isPointerToMemberFunction() const {
1005   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToMemberFunction);
1006 }
1007
1008 bool DIARawSymbol::isPureVirtual() const {
1009   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_pure);
1010 }
1011
1012 bool DIARawSymbol::isRValueReference() const {
1013   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_RValueReference);
1014 }
1015
1016 bool DIARawSymbol::isRefUdt() const {
1017   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isRefUdt);
1018 }
1019
1020 bool DIARawSymbol::isReference() const {
1021   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_reference);
1022 }
1023
1024 bool DIARawSymbol::isRestrictedType() const {
1025   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_restrictedType);
1026 }
1027
1028 bool DIARawSymbol::isReturnValue() const {
1029   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isReturnValue);
1030 }
1031
1032 bool DIARawSymbol::isSafeBuffers() const {
1033   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSafeBuffers);
1034 }
1035
1036 bool DIARawSymbol::isScoped() const {
1037   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_scoped);
1038 }
1039
1040 bool DIARawSymbol::isSdl() const {
1041   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSdl);
1042 }
1043
1044 bool DIARawSymbol::isSingleInheritance() const {
1045   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSingleInheritance);
1046 }
1047
1048 bool DIARawSymbol::isSplitted() const {
1049   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSplitted);
1050 }
1051
1052 bool DIARawSymbol::isStatic() const {
1053   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStatic);
1054 }
1055
1056 bool DIARawSymbol::hasPrivateSymbols() const {
1057   // hasPrivateSymbols is the opposite of isStripped, but we expose
1058   // hasPrivateSymbols as a more intuitive interface.
1059   return !PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStripped);
1060 }
1061
1062 bool DIARawSymbol::isUnalignedType() const {
1063   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unalignedType);
1064 }
1065
1066 bool DIARawSymbol::isUnreached() const {
1067   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_notReached);
1068 }
1069
1070 bool DIARawSymbol::isValueUdt() const {
1071   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isValueUdt);
1072 }
1073
1074 bool DIARawSymbol::isVirtual() const {
1075   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtual);
1076 }
1077
1078 bool DIARawSymbol::isVirtualBaseClass() const {
1079   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseClass);
1080 }
1081
1082 bool DIARawSymbol::isVirtualInheritance() const {
1083   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isVirtualInheritance);
1084 }
1085
1086 bool DIARawSymbol::isVolatileType() const {
1087   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_volatileType);
1088 }
1089
1090 bool DIARawSymbol::wasInlined() const {
1091   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_wasInlined);
1092 }
1093
1094 std::string DIARawSymbol::getUnused() const {
1095   return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unused);
1096 }