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