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(SrcBytes: SrcByteArray, Out&: Result8)) |
82 | Result.Value.String = nullptr; |
83 | Result.Value.String = new char[Result8.length() + 1]; |
84 | ::strcpy(dest: Result.Value.String, src: 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(SrcBytes: ByteArray, Out&: Result)) |
174 | dumpSymbolField(OS, Name, Value: 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, Value: 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(Stream&: OS, Style: "" ); |
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(SrcUTF8: Name, DstUTF16&: 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(SrcUTF8: Name, DstUTF16&: 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(SrcUTF8: Name, DstUTF16&: 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(SrcUTF8: Name, DstUTF16&: 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(SrcBytes: SrcByteArray, Out&: 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 | |