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