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