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 {
VariantFromVARIANT(const VARIANT & V)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>
PrivateGetDIAValue(IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(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>
PrivateGetDIAValue(IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(ArgType *))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
PrivateGetDIAValue(IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(BSTR *))117 PrivateGetDIAValue(IDiaSymbol *Symbol,
118 HRESULT (__stdcall IDiaSymbol::*Method)(BSTR *)) {
119 return invokeBstrMethod(*Symbol, Method);
120 }
121
122 codeview::GUID
PrivateGetDIAValue(IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(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>
DumpDIAValueAs(llvm::raw_ostream & OS,int Indent,StringRef Name,IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(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
DumpDIAIdValue(llvm::raw_ostream & OS,int Indent,StringRef Name,IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(DWORD *),const IPDBSession & Session,PdbSymbolIdField FieldId,PdbSymbolIdField ShowFlags,PdbSymbolIdField RecurseFlags)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>
DumpDIAValue(llvm::raw_ostream & OS,int Indent,StringRef Name,IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(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
DumpDIAValue(llvm::raw_ostream & OS,int Indent,StringRef Name,IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(BSTR *))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
DumpDIAValue(llvm::raw_ostream & OS,int Indent,StringRef Name,IDiaSymbol * Symbol,HRESULT (__stdcall IDiaSymbol::* Method)(VARIANT *))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 {
operator <<(llvm::raw_ostream & OS,const GUID & G)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
DIARawSymbol(const DIASession & PDBSession,CComPtr<IDiaSymbol> DiaSymbol)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
dump(raw_ostream & OS,int Indent,PdbSymbolIdField ShowIdFields,PdbSymbolIdField RecurseIdFields) const219 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>
findChildren(PDB_SymType Type) const399 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>
findChildren(PDB_SymType Type,StringRef Name,PDB_NameSearchFlags Flags) const413 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>
findChildrenByAddr(PDB_SymType Type,StringRef Name,PDB_NameSearchFlags Flags,uint32_t Section,uint32_t Offset) const431 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>
findChildrenByVA(PDB_SymType Type,StringRef Name,PDB_NameSearchFlags Flags,uint64_t VA) const451 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>
findChildrenByRVA(PDB_SymType Type,StringRef Name,PDB_NameSearchFlags Flags,uint32_t RVA) const470 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>
findInlineFramesByAddr(uint32_t Section,uint32_t Offset) const488 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>
findInlineFramesByRVA(uint32_t RVA) const497 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>
findInlineFramesByVA(uint64_t VA) const506 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
findInlineeLines() const514 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>
findInlineeLinesByAddr(uint32_t Section,uint32_t Offset,uint32_t Length) const523 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>
findInlineeLinesByRVA(uint32_t RVA,uint32_t Length) const534 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>
findInlineeLinesByVA(uint64_t VA,uint32_t Length) const543 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
getDataBytes(llvm::SmallVector<uint8_t,32> & bytes) const551 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
getUndecoratedNameEx(PDB_UndnameFlags Flags) const563 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
getAccess() const576 PDB_MemberAccess DIARawSymbol::getAccess() const {
577 return PrivateGetDIAValue<DWORD, PDB_MemberAccess>(Symbol,
578 &IDiaSymbol::get_access);
579 }
580
getAddressOffset() const581 uint32_t DIARawSymbol::getAddressOffset() const {
582 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressOffset);
583 }
584
getAddressSection() const585 uint32_t DIARawSymbol::getAddressSection() const {
586 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressSection);
587 }
588
getAge() const589 uint32_t DIARawSymbol::getAge() const {
590 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_age);
591 }
592
getArrayIndexTypeId() const593 SymIndexId DIARawSymbol::getArrayIndexTypeId() const {
594 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_arrayIndexTypeId);
595 }
596
getBackEndVersion(VersionInfo & Version) const597 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
getBaseDataOffset() const604 uint32_t DIARawSymbol::getBaseDataOffset() const {
605 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataOffset);
606 }
607
getBaseDataSlot() const608 uint32_t DIARawSymbol::getBaseDataSlot() const {
609 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseDataSlot);
610 }
611
getBaseSymbolId() const612 SymIndexId DIARawSymbol::getBaseSymbolId() const {
613 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_baseSymbolId);
614 }
615
getBuiltinType() const616 PDB_BuiltinType DIARawSymbol::getBuiltinType() const {
617 return PrivateGetDIAValue<DWORD, PDB_BuiltinType>(Symbol,
618 &IDiaSymbol::get_baseType);
619 }
620
getBitPosition() const621 uint32_t DIARawSymbol::getBitPosition() const {
622 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_bitPosition);
623 }
624
getCallingConvention() const625 PDB_CallingConv DIARawSymbol::getCallingConvention() const {
626 return PrivateGetDIAValue<DWORD, PDB_CallingConv>(
627 Symbol, &IDiaSymbol::get_callingConvention);
628 }
629
getClassParentId() const630 SymIndexId DIARawSymbol::getClassParentId() const {
631 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_classParentId);
632 }
633
getCompilerName() const634 std::string DIARawSymbol::getCompilerName() const {
635 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerName);
636 }
637
getCount() const638 uint32_t DIARawSymbol::getCount() const {
639 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_count);
640 }
641
getCountLiveRanges() const642 uint32_t DIARawSymbol::getCountLiveRanges() const {
643 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_countLiveRanges);
644 }
645
getFrontEndVersion(VersionInfo & Version) const646 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
getLanguage() const653 PDB_Lang DIARawSymbol::getLanguage() const {
654 return PrivateGetDIAValue<DWORD, PDB_Lang>(Symbol, &IDiaSymbol::get_language);
655 }
656
getLexicalParentId() const657 SymIndexId DIARawSymbol::getLexicalParentId() const {
658 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lexicalParentId);
659 }
660
getLibraryName() const661 std::string DIARawSymbol::getLibraryName() const {
662 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_libraryName);
663 }
664
getLiveRangeStartAddressOffset() const665 uint32_t DIARawSymbol::getLiveRangeStartAddressOffset() const {
666 return PrivateGetDIAValue(Symbol,
667 &IDiaSymbol::get_liveRangeStartAddressOffset);
668 }
669
getLiveRangeStartAddressSection() const670 uint32_t DIARawSymbol::getLiveRangeStartAddressSection() const {
671 return PrivateGetDIAValue(Symbol,
672 &IDiaSymbol::get_liveRangeStartAddressSection);
673 }
674
getLiveRangeStartRelativeVirtualAddress() const675 uint32_t DIARawSymbol::getLiveRangeStartRelativeVirtualAddress() const {
676 return PrivateGetDIAValue(
677 Symbol, &IDiaSymbol::get_liveRangeStartRelativeVirtualAddress);
678 }
679
getLocalBasePointerRegisterId() const680 codeview::RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const {
681 return PrivateGetDIAValue<DWORD, codeview::RegisterId>(
682 Symbol, &IDiaSymbol::get_localBasePointerRegisterId);
683 }
684
getLowerBoundId() const685 SymIndexId DIARawSymbol::getLowerBoundId() const {
686 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_lowerBoundId);
687 }
688
getMemorySpaceKind() const689 uint32_t DIARawSymbol::getMemorySpaceKind() const {
690 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_memorySpaceKind);
691 }
692
getName() const693 std::string DIARawSymbol::getName() const {
694 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_name);
695 }
696
getNumberOfAcceleratorPointerTags() const697 uint32_t DIARawSymbol::getNumberOfAcceleratorPointerTags() const {
698 return PrivateGetDIAValue(Symbol,
699 &IDiaSymbol::get_numberOfAcceleratorPointerTags);
700 }
701
getNumberOfColumns() const702 uint32_t DIARawSymbol::getNumberOfColumns() const {
703 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfColumns);
704 }
705
getNumberOfModifiers() const706 uint32_t DIARawSymbol::getNumberOfModifiers() const {
707 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfModifiers);
708 }
709
getNumberOfRegisterIndices() const710 uint32_t DIARawSymbol::getNumberOfRegisterIndices() const {
711 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRegisterIndices);
712 }
713
getNumberOfRows() const714 uint32_t DIARawSymbol::getNumberOfRows() const {
715 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_numberOfRows);
716 }
717
getObjectFileName() const718 std::string DIARawSymbol::getObjectFileName() const {
719 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_objectFileName);
720 }
721
getOemId() const722 uint32_t DIARawSymbol::getOemId() const {
723 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemId);
724 }
725
getOemSymbolId() const726 SymIndexId DIARawSymbol::getOemSymbolId() const {
727 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_oemSymbolId);
728 }
729
getOffsetInUdt() const730 uint32_t DIARawSymbol::getOffsetInUdt() const {
731 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offsetInUdt);
732 }
733
getPlatform() const734 PDB_Cpu DIARawSymbol::getPlatform() const {
735 return PrivateGetDIAValue<DWORD, PDB_Cpu>(Symbol, &IDiaSymbol::get_platform);
736 }
737
getRank() const738 uint32_t DIARawSymbol::getRank() const {
739 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_rank);
740 }
741
getRegisterId() const742 codeview::RegisterId DIARawSymbol::getRegisterId() const {
743 return PrivateGetDIAValue<DWORD, codeview::RegisterId>(
744 Symbol, &IDiaSymbol::get_registerId);
745 }
746
getRegisterType() const747 uint32_t DIARawSymbol::getRegisterType() const {
748 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_registerType);
749 }
750
getRelativeVirtualAddress() const751 uint32_t DIARawSymbol::getRelativeVirtualAddress() const {
752 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_relativeVirtualAddress);
753 }
754
getSamplerSlot() const755 uint32_t DIARawSymbol::getSamplerSlot() const {
756 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_samplerSlot);
757 }
758
getSignature() const759 uint32_t DIARawSymbol::getSignature() const {
760 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_signature);
761 }
762
getSizeInUdt() const763 uint32_t DIARawSymbol::getSizeInUdt() const {
764 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sizeInUdt);
765 }
766
getSlot() const767 uint32_t DIARawSymbol::getSlot() const {
768 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_slot);
769 }
770
getSourceFileName() const771 std::string DIARawSymbol::getSourceFileName() const {
772 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_sourceFileName);
773 }
774
getSrcLineOnTypeDefn() const775 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
getStride() const783 uint32_t DIARawSymbol::getStride() const {
784 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_stride);
785 }
786
getSubTypeId() const787 SymIndexId DIARawSymbol::getSubTypeId() const {
788 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_subTypeId);
789 }
790
getSymbolsFileName() const791 std::string DIARawSymbol::getSymbolsFileName() const {
792 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symbolsFileName);
793 }
794
getSymIndexId() const795 SymIndexId DIARawSymbol::getSymIndexId() const {
796 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_symIndexId);
797 }
798
getTargetOffset() const799 uint32_t DIARawSymbol::getTargetOffset() const {
800 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetOffset);
801 }
802
getTargetRelativeVirtualAddress() const803 uint32_t DIARawSymbol::getTargetRelativeVirtualAddress() const {
804 return PrivateGetDIAValue(Symbol,
805 &IDiaSymbol::get_targetRelativeVirtualAddress);
806 }
807
getTargetVirtualAddress() const808 uint64_t DIARawSymbol::getTargetVirtualAddress() const {
809 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetVirtualAddress);
810 }
811
getTargetSection() const812 uint32_t DIARawSymbol::getTargetSection() const {
813 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_targetSection);
814 }
815
getTextureSlot() const816 uint32_t DIARawSymbol::getTextureSlot() const {
817 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_textureSlot);
818 }
819
getTimeStamp() const820 uint32_t DIARawSymbol::getTimeStamp() const {
821 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_timeStamp);
822 }
823
getToken() const824 uint32_t DIARawSymbol::getToken() const {
825 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_token);
826 }
827
getTypeId() const828 SymIndexId DIARawSymbol::getTypeId() const {
829 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_typeId);
830 }
831
getUavSlot() const832 uint32_t DIARawSymbol::getUavSlot() const {
833 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_uavSlot);
834 }
835
getUndecoratedName() const836 std::string DIARawSymbol::getUndecoratedName() const {
837 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_undecoratedName);
838 }
839
getUnmodifiedTypeId() const840 SymIndexId DIARawSymbol::getUnmodifiedTypeId() const {
841 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unmodifiedTypeId);
842 }
843
getUpperBoundId() const844 SymIndexId DIARawSymbol::getUpperBoundId() const {
845 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_upperBoundId);
846 }
847
getValue() const848 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
getVirtualBaseDispIndex() const857 uint32_t DIARawSymbol::getVirtualBaseDispIndex() const {
858 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseDispIndex);
859 }
860
getVirtualBaseOffset() const861 uint32_t DIARawSymbol::getVirtualBaseOffset() const {
862 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseOffset);
863 }
864
getVirtualTableShapeId() const865 SymIndexId DIARawSymbol::getVirtualTableShapeId() const {
866 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualTableShapeId);
867 }
868
869 std::unique_ptr<PDBSymbolTypeBuiltin>
getVirtualBaseTableType() const870 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
getDataKind() const881 PDB_DataKind DIARawSymbol::getDataKind() const {
882 return PrivateGetDIAValue<DWORD, PDB_DataKind>(Symbol,
883 &IDiaSymbol::get_dataKind);
884 }
885
getSymTag() const886 PDB_SymType DIARawSymbol::getSymTag() const {
887 return PrivateGetDIAValue<DWORD, PDB_SymType>(Symbol,
888 &IDiaSymbol::get_symTag);
889 }
890
getGuid() const891 codeview::GUID DIARawSymbol::getGuid() const {
892 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_guid);
893 }
894
getOffset() const895 int32_t DIARawSymbol::getOffset() const {
896 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_offset);
897 }
898
getThisAdjust() const899 int32_t DIARawSymbol::getThisAdjust() const {
900 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_thisAdjust);
901 }
902
getVirtualBasePointerOffset() const903 int32_t DIARawSymbol::getVirtualBasePointerOffset() const {
904 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBasePointerOffset);
905 }
906
getLocationType() const907 PDB_LocType DIARawSymbol::getLocationType() const {
908 return PrivateGetDIAValue<DWORD, PDB_LocType>(Symbol,
909 &IDiaSymbol::get_locationType);
910 }
911
getMachineType() const912 PDB_Machine DIARawSymbol::getMachineType() const {
913 return PrivateGetDIAValue<DWORD, PDB_Machine>(Symbol,
914 &IDiaSymbol::get_machineType);
915 }
916
getThunkOrdinal() const917 codeview::ThunkOrdinal DIARawSymbol::getThunkOrdinal() const {
918 return PrivateGetDIAValue<DWORD, codeview::ThunkOrdinal>(
919 Symbol, &IDiaSymbol::get_thunkOrdinal);
920 }
921
getLength() const922 uint64_t DIARawSymbol::getLength() const {
923 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_length);
924 }
925
getLiveRangeLength() const926 uint64_t DIARawSymbol::getLiveRangeLength() const {
927 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_liveRangeLength);
928 }
929
getVirtualAddress() const930 uint64_t DIARawSymbol::getVirtualAddress() const {
931 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualAddress);
932 }
933
getUdtKind() const934 PDB_UdtType DIARawSymbol::getUdtKind() const {
935 return PrivateGetDIAValue<DWORD, PDB_UdtType>(Symbol,
936 &IDiaSymbol::get_udtKind);
937 }
938
hasConstructor() const939 bool DIARawSymbol::hasConstructor() const {
940 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constructor);
941 }
942
hasCustomCallingConvention() const943 bool DIARawSymbol::hasCustomCallingConvention() const {
944 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_customCallingConvention);
945 }
946
hasFarReturn() const947 bool DIARawSymbol::hasFarReturn() const {
948 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_farReturn);
949 }
950
isCode() const951 bool DIARawSymbol::isCode() const {
952 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_code);
953 }
954
isCompilerGenerated() const955 bool DIARawSymbol::isCompilerGenerated() const {
956 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_compilerGenerated);
957 }
958
isConstType() const959 bool DIARawSymbol::isConstType() const {
960 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_constType);
961 }
962
isEditAndContinueEnabled() const963 bool DIARawSymbol::isEditAndContinueEnabled() const {
964 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_editAndContinueEnabled);
965 }
966
isFunction() const967 bool DIARawSymbol::isFunction() const {
968 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_function);
969 }
970
getAddressTaken() const971 bool DIARawSymbol::getAddressTaken() const {
972 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_addressTaken);
973 }
974
getNoStackOrdering() const975 bool DIARawSymbol::getNoStackOrdering() const {
976 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noStackOrdering);
977 }
978
hasAlloca() const979 bool DIARawSymbol::hasAlloca() const {
980 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAlloca);
981 }
982
hasAssignmentOperator() const983 bool DIARawSymbol::hasAssignmentOperator() const {
984 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasAssignmentOperator);
985 }
986
hasCTypes() const987 bool DIARawSymbol::hasCTypes() const {
988 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCTypes);
989 }
990
hasCastOperator() const991 bool DIARawSymbol::hasCastOperator() const {
992 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasCastOperator);
993 }
994
hasDebugInfo() const995 bool DIARawSymbol::hasDebugInfo() const {
996 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasDebugInfo);
997 }
998
hasEH() const999 bool DIARawSymbol::hasEH() const {
1000 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEH);
1001 }
1002
hasEHa() const1003 bool DIARawSymbol::hasEHa() const {
1004 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasEHa);
1005 }
1006
hasInlAsm() const1007 bool DIARawSymbol::hasInlAsm() const {
1008 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasInlAsm);
1009 }
1010
hasInlineAttribute() const1011 bool DIARawSymbol::hasInlineAttribute() const {
1012 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_inlSpec);
1013 }
1014
hasInterruptReturn() const1015 bool DIARawSymbol::hasInterruptReturn() const {
1016 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_interruptReturn);
1017 }
1018
hasFramePointer() const1019 bool DIARawSymbol::hasFramePointer() const {
1020 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_framePointerPresent);
1021 }
1022
hasLongJump() const1023 bool DIARawSymbol::hasLongJump() const {
1024 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasLongJump);
1025 }
1026
hasManagedCode() const1027 bool DIARawSymbol::hasManagedCode() const {
1028 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasManagedCode);
1029 }
1030
hasNestedTypes() const1031 bool DIARawSymbol::hasNestedTypes() const {
1032 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasNestedTypes);
1033 }
1034
hasNoInlineAttribute() const1035 bool DIARawSymbol::hasNoInlineAttribute() const {
1036 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noInline);
1037 }
1038
hasNoReturnAttribute() const1039 bool DIARawSymbol::hasNoReturnAttribute() const {
1040 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_noReturn);
1041 }
1042
hasOptimizedCodeDebugInfo() const1043 bool DIARawSymbol::hasOptimizedCodeDebugInfo() const {
1044 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_optimizedCodeDebugInfo);
1045 }
1046
hasOverloadedOperator() const1047 bool DIARawSymbol::hasOverloadedOperator() const {
1048 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_overloadedOperator);
1049 }
1050
hasSEH() const1051 bool DIARawSymbol::hasSEH() const {
1052 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSEH);
1053 }
1054
hasSecurityChecks() const1055 bool DIARawSymbol::hasSecurityChecks() const {
1056 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSecurityChecks);
1057 }
1058
hasSetJump() const1059 bool DIARawSymbol::hasSetJump() const {
1060 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_hasSetJump);
1061 }
1062
hasStrictGSCheck() const1063 bool DIARawSymbol::hasStrictGSCheck() const {
1064 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_strictGSCheck);
1065 }
1066
isAcceleratorGroupSharedLocal() const1067 bool DIARawSymbol::isAcceleratorGroupSharedLocal() const {
1068 return PrivateGetDIAValue(Symbol,
1069 &IDiaSymbol::get_isAcceleratorGroupSharedLocal);
1070 }
1071
isAcceleratorPointerTagLiveRange() const1072 bool DIARawSymbol::isAcceleratorPointerTagLiveRange() const {
1073 return PrivateGetDIAValue(Symbol,
1074 &IDiaSymbol::get_isAcceleratorPointerTagLiveRange);
1075 }
1076
isAcceleratorStubFunction() const1077 bool DIARawSymbol::isAcceleratorStubFunction() const {
1078 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAcceleratorStubFunction);
1079 }
1080
isAggregated() const1081 bool DIARawSymbol::isAggregated() const {
1082 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isAggregated);
1083 }
1084
isIntroVirtualFunction() const1085 bool DIARawSymbol::isIntroVirtualFunction() const {
1086 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intro);
1087 }
1088
isCVTCIL() const1089 bool DIARawSymbol::isCVTCIL() const {
1090 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCVTCIL);
1091 }
1092
isConstructorVirtualBase() const1093 bool DIARawSymbol::isConstructorVirtualBase() const {
1094 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isConstructorVirtualBase);
1095 }
1096
isCxxReturnUdt() const1097 bool DIARawSymbol::isCxxReturnUdt() const {
1098 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isCxxReturnUdt);
1099 }
1100
isDataAligned() const1101 bool DIARawSymbol::isDataAligned() const {
1102 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isDataAligned);
1103 }
1104
isHLSLData() const1105 bool DIARawSymbol::isHLSLData() const {
1106 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHLSLData);
1107 }
1108
isHotpatchable() const1109 bool DIARawSymbol::isHotpatchable() const {
1110 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isHotpatchable);
1111 }
1112
isIndirectVirtualBaseClass() const1113 bool DIARawSymbol::isIndirectVirtualBaseClass() const {
1114 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_indirectVirtualBaseClass);
1115 }
1116
isInterfaceUdt() const1117 bool DIARawSymbol::isInterfaceUdt() const {
1118 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isInterfaceUdt);
1119 }
1120
isIntrinsic() const1121 bool DIARawSymbol::isIntrinsic() const {
1122 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_intrinsic);
1123 }
1124
isLTCG() const1125 bool DIARawSymbol::isLTCG() const {
1126 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isLTCG);
1127 }
1128
isLocationControlFlowDependent() const1129 bool DIARawSymbol::isLocationControlFlowDependent() const {
1130 return PrivateGetDIAValue(Symbol,
1131 &IDiaSymbol::get_isLocationControlFlowDependent);
1132 }
1133
isMSILNetmodule() const1134 bool DIARawSymbol::isMSILNetmodule() const {
1135 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMSILNetmodule);
1136 }
1137
isMatrixRowMajor() const1138 bool DIARawSymbol::isMatrixRowMajor() const {
1139 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMatrixRowMajor);
1140 }
1141
isManagedCode() const1142 bool DIARawSymbol::isManagedCode() const {
1143 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_managed);
1144 }
1145
isMSILCode() const1146 bool DIARawSymbol::isMSILCode() const {
1147 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_msil);
1148 }
1149
isMultipleInheritance() const1150 bool DIARawSymbol::isMultipleInheritance() const {
1151 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isMultipleInheritance);
1152 }
1153
isNaked() const1154 bool DIARawSymbol::isNaked() const {
1155 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isNaked);
1156 }
1157
isNested() const1158 bool DIARawSymbol::isNested() const {
1159 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_nested);
1160 }
1161
isOptimizedAway() const1162 bool DIARawSymbol::isOptimizedAway() const {
1163 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isOptimizedAway);
1164 }
1165
isPacked() const1166 bool DIARawSymbol::isPacked() const {
1167 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_packed);
1168 }
1169
isPointerBasedOnSymbolValue() const1170 bool DIARawSymbol::isPointerBasedOnSymbolValue() const {
1171 return PrivateGetDIAValue(Symbol,
1172 &IDiaSymbol::get_isPointerBasedOnSymbolValue);
1173 }
1174
isPointerToDataMember() const1175 bool DIARawSymbol::isPointerToDataMember() const {
1176 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToDataMember);
1177 }
1178
isPointerToMemberFunction() const1179 bool DIARawSymbol::isPointerToMemberFunction() const {
1180 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isPointerToMemberFunction);
1181 }
1182
isPureVirtual() const1183 bool DIARawSymbol::isPureVirtual() const {
1184 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_pure);
1185 }
1186
isRValueReference() const1187 bool DIARawSymbol::isRValueReference() const {
1188 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_RValueReference);
1189 }
1190
isRefUdt() const1191 bool DIARawSymbol::isRefUdt() const {
1192 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isRefUdt);
1193 }
1194
isReference() const1195 bool DIARawSymbol::isReference() const {
1196 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_reference);
1197 }
1198
isRestrictedType() const1199 bool DIARawSymbol::isRestrictedType() const {
1200 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_restrictedType);
1201 }
1202
isReturnValue() const1203 bool DIARawSymbol::isReturnValue() const {
1204 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isReturnValue);
1205 }
1206
isSafeBuffers() const1207 bool DIARawSymbol::isSafeBuffers() const {
1208 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSafeBuffers);
1209 }
1210
isScoped() const1211 bool DIARawSymbol::isScoped() const {
1212 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_scoped);
1213 }
1214
isSdl() const1215 bool DIARawSymbol::isSdl() const {
1216 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSdl);
1217 }
1218
isSingleInheritance() const1219 bool DIARawSymbol::isSingleInheritance() const {
1220 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSingleInheritance);
1221 }
1222
isSplitted() const1223 bool DIARawSymbol::isSplitted() const {
1224 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isSplitted);
1225 }
1226
isStatic() const1227 bool DIARawSymbol::isStatic() const {
1228 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isStatic);
1229 }
1230
hasPrivateSymbols() const1231 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
isUnalignedType() const1237 bool DIARawSymbol::isUnalignedType() const {
1238 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unalignedType);
1239 }
1240
isUnreached() const1241 bool DIARawSymbol::isUnreached() const {
1242 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_notReached);
1243 }
1244
isValueUdt() const1245 bool DIARawSymbol::isValueUdt() const {
1246 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isValueUdt);
1247 }
1248
isVirtual() const1249 bool DIARawSymbol::isVirtual() const {
1250 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtual);
1251 }
1252
isVirtualBaseClass() const1253 bool DIARawSymbol::isVirtualBaseClass() const {
1254 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseClass);
1255 }
1256
isVirtualInheritance() const1257 bool DIARawSymbol::isVirtualInheritance() const {
1258 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_isVirtualInheritance);
1259 }
1260
isVolatileType() const1261 bool DIARawSymbol::isVolatileType() const {
1262 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_volatileType);
1263 }
1264
wasInlined() const1265 bool DIARawSymbol::wasInlined() const {
1266 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_wasInlined);
1267 }
1268
getUnused() const1269 std::string DIARawSymbol::getUnused() const {
1270 return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unused);
1271 }
1272