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