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