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