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