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