LLDB  mainline
PDBASTParser.cpp
Go to the documentation of this file.
1 //===-- PDBASTParser.cpp --------------------------------------------------===//
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 "PDBASTParser.h"
10 
11 #include "SymbolFilePDB.h"
12 
13 #include "clang/AST/CharUnits.h"
14 #include "clang/AST/Decl.h"
15 #include "clang/AST/DeclCXX.h"
16 
20 #include "lldb/Core/Declaration.h"
21 #include "lldb/Core/Module.h"
22 #include "lldb/Symbol/SymbolFile.h"
23 #include "lldb/Symbol/TypeMap.h"
24 #include "lldb/Symbol/TypeSystem.h"
25 
26 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
27 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
28 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
29 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
30 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
31 #include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
32 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
33 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
34 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
35 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
36 #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
37 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
38 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
39 
41 
42 using namespace lldb;
43 using namespace lldb_private;
44 using namespace llvm::pdb;
45 
46 static int TranslateUdtKind(PDB_UdtType pdb_kind) {
47  switch (pdb_kind) {
48  case PDB_UdtType::Class:
49  return clang::TTK_Class;
50  case PDB_UdtType::Struct:
51  return clang::TTK_Struct;
52  case PDB_UdtType::Union:
53  return clang::TTK_Union;
54  case PDB_UdtType::Interface:
55  return clang::TTK_Interface;
56  }
57  llvm_unreachable("unsuported PDB UDT type");
58 }
59 
60 static lldb::Encoding TranslateBuiltinEncoding(PDB_BuiltinType type) {
61  switch (type) {
62  case PDB_BuiltinType::Float:
64  case PDB_BuiltinType::Int:
65  case PDB_BuiltinType::Long:
66  case PDB_BuiltinType::Char:
67  return lldb::eEncodingSint;
68  case PDB_BuiltinType::Bool:
69  case PDB_BuiltinType::Char16:
70  case PDB_BuiltinType::Char32:
72  case PDB_BuiltinType::ULong:
73  case PDB_BuiltinType::HResult:
74  case PDB_BuiltinType::WCharT:
75  return lldb::eEncodingUint;
76  default:
78  }
79 }
80 
81 static lldb::Encoding TranslateEnumEncoding(PDB_VariantType type) {
82  switch (type) {
83  case PDB_VariantType::Int8:
84  case PDB_VariantType::Int16:
85  case PDB_VariantType::Int32:
86  case PDB_VariantType::Int64:
87  return lldb::eEncodingSint;
88 
89  case PDB_VariantType::UInt8:
90  case PDB_VariantType::UInt16:
91  case PDB_VariantType::UInt32:
92  case PDB_VariantType::UInt64:
93  return lldb::eEncodingUint;
94 
95  default:
96  break;
97  }
98 
99  return lldb::eEncodingSint;
100 }
101 
102 static CompilerType
104  const PDBSymbolTypeBuiltin &pdb_type,
105  Encoding encoding, uint32_t width) {
106  clang::ASTContext &ast = clang_ast.getASTContext();
107 
108  switch (pdb_type.getBuiltinType()) {
109  default:
110  break;
111  case PDB_BuiltinType::None:
112  return CompilerType();
113  case PDB_BuiltinType::Void:
114  return clang_ast.GetBasicType(eBasicTypeVoid);
115  case PDB_BuiltinType::Char:
116  return clang_ast.GetBasicType(eBasicTypeChar);
117  case PDB_BuiltinType::Bool:
118  return clang_ast.GetBasicType(eBasicTypeBool);
119  case PDB_BuiltinType::Long:
120  if (width == ast.getTypeSize(ast.LongTy))
121  return CompilerType(&clang_ast, ast.LongTy.getAsOpaquePtr());
122  if (width == ast.getTypeSize(ast.LongLongTy))
123  return CompilerType(&clang_ast, ast.LongLongTy.getAsOpaquePtr());
124  break;
125  case PDB_BuiltinType::ULong:
126  if (width == ast.getTypeSize(ast.UnsignedLongTy))
127  return CompilerType(&clang_ast, ast.UnsignedLongTy.getAsOpaquePtr());
128  if (width == ast.getTypeSize(ast.UnsignedLongLongTy))
129  return CompilerType(&clang_ast, ast.UnsignedLongLongTy.getAsOpaquePtr());
130  break;
131  case PDB_BuiltinType::WCharT:
132  if (width == ast.getTypeSize(ast.WCharTy))
133  return CompilerType(&clang_ast, ast.WCharTy.getAsOpaquePtr());
134  break;
135  case PDB_BuiltinType::Char16:
136  return CompilerType(&clang_ast, ast.Char16Ty.getAsOpaquePtr());
137  case PDB_BuiltinType::Char32:
138  return CompilerType(&clang_ast, ast.Char32Ty.getAsOpaquePtr());
139  case PDB_BuiltinType::Float:
140  // Note: types `long double` and `double` have same bit size in MSVC and
141  // there is no information in the PDB to distinguish them. So when falling
142  // back to default search, the compiler type of `long double` will be
143  // represented by the one generated for `double`.
144  break;
145  }
146  // If there is no match on PDB_BuiltinType, fall back to default search by
147  // encoding and width only
148  return clang_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, width);
149 }
150 
151 static ConstString GetPDBBuiltinTypeName(const PDBSymbolTypeBuiltin &pdb_type,
152  CompilerType &compiler_type) {
153  PDB_BuiltinType kind = pdb_type.getBuiltinType();
154  switch (kind) {
155  default:
156  break;
157  case PDB_BuiltinType::Currency:
158  return ConstString("CURRENCY");
159  case PDB_BuiltinType::Date:
160  return ConstString("DATE");
161  case PDB_BuiltinType::Variant:
162  return ConstString("VARIANT");
163  case PDB_BuiltinType::Complex:
164  return ConstString("complex");
165  case PDB_BuiltinType::Bitfield:
166  return ConstString("bitfield");
167  case PDB_BuiltinType::BSTR:
168  return ConstString("BSTR");
169  case PDB_BuiltinType::HResult:
170  return ConstString("HRESULT");
171  case PDB_BuiltinType::BCD:
172  return ConstString("BCD");
173  case PDB_BuiltinType::Char16:
174  return ConstString("char16_t");
175  case PDB_BuiltinType::Char32:
176  return ConstString("char32_t");
177  case PDB_BuiltinType::None:
178  return ConstString("...");
179  }
180  return compiler_type.GetTypeName();
181 }
182 
183 static bool GetDeclarationForSymbol(const PDBSymbol &symbol,
184  Declaration &decl) {
185  auto &raw_sym = symbol.getRawSymbol();
186  auto first_line_up = raw_sym.getSrcLineOnTypeDefn();
187 
188  if (!first_line_up) {
189  auto lines_up = symbol.getSession().findLineNumbersByAddress(
190  raw_sym.getVirtualAddress(), raw_sym.getLength());
191  if (!lines_up)
192  return false;
193  first_line_up = lines_up->getNext();
194  if (!first_line_up)
195  return false;
196  }
197  uint32_t src_file_id = first_line_up->getSourceFileId();
198  auto src_file_up = symbol.getSession().getSourceFileById(src_file_id);
199  if (!src_file_up)
200  return false;
201 
202  FileSpec spec(src_file_up->getFileName());
203  decl.SetFile(spec);
204  decl.SetColumn(first_line_up->getColumnNumber());
205  decl.SetLine(first_line_up->getLineNumber());
206  return true;
207 }
208 
209 static AccessType TranslateMemberAccess(PDB_MemberAccess access) {
210  switch (access) {
211  case PDB_MemberAccess::Private:
212  return eAccessPrivate;
213  case PDB_MemberAccess::Protected:
214  return eAccessProtected;
215  case PDB_MemberAccess::Public:
216  return eAccessPublic;
217  }
218  return eAccessNone;
219 }
220 
221 static AccessType GetDefaultAccessibilityForUdtKind(PDB_UdtType udt_kind) {
222  switch (udt_kind) {
223  case PDB_UdtType::Struct:
224  case PDB_UdtType::Union:
225  return eAccessPublic;
226  case PDB_UdtType::Class:
227  case PDB_UdtType::Interface:
228  return eAccessPrivate;
229  }
230  llvm_unreachable("unsupported PDB UDT type");
231 }
232 
233 static AccessType GetAccessibilityForUdt(const PDBSymbolTypeUDT &udt) {
234  AccessType access = TranslateMemberAccess(udt.getAccess());
235  if (access != lldb::eAccessNone || !udt.isNested())
236  return access;
237 
238  auto parent = udt.getClassParent();
239  if (!parent)
240  return lldb::eAccessNone;
241 
242  auto parent_udt = llvm::dyn_cast<PDBSymbolTypeUDT>(parent.get());
243  if (!parent_udt)
244  return lldb::eAccessNone;
245 
246  return GetDefaultAccessibilityForUdtKind(parent_udt->getUdtKind());
247 }
248 
249 static clang::MSInheritanceAttr::Spelling
250 GetMSInheritance(const PDBSymbolTypeUDT &udt) {
251  int base_count = 0;
252  bool has_virtual = false;
253 
254  auto bases_enum = udt.findAllChildren<PDBSymbolTypeBaseClass>();
255  if (bases_enum) {
256  while (auto base = bases_enum->getNext()) {
257  base_count++;
258  has_virtual |= base->isVirtualBaseClass();
259  }
260  }
261 
262  if (has_virtual)
263  return clang::MSInheritanceAttr::Keyword_virtual_inheritance;
264  if (base_count > 1)
265  return clang::MSInheritanceAttr::Keyword_multiple_inheritance;
266  return clang::MSInheritanceAttr::Keyword_single_inheritance;
267 }
268 
269 static std::unique_ptr<llvm::pdb::PDBSymbol>
270 GetClassOrFunctionParent(const llvm::pdb::PDBSymbol &symbol) {
271  const IPDBSession &session = symbol.getSession();
272  const IPDBRawSymbol &raw = symbol.getRawSymbol();
273  auto tag = symbol.getSymTag();
274 
275  // For items that are nested inside of a class, return the class that it is
276  // nested inside of.
277  // Note that only certain items can be nested inside of classes.
278  switch (tag) {
279  case PDB_SymType::Function:
280  case PDB_SymType::Data:
281  case PDB_SymType::UDT:
282  case PDB_SymType::Enum:
283  case PDB_SymType::FunctionSig:
284  case PDB_SymType::Typedef:
285  case PDB_SymType::BaseClass:
286  case PDB_SymType::VTable: {
287  auto class_parent_id = raw.getClassParentId();
288  if (auto class_parent = session.getSymbolById(class_parent_id))
289  return class_parent;
290  break;
291  }
292  default:
293  break;
294  }
295 
296  // Otherwise, if it is nested inside of a function, return the function.
297  // Note that only certain items can be nested inside of functions.
298  switch (tag) {
299  case PDB_SymType::Block:
300  case PDB_SymType::Data: {
301  auto lexical_parent_id = raw.getLexicalParentId();
302  auto lexical_parent = session.getSymbolById(lexical_parent_id);
303  if (!lexical_parent)
304  return nullptr;
305 
306  auto lexical_parent_tag = lexical_parent->getSymTag();
307  if (lexical_parent_tag == PDB_SymType::Function)
308  return lexical_parent;
309  if (lexical_parent_tag == PDB_SymType::Exe)
310  return nullptr;
311 
312  return GetClassOrFunctionParent(*lexical_parent);
313  }
314  default:
315  return nullptr;
316  }
317 }
318 
319 static clang::NamedDecl *
320 GetDeclFromContextByName(const clang::ASTContext &ast,
321  const clang::DeclContext &decl_context,
322  llvm::StringRef name) {
323  clang::IdentifierInfo &ident = ast.Idents.get(name);
324  clang::DeclarationName decl_name = ast.DeclarationNames.getIdentifier(&ident);
325  clang::DeclContext::lookup_result result = decl_context.lookup(decl_name);
326  if (result.empty())
327  return nullptr;
328 
329  return *result.begin();
330 }
331 
332 static bool IsAnonymousNamespaceName(llvm::StringRef name) {
333  return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
334 }
335 
336 static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc) {
337  switch (pdb_cc) {
338  case llvm::codeview::CallingConvention::NearC:
339  return clang::CC_C;
340  case llvm::codeview::CallingConvention::NearStdCall:
341  return clang::CC_X86StdCall;
342  case llvm::codeview::CallingConvention::NearFast:
343  return clang::CC_X86FastCall;
344  case llvm::codeview::CallingConvention::ThisCall:
345  return clang::CC_X86ThisCall;
346  case llvm::codeview::CallingConvention::NearVector:
347  return clang::CC_X86VectorCall;
348  case llvm::codeview::CallingConvention::NearPascal:
349  return clang::CC_X86Pascal;
350  default:
351  assert(false && "Unknown calling convention");
352  return clang::CC_C;
353  }
354 }
355 
357 
358 PDBASTParser::~PDBASTParser() = default;
359 
360 // DebugInfoASTParser interface
361 
362 lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
363  Declaration decl;
364  switch (type.getSymTag()) {
365  case PDB_SymType::BaseClass: {
366  auto symbol_file = m_ast.GetSymbolFile();
367  if (!symbol_file)
368  return nullptr;
369 
370  auto ty = symbol_file->ResolveTypeUID(type.getRawSymbol().getTypeId());
371  return ty ? ty->shared_from_this() : nullptr;
372  } break;
373  case PDB_SymType::UDT: {
374  auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&type);
375  assert(udt);
376 
377  // Note that, unnamed UDT being typedef-ed is generated as a UDT symbol
378  // other than a Typedef symbol in PDB. For example,
379  // typedef union { short Row; short Col; } Union;
380  // is generated as a named UDT in PDB:
381  // union Union { short Row; short Col; }
382  // Such symbols will be handled here.
383 
384  // Some UDT with trival ctor has zero length. Just ignore.
385  if (udt->getLength() == 0)
386  return nullptr;
387 
388  // Ignore unnamed-tag UDTs.
389  std::string name =
391  if (name.empty())
392  return nullptr;
393 
394  auto decl_context = GetDeclContextContainingSymbol(type);
395 
396  // Check if such an UDT already exists in the current context.
397  // This may occur with const or volatile types. There are separate type
398  // symbols in PDB for types with const or volatile modifiers, but we need
399  // to create only one declaration for them all.
400  Type::ResolveState type_resolve_state;
401  CompilerType clang_type = m_ast.GetTypeForIdentifier<clang::CXXRecordDecl>(
402  ConstString(name), decl_context);
403  if (!clang_type.IsValid()) {
404  auto access = GetAccessibilityForUdt(*udt);
405 
406  auto tag_type_kind = TranslateUdtKind(udt->getUdtKind());
407 
408  ClangASTMetadata metadata;
409  metadata.SetUserID(type.getSymIndexId());
410  metadata.SetIsDynamicCXXType(false);
411 
412  clang_type = m_ast.CreateRecordType(
413  decl_context, OptionalClangModuleID(), access, name, tag_type_kind,
414  lldb::eLanguageTypeC_plus_plus, &metadata);
415  assert(clang_type.IsValid());
416 
417  auto record_decl =
419  assert(record_decl);
420  m_uid_to_decl[type.getSymIndexId()] = record_decl;
421 
422  auto inheritance_attr = clang::MSInheritanceAttr::CreateImplicit(
424  record_decl->addAttr(inheritance_attr);
425 
426  TypeSystemClang::StartTagDeclarationDefinition(clang_type);
427 
428  auto children = udt->findAllChildren();
429  if (!children || children->getChildCount() == 0) {
430  // PDB does not have symbol of forwarder. We assume we get an udt w/o
431  // any fields. Just complete it at this point.
432  TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
433 
434  TypeSystemClang::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
435  false);
436 
437  type_resolve_state = Type::ResolveState::Full;
438  } else {
439  // Add the type to the forward declarations. It will help us to avoid
440  // an endless recursion in CompleteTypeFromUdt function.
441  m_forward_decl_to_uid[record_decl] = type.getSymIndexId();
442 
443  TypeSystemClang::SetHasExternalStorage(clang_type.GetOpaqueQualType(),
444  true);
445 
446  type_resolve_state = Type::ResolveState::Forward;
447  }
448  } else
449  type_resolve_state = Type::ResolveState::Forward;
450 
451  if (udt->isConstType())
452  clang_type = clang_type.AddConstModifier();
453 
454  if (udt->isVolatileType())
455  clang_type = clang_type.AddVolatileModifier();
456 
457  GetDeclarationForSymbol(type, decl);
458  return std::make_shared<lldb_private::Type>(
459  type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
460  udt->getLength(), nullptr, LLDB_INVALID_UID,
461  lldb_private::Type::eEncodingIsUID, decl, clang_type,
462  type_resolve_state);
463  } break;
464  case PDB_SymType::Enum: {
465  auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type);
466  assert(enum_type);
467 
468  std::string name =
469  std::string(MSVCUndecoratedNameParser::DropScope(enum_type->getName()));
470  auto decl_context = GetDeclContextContainingSymbol(type);
471  uint64_t bytes = enum_type->getLength();
472 
473  // Check if such an enum already exists in the current context
474  CompilerType ast_enum = m_ast.GetTypeForIdentifier<clang::EnumDecl>(
475  ConstString(name), decl_context);
476  if (!ast_enum.IsValid()) {
477  auto underlying_type_up = enum_type->getUnderlyingType();
478  if (!underlying_type_up)
479  return nullptr;
480 
481  lldb::Encoding encoding =
482  TranslateBuiltinEncoding(underlying_type_up->getBuiltinType());
483  // FIXME: Type of underlying builtin is always `Int`. We correct it with
484  // the very first enumerator's encoding if any.
485  auto first_child = enum_type->findOneChild<PDBSymbolData>();
486  if (first_child)
487  encoding = TranslateEnumEncoding(first_child->getValue().Type);
488 
489  CompilerType builtin_type;
490  if (bytes > 0)
492  m_ast, *underlying_type_up, encoding, bytes * 8);
493  else
494  builtin_type = m_ast.GetBasicType(eBasicTypeInt);
495 
496  // FIXME: PDB does not have information about scoped enumeration (Enum
497  // Class). Set it false for now.
498  bool isScoped = false;
499 
500  ast_enum = m_ast.CreateEnumerationType(name.c_str(), decl_context,
501  OptionalClangModuleID(), decl,
502  builtin_type, isScoped);
503 
504  auto enum_decl = TypeSystemClang::GetAsEnumDecl(ast_enum);
505  assert(enum_decl);
506  m_uid_to_decl[type.getSymIndexId()] = enum_decl;
507 
508  auto enum_values = enum_type->findAllChildren<PDBSymbolData>();
509  if (enum_values) {
510  while (auto enum_value = enum_values->getNext()) {
511  if (enum_value->getDataKind() != PDB_DataKind::Constant)
512  continue;
513  AddEnumValue(ast_enum, *enum_value);
514  }
515  }
516 
517  if (TypeSystemClang::StartTagDeclarationDefinition(ast_enum))
518  TypeSystemClang::CompleteTagDeclarationDefinition(ast_enum);
519  }
520 
521  if (enum_type->isConstType())
522  ast_enum = ast_enum.AddConstModifier();
523 
524  if (enum_type->isVolatileType())
525  ast_enum = ast_enum.AddVolatileModifier();
526 
527  GetDeclarationForSymbol(type, decl);
528  return std::make_shared<lldb_private::Type>(
529  type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), bytes,
532  } break;
533  case PDB_SymType::Typedef: {
534  auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type);
535  assert(type_def);
536 
537  SymbolFile *symbol_file = m_ast.GetSymbolFile();
538  if (!symbol_file)
539  return nullptr;
540 
541  lldb_private::Type *target_type =
542  symbol_file->ResolveTypeUID(type_def->getTypeId());
543  if (!target_type)
544  return nullptr;
545 
546  std::string name =
548  auto decl_ctx = GetDeclContextContainingSymbol(type);
549 
550  // Check if such a typedef already exists in the current context
551  CompilerType ast_typedef =
552  m_ast.GetTypeForIdentifier<clang::TypedefNameDecl>(ConstString(name),
553  decl_ctx);
554  if (!ast_typedef.IsValid()) {
555  CompilerType target_ast_type = target_type->GetFullCompilerType();
556 
557  ast_typedef = target_ast_type.CreateTypedef(
558  name.c_str(), m_ast.CreateDeclContext(decl_ctx), 0);
559  if (!ast_typedef)
560  return nullptr;
561 
562  auto typedef_decl = TypeSystemClang::GetAsTypedefDecl(ast_typedef);
563  assert(typedef_decl);
564  m_uid_to_decl[type.getSymIndexId()] = typedef_decl;
565  }
566 
567  if (type_def->isConstType())
568  ast_typedef = ast_typedef.AddConstModifier();
569 
570  if (type_def->isVolatileType())
571  ast_typedef = ast_typedef.AddVolatileModifier();
572 
573  GetDeclarationForSymbol(type, decl);
574  llvm::Optional<uint64_t> size;
575  if (type_def->getLength())
576  size = type_def->getLength();
577  return std::make_shared<lldb_private::Type>(
578  type_def->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
579  size, nullptr, target_type->GetID(),
582  } break;
583  case PDB_SymType::Function:
584  case PDB_SymType::FunctionSig: {
585  std::string name;
586  PDBSymbolTypeFunctionSig *func_sig = nullptr;
587  if (auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(&type)) {
588  if (pdb_func->isCompilerGenerated())
589  return nullptr;
590 
591  auto sig = pdb_func->getSignature();
592  if (!sig)
593  return nullptr;
594  func_sig = sig.release();
595  // Function type is named.
596  name = std::string(
597  MSVCUndecoratedNameParser::DropScope(pdb_func->getName()));
598  } else if (auto pdb_func_sig =
599  llvm::dyn_cast<PDBSymbolTypeFunctionSig>(&type)) {
600  func_sig = const_cast<PDBSymbolTypeFunctionSig *>(pdb_func_sig);
601  } else
602  llvm_unreachable("Unexpected PDB symbol!");
603 
604  auto arg_enum = func_sig->getArguments();
605  uint32_t num_args = arg_enum->getChildCount();
606  std::vector<CompilerType> arg_list;
607 
608  bool is_variadic = func_sig->isCVarArgs();
609  // Drop last variadic argument.
610  if (is_variadic)
611  --num_args;
612  for (uint32_t arg_idx = 0; arg_idx < num_args; arg_idx++) {
613  auto arg = arg_enum->getChildAtIndex(arg_idx);
614  if (!arg)
615  break;
616 
617  SymbolFile *symbol_file = m_ast.GetSymbolFile();
618  if (!symbol_file)
619  return nullptr;
620 
621  lldb_private::Type *arg_type =
622  symbol_file->ResolveTypeUID(arg->getSymIndexId());
623  // If there's some error looking up one of the dependent types of this
624  // function signature, bail.
625  if (!arg_type)
626  return nullptr;
627  CompilerType arg_ast_type = arg_type->GetFullCompilerType();
628  arg_list.push_back(arg_ast_type);
629  }
630  lldbassert(arg_list.size() <= num_args);
631 
632  auto pdb_return_type = func_sig->getReturnType();
633  SymbolFile *symbol_file = m_ast.GetSymbolFile();
634  if (!symbol_file)
635  return nullptr;
636 
637  lldb_private::Type *return_type =
638  symbol_file->ResolveTypeUID(pdb_return_type->getSymIndexId());
639  // If there's some error looking up one of the dependent types of this
640  // function signature, bail.
641  if (!return_type)
642  return nullptr;
643  CompilerType return_ast_type = return_type->GetFullCompilerType();
644  uint32_t type_quals = 0;
645  if (func_sig->isConstType())
646  type_quals |= clang::Qualifiers::Const;
647  if (func_sig->isVolatileType())
648  type_quals |= clang::Qualifiers::Volatile;
649  auto cc = TranslateCallingConvention(func_sig->getCallingConvention());
650  CompilerType func_sig_ast_type =
651  m_ast.CreateFunctionType(return_ast_type, arg_list.data(),
652  arg_list.size(), is_variadic, type_quals, cc);
653 
654  GetDeclarationForSymbol(type, decl);
655  return std::make_shared<lldb_private::Type>(
656  type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name),
657  llvm::None, nullptr, LLDB_INVALID_UID,
658  lldb_private::Type::eEncodingIsUID, decl, func_sig_ast_type,
660  } break;
661  case PDB_SymType::ArrayType: {
662  auto array_type = llvm::dyn_cast<PDBSymbolTypeArray>(&type);
663  assert(array_type);
664  uint32_t num_elements = array_type->getCount();
665  uint32_t element_uid = array_type->getElementTypeId();
666  llvm::Optional<uint64_t> bytes;
667  if (uint64_t size = array_type->getLength())
668  bytes = size;
669 
670  SymbolFile *symbol_file = m_ast.GetSymbolFile();
671  if (!symbol_file)
672  return nullptr;
673 
674  // If array rank > 0, PDB gives the element type at N=0. So element type
675  // will parsed in the order N=0, N=1,..., N=rank sequentially.
676  lldb_private::Type *element_type = symbol_file->ResolveTypeUID(element_uid);
677  if (!element_type)
678  return nullptr;
679 
680  CompilerType element_ast_type = element_type->GetForwardCompilerType();
681  // If element type is UDT, it needs to be complete.
682  if (TypeSystemClang::IsCXXClassType(element_ast_type) &&
683  !element_ast_type.GetCompleteType()) {
684  if (TypeSystemClang::StartTagDeclarationDefinition(element_ast_type)) {
685  TypeSystemClang::CompleteTagDeclarationDefinition(element_ast_type);
686  } else {
687  // We are not able to start defintion.
688  return nullptr;
689  }
690  }
691  CompilerType array_ast_type = m_ast.CreateArrayType(
692  element_ast_type, num_elements, /*is_gnu_vector*/ false);
693  TypeSP type_sp = std::make_shared<lldb_private::Type>(
694  array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
696  decl, array_ast_type, lldb_private::Type::ResolveState::Full);
697  type_sp->SetEncodingType(element_type);
698  return type_sp;
699  } break;
700  case PDB_SymType::BuiltinType: {
701  auto *builtin_type = llvm::dyn_cast<PDBSymbolTypeBuiltin>(&type);
702  assert(builtin_type);
703  PDB_BuiltinType builtin_kind = builtin_type->getBuiltinType();
704  if (builtin_kind == PDB_BuiltinType::None)
705  return nullptr;
706 
707  llvm::Optional<uint64_t> bytes;
708  if (uint64_t size = builtin_type->getLength())
709  bytes = size;
710  Encoding encoding = TranslateBuiltinEncoding(builtin_kind);
712  m_ast, *builtin_type, encoding, bytes.getValueOr(0) * 8);
713 
714  if (builtin_type->isConstType())
715  builtin_ast_type = builtin_ast_type.AddConstModifier();
716 
717  if (builtin_type->isVolatileType())
718  builtin_ast_type = builtin_ast_type.AddVolatileModifier();
719 
720  auto type_name = GetPDBBuiltinTypeName(*builtin_type, builtin_ast_type);
721 
722  return std::make_shared<lldb_private::Type>(
723  builtin_type->getSymIndexId(), m_ast.GetSymbolFile(), type_name, bytes,
725  builtin_ast_type, lldb_private::Type::ResolveState::Full);
726  } break;
727  case PDB_SymType::PointerType: {
728  auto *pointer_type = llvm::dyn_cast<PDBSymbolTypePointer>(&type);
729  assert(pointer_type);
730 
731  SymbolFile *symbol_file = m_ast.GetSymbolFile();
732  if (!symbol_file)
733  return nullptr;
734 
735  Type *pointee_type = symbol_file->ResolveTypeUID(
736  pointer_type->getPointeeType()->getSymIndexId());
737  if (!pointee_type)
738  return nullptr;
739 
740  if (pointer_type->isPointerToDataMember() ||
741  pointer_type->isPointerToMemberFunction()) {
742  auto class_parent_uid = pointer_type->getRawSymbol().getClassParentId();
743  auto class_parent_type = symbol_file->ResolveTypeUID(class_parent_uid);
744  assert(class_parent_type);
745 
746  CompilerType pointer_ast_type;
747  pointer_ast_type = TypeSystemClang::CreateMemberPointerType(
748  class_parent_type->GetLayoutCompilerType(),
749  pointee_type->GetForwardCompilerType());
750  assert(pointer_ast_type);
751 
752  return std::make_shared<lldb_private::Type>(
753  pointer_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
754  pointer_type->getLength(), nullptr, LLDB_INVALID_UID,
755  lldb_private::Type::eEncodingIsUID, decl, pointer_ast_type,
757  }
758 
759  CompilerType pointer_ast_type;
760  pointer_ast_type = pointee_type->GetFullCompilerType();
761  if (pointer_type->isReference())
762  pointer_ast_type = pointer_ast_type.GetLValueReferenceType();
763  else if (pointer_type->isRValueReference())
764  pointer_ast_type = pointer_ast_type.GetRValueReferenceType();
765  else
766  pointer_ast_type = pointer_ast_type.GetPointerType();
767 
768  if (pointer_type->isConstType())
769  pointer_ast_type = pointer_ast_type.AddConstModifier();
770 
771  if (pointer_type->isVolatileType())
772  pointer_ast_type = pointer_ast_type.AddVolatileModifier();
773 
774  if (pointer_type->isRestrictedType())
775  pointer_ast_type = pointer_ast_type.AddRestrictModifier();
776 
777  return std::make_shared<lldb_private::Type>(
778  pointer_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
779  pointer_type->getLength(), nullptr, LLDB_INVALID_UID,
780  lldb_private::Type::eEncodingIsUID, decl, pointer_ast_type,
782  } break;
783  default:
784  break;
785  }
786  return nullptr;
787 }
788 
790  lldb_private::CompilerType &compiler_type) {
791  if (GetClangASTImporter().CanImport(compiler_type))
792  return GetClangASTImporter().CompleteType(compiler_type);
793 
794  // Remove the type from the forward declarations to avoid
795  // an endless recursion for types like a linked list.
796  clang::CXXRecordDecl *record_decl =
797  m_ast.GetAsCXXRecordDecl(compiler_type.GetOpaqueQualType());
798  auto uid_it = m_forward_decl_to_uid.find(record_decl);
799  if (uid_it == m_forward_decl_to_uid.end())
800  return true;
801 
802  auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
803  if (!symbol_file)
804  return false;
805 
806  std::unique_ptr<PDBSymbol> symbol =
807  symbol_file->GetPDBSession().getSymbolById(uid_it->getSecond());
808  if (!symbol)
809  return false;
810 
811  m_forward_decl_to_uid.erase(uid_it);
812 
813  TypeSystemClang::SetHasExternalStorage(compiler_type.GetOpaqueQualType(),
814  false);
815 
816  switch (symbol->getSymTag()) {
817  case PDB_SymType::UDT: {
818  auto udt = llvm::dyn_cast<PDBSymbolTypeUDT>(symbol.get());
819  if (!udt)
820  return false;
821 
822  return CompleteTypeFromUDT(*symbol_file, compiler_type, *udt);
823  }
824  default:
825  llvm_unreachable("not a forward clang type decl!");
826  }
827 }
828 
829 clang::Decl *
830 PDBASTParser::GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) {
831  uint32_t sym_id = symbol.getSymIndexId();
832  auto it = m_uid_to_decl.find(sym_id);
833  if (it != m_uid_to_decl.end())
834  return it->second;
835 
836  auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
837  if (!symbol_file)
838  return nullptr;
839 
840  // First of all, check if the symbol is a member of a class. Resolve the full
841  // class type and return the declaration from the cache if so.
842  auto tag = symbol.getSymTag();
843  if (tag == PDB_SymType::Data || tag == PDB_SymType::Function) {
844  const IPDBSession &session = symbol.getSession();
845  const IPDBRawSymbol &raw = symbol.getRawSymbol();
846 
847  auto class_parent_id = raw.getClassParentId();
848  if (std::unique_ptr<PDBSymbol> class_parent =
849  session.getSymbolById(class_parent_id)) {
850  auto class_parent_type = symbol_file->ResolveTypeUID(class_parent_id);
851  if (!class_parent_type)
852  return nullptr;
853 
854  CompilerType class_parent_ct = class_parent_type->GetFullCompilerType();
855 
856  // Look a declaration up in the cache after completing the class
857  clang::Decl *decl = m_uid_to_decl.lookup(sym_id);
858  if (decl)
859  return decl;
860 
861  // A declaration was not found in the cache. It means that the symbol
862  // has the class parent, but the class doesn't have the symbol in its
863  // children list.
864  if (auto func = llvm::dyn_cast_or_null<PDBSymbolFunc>(&symbol)) {
865  // Try to find a class child method with the same RVA and use its
866  // declaration if found.
867  if (uint32_t rva = func->getRelativeVirtualAddress()) {
868  if (std::unique_ptr<ConcreteSymbolEnumerator<PDBSymbolFunc>>
869  methods_enum =
870  class_parent->findAllChildren<PDBSymbolFunc>()) {
871  while (std::unique_ptr<PDBSymbolFunc> method =
872  methods_enum->getNext()) {
873  if (method->getRelativeVirtualAddress() == rva) {
874  decl = m_uid_to_decl.lookup(method->getSymIndexId());
875  if (decl)
876  break;
877  }
878  }
879  }
880  }
881 
882  // If no class methods with the same RVA were found, then create a new
883  // method. It is possible for template methods.
884  if (!decl)
885  decl = AddRecordMethod(*symbol_file, class_parent_ct, *func);
886  }
887 
888  if (decl)
889  m_uid_to_decl[sym_id] = decl;
890 
891  return decl;
892  }
893  }
894 
895  // If we are here, then the symbol is not belonging to a class and is not
896  // contained in the cache. So create a declaration for it.
897  switch (symbol.getSymTag()) {
898  case PDB_SymType::Data: {
899  auto data = llvm::dyn_cast<PDBSymbolData>(&symbol);
900  assert(data);
901 
902  auto decl_context = GetDeclContextContainingSymbol(symbol);
903  assert(decl_context);
904 
905  // May be the current context is a class really, but we haven't found
906  // any class parent. This happens e.g. in the case of class static
907  // variables - they has two symbols, one is a child of the class when
908  // another is a child of the exe. So always complete the parent and use
909  // an existing declaration if possible.
910  if (auto parent_decl = llvm::dyn_cast_or_null<clang::TagDecl>(decl_context))
911  m_ast.GetCompleteDecl(parent_decl);
912 
913  std::string name =
915 
916  // Check if the current context already contains the symbol with the name.
917  clang::Decl *decl =
918  GetDeclFromContextByName(m_ast.getASTContext(), *decl_context, name);
919  if (!decl) {
920  auto type = symbol_file->ResolveTypeUID(data->getTypeId());
921  if (!type)
922  return nullptr;
923 
925  decl_context, OptionalClangModuleID(), name.c_str(),
926  ClangUtil::GetQualType(type->GetLayoutCompilerType()));
927  }
928 
929  m_uid_to_decl[sym_id] = decl;
930 
931  return decl;
932  }
933  case PDB_SymType::Function: {
934  auto func = llvm::dyn_cast<PDBSymbolFunc>(&symbol);
935  assert(func);
936 
937  auto decl_context = GetDeclContextContainingSymbol(symbol);
938  assert(decl_context);
939 
940  std::string name =
942 
943  Type *type = symbol_file->ResolveTypeUID(sym_id);
944  if (!type)
945  return nullptr;
946 
947  auto storage = func->isStatic() ? clang::StorageClass::SC_Static
948  : clang::StorageClass::SC_None;
949 
950  auto decl = m_ast.CreateFunctionDeclaration(
951  decl_context, OptionalClangModuleID(), name,
952  type->GetForwardCompilerType(), storage, func->hasInlineAttribute());
953 
954  std::vector<clang::ParmVarDecl *> params;
955  if (std::unique_ptr<PDBSymbolTypeFunctionSig> sig = func->getSignature()) {
957  arg_enum = sig->findAllChildren<PDBSymbolTypeFunctionArg>()) {
958  while (std::unique_ptr<PDBSymbolTypeFunctionArg> arg =
959  arg_enum->getNext()) {
960  Type *arg_type = symbol_file->ResolveTypeUID(arg->getTypeId());
961  if (!arg_type)
962  continue;
963 
964  clang::ParmVarDecl *param = m_ast.CreateParameterDeclaration(
965  decl, OptionalClangModuleID(), nullptr,
966  arg_type->GetForwardCompilerType(), clang::SC_None, true);
967  if (param)
968  params.push_back(param);
969  }
970  }
971  }
972  if (params.size())
973  m_ast.SetFunctionParameters(decl, params);
974 
975  m_uid_to_decl[sym_id] = decl;
976 
977  return decl;
978  }
979  default: {
980  // It's not a variable and not a function, check if it's a type
981  Type *type = symbol_file->ResolveTypeUID(sym_id);
982  if (!type)
983  return nullptr;
984 
985  return m_uid_to_decl.lookup(sym_id);
986  }
987  }
988 }
989 
990 clang::DeclContext *
991 PDBASTParser::GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) {
992  if (symbol.getSymTag() == PDB_SymType::Function) {
993  clang::DeclContext *result =
994  llvm::dyn_cast_or_null<clang::FunctionDecl>(GetDeclForSymbol(symbol));
995 
996  if (result)
997  m_decl_context_to_uid[result] = symbol.getSymIndexId();
998 
999  return result;
1000  }
1001 
1002  auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
1003  if (!symbol_file)
1004  return nullptr;
1005 
1006  auto type = symbol_file->ResolveTypeUID(symbol.getSymIndexId());
1007  if (!type)
1008  return nullptr;
1009 
1010  clang::DeclContext *result =
1011  m_ast.GetDeclContextForType(type->GetForwardCompilerType());
1012 
1013  if (result)
1014  m_decl_context_to_uid[result] = symbol.getSymIndexId();
1015 
1016  return result;
1017 }
1018 
1020  const llvm::pdb::PDBSymbol &symbol) {
1021  auto parent = GetClassOrFunctionParent(symbol);
1022  while (parent) {
1023  if (auto parent_context = GetDeclContextForSymbol(*parent))
1024  return parent_context;
1025 
1026  parent = GetClassOrFunctionParent(*parent);
1027  }
1028 
1029  // We can't find any class or function parent of the symbol. So analyze
1030  // the full symbol name. The symbol may be belonging to a namespace
1031  // or function (or even to a class if it's e.g. a static variable symbol).
1032 
1033  // TODO: Make clang to emit full names for variables in namespaces
1034  // (as MSVC does)
1035 
1036  std::string name(symbol.getRawSymbol().getName());
1037  MSVCUndecoratedNameParser parser(name);
1038  llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
1039  if (specs.empty())
1040  return m_ast.GetTranslationUnitDecl();
1041 
1042  auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
1043  if (!symbol_file)
1044  return m_ast.GetTranslationUnitDecl();
1045 
1046  auto global = symbol_file->GetPDBSession().getGlobalScope();
1047  if (!global)
1048  return m_ast.GetTranslationUnitDecl();
1049 
1050  bool has_type_or_function_parent = false;
1051  clang::DeclContext *curr_context = m_ast.GetTranslationUnitDecl();
1052  for (std::size_t i = 0; i < specs.size() - 1; i++) {
1053  // Check if there is a function or a type with the current context's name.
1054  if (std::unique_ptr<IPDBEnumSymbols> children_enum = global->findChildren(
1055  PDB_SymType::None, specs[i].GetFullName(), NS_CaseSensitive)) {
1056  while (IPDBEnumChildren<PDBSymbol>::ChildTypePtr child =
1057  children_enum->getNext()) {
1058  if (clang::DeclContext *child_context =
1059  GetDeclContextForSymbol(*child)) {
1060  // Note that `GetDeclContextForSymbol' retrieves
1061  // a declaration context for functions and types only,
1062  // so if we are here then `child_context' is guaranteed
1063  // a function or a type declaration context.
1064  has_type_or_function_parent = true;
1065  curr_context = child_context;
1066  }
1067  }
1068  }
1069 
1070  // If there were no functions or types above then retrieve a namespace with
1071  // the current context's name. There can be no namespaces inside a function
1072  // or a type. We check it to avoid fake namespaces such as `__l2':
1073  // `N0::N1::CClass::PrivateFunc::__l2::InnerFuncStruct'
1074  if (!has_type_or_function_parent) {
1075  std::string namespace_name = std::string(specs[i].GetBaseName());
1076  const char *namespace_name_c_str =
1077  IsAnonymousNamespaceName(namespace_name) ? nullptr
1078  : namespace_name.data();
1079  clang::NamespaceDecl *namespace_decl =
1081  namespace_name_c_str, curr_context, OptionalClangModuleID());
1082 
1083  m_parent_to_namespaces[curr_context].insert(namespace_decl);
1084  m_namespaces.insert(namespace_decl);
1085 
1086  curr_context = namespace_decl;
1087  }
1088  }
1089 
1090  return curr_context;
1091 }
1092 
1094  const clang::DeclContext *decl_context) {
1095  auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
1096  if (!symbol_file)
1097  return;
1098 
1099  IPDBSession &session = symbol_file->GetPDBSession();
1100  auto symbol_up =
1101  session.getSymbolById(m_decl_context_to_uid.lookup(decl_context));
1102  auto global_up = session.getGlobalScope();
1103 
1104  PDBSymbol *symbol;
1105  if (symbol_up)
1106  symbol = symbol_up.get();
1107  else if (global_up)
1108  symbol = global_up.get();
1109  else
1110  return;
1111 
1112  if (auto children = symbol->findAllChildren())
1113  while (auto child = children->getNext())
1114  GetDeclForSymbol(*child);
1115 }
1116 
1117 clang::NamespaceDecl *
1118 PDBASTParser::FindNamespaceDecl(const clang::DeclContext *parent,
1119  llvm::StringRef name) {
1120  NamespacesSet *set;
1121  if (parent) {
1122  auto pit = m_parent_to_namespaces.find(parent);
1123  if (pit == m_parent_to_namespaces.end())
1124  return nullptr;
1125 
1126  set = &pit->second;
1127  } else {
1128  set = &m_namespaces;
1129  }
1130  assert(set);
1131 
1132  for (clang::NamespaceDecl *namespace_decl : *set)
1133  if (namespace_decl->getName().equals(name))
1134  return namespace_decl;
1135 
1136  for (clang::NamespaceDecl *namespace_decl : *set)
1137  if (namespace_decl->isAnonymousNamespace())
1138  return FindNamespaceDecl(namespace_decl, name);
1139 
1140  return nullptr;
1141 }
1142 
1144  const PDBSymbolData &enum_value) {
1145  Declaration decl;
1146  Variant v = enum_value.getValue();
1147  std::string name =
1148  std::string(MSVCUndecoratedNameParser::DropScope(enum_value.getName()));
1149  int64_t raw_value;
1150  switch (v.Type) {
1151  case PDB_VariantType::Int8:
1152  raw_value = v.Value.Int8;
1153  break;
1154  case PDB_VariantType::Int16:
1155  raw_value = v.Value.Int16;
1156  break;
1157  case PDB_VariantType::Int32:
1158  raw_value = v.Value.Int32;
1159  break;
1160  case PDB_VariantType::Int64:
1161  raw_value = v.Value.Int64;
1162  break;
1163  case PDB_VariantType::UInt8:
1164  raw_value = v.Value.UInt8;
1165  break;
1166  case PDB_VariantType::UInt16:
1167  raw_value = v.Value.UInt16;
1168  break;
1169  case PDB_VariantType::UInt32:
1170  raw_value = v.Value.UInt32;
1171  break;
1172  case PDB_VariantType::UInt64:
1173  raw_value = v.Value.UInt64;
1174  break;
1175  default:
1176  return false;
1177  }
1178  CompilerType underlying_type = m_ast.GetEnumerationIntegerType(enum_type);
1179  uint32_t byte_size = m_ast.getASTContext().getTypeSize(
1180  ClangUtil::GetQualType(underlying_type));
1181  auto enum_constant_decl = m_ast.AddEnumerationValueToEnumerationType(
1182  enum_type, decl, name.c_str(), raw_value, byte_size * 8);
1183  if (!enum_constant_decl)
1184  return false;
1185 
1186  m_uid_to_decl[enum_value.getSymIndexId()] = enum_constant_decl;
1187 
1188  return true;
1189 }
1190 
1192  lldb_private::SymbolFile &symbol_file,
1193  lldb_private::CompilerType &compiler_type,
1194  llvm::pdb::PDBSymbolTypeUDT &udt) {
1195  ClangASTImporter::LayoutInfo layout_info;
1196  layout_info.bit_size = udt.getLength() * 8;
1197 
1198  auto nested_enums = udt.findAllChildren<PDBSymbolTypeUDT>();
1199  if (nested_enums)
1200  while (auto nested = nested_enums->getNext())
1201  symbol_file.ResolveTypeUID(nested->getSymIndexId());
1202 
1203  auto bases_enum = udt.findAllChildren<PDBSymbolTypeBaseClass>();
1204  if (bases_enum)
1205  AddRecordBases(symbol_file, compiler_type,
1206  TranslateUdtKind(udt.getUdtKind()), *bases_enum,
1207  layout_info);
1208 
1209  auto members_enum = udt.findAllChildren<PDBSymbolData>();
1210  if (members_enum)
1211  AddRecordMembers(symbol_file, compiler_type, *members_enum, layout_info);
1212 
1213  auto methods_enum = udt.findAllChildren<PDBSymbolFunc>();
1214  if (methods_enum)
1215  AddRecordMethods(symbol_file, compiler_type, *methods_enum);
1216 
1218  TypeSystemClang::BuildIndirectFields(compiler_type);
1219  TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type);
1220 
1221  clang::CXXRecordDecl *record_decl =
1222  m_ast.GetAsCXXRecordDecl(compiler_type.GetOpaqueQualType());
1223  if (!record_decl)
1224  return static_cast<bool>(compiler_type);
1225 
1226  GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
1227 
1228  return static_cast<bool>(compiler_type);
1229 }
1230 
1232  lldb_private::SymbolFile &symbol_file,
1233  lldb_private::CompilerType &record_type,
1234  PDBDataSymbolEnumerator &members_enum,
1236  while (auto member = members_enum.getNext()) {
1237  if (member->isCompilerGenerated())
1238  continue;
1239 
1240  auto member_name = member->getName();
1241 
1242  auto member_type = symbol_file.ResolveTypeUID(member->getTypeId());
1243  if (!member_type)
1244  continue;
1245 
1246  auto member_comp_type = member_type->GetLayoutCompilerType();
1247  if (!member_comp_type.GetCompleteType()) {
1248  symbol_file.GetObjectFile()->GetModule()->ReportError(
1249  ":: Class '%s' has a member '%s' of type '%s' "
1250  "which does not have a complete definition.",
1251  record_type.GetTypeName().GetCString(), member_name.c_str(),
1252  member_comp_type.GetTypeName().GetCString());
1253  if (TypeSystemClang::StartTagDeclarationDefinition(member_comp_type))
1254  TypeSystemClang::CompleteTagDeclarationDefinition(member_comp_type);
1255  }
1256 
1257  auto access = TranslateMemberAccess(member->getAccess());
1258 
1259  switch (member->getDataKind()) {
1260  case PDB_DataKind::Member: {
1261  auto location_type = member->getLocationType();
1262 
1263  auto bit_size = member->getLength();
1264  if (location_type == PDB_LocType::ThisRel)
1265  bit_size *= 8;
1266 
1267  auto decl = TypeSystemClang::AddFieldToRecordType(
1268  record_type, member_name.c_str(), member_comp_type, access, bit_size);
1269  if (!decl)
1270  continue;
1271 
1272  m_uid_to_decl[member->getSymIndexId()] = decl;
1273 
1274  auto offset = member->getOffset() * 8;
1275  if (location_type == PDB_LocType::BitField)
1276  offset += member->getBitPosition();
1277 
1278  layout_info.field_offsets.insert(std::make_pair(decl, offset));
1279 
1280  break;
1281  }
1282  case PDB_DataKind::StaticMember: {
1283  auto decl = TypeSystemClang::AddVariableToRecordType(
1284  record_type, member_name.c_str(), member_comp_type, access);
1285  if (!decl)
1286  continue;
1287 
1288  // Static constant members may be a const[expr] declaration.
1289  // Query the symbol's value as the variable initializer if valid.
1290  if (member_comp_type.IsConst()) {
1291  auto value = member->getValue();
1292  clang::QualType qual_type = decl->getType();
1293  unsigned type_width = m_ast.getASTContext().getIntWidth(qual_type);
1294  unsigned constant_width = value.getBitWidth();
1295 
1296  if (qual_type->isIntegralOrEnumerationType()) {
1297  if (type_width >= constant_width) {
1298  TypeSystemClang::SetIntegerInitializerForVariable(
1299  decl, value.toAPSInt().extOrTrunc(type_width));
1300  } else {
1302  "Class '{0}' has a member '{1}' of type '{2}' ({3} bits) "
1303  "which resolves to a wider constant value ({4} bits). "
1304  "Ignoring constant.",
1305  record_type.GetTypeName(), member_name,
1306  member_comp_type.GetTypeName(), type_width,
1307  constant_width);
1308  }
1309  } else {
1310  switch (member_comp_type.GetBasicTypeEnumeration()) {
1311  case lldb::eBasicTypeFloat:
1314  if (type_width == constant_width) {
1315  TypeSystemClang::SetFloatingInitializerForVariable(
1316  decl, value.toAPFloat());
1317  decl->setConstexpr(true);
1318  } else {
1320  "Class '{0}' has a member '{1}' of type '{2}' ({3} "
1321  "bits) which resolves to a constant value of mismatched "
1322  "width ({4} bits). Ignoring constant.",
1323  record_type.GetTypeName(), member_name,
1324  member_comp_type.GetTypeName(), type_width,
1325  constant_width);
1326  }
1327  break;
1328  default:
1329  break;
1330  }
1331  }
1332  }
1333 
1334  m_uid_to_decl[member->getSymIndexId()] = decl;
1335 
1336  break;
1337  }
1338  default:
1339  llvm_unreachable("unsupported PDB data kind");
1340  }
1341  }
1342 }
1343 
1345  lldb_private::SymbolFile &symbol_file,
1346  lldb_private::CompilerType &record_type, int record_kind,
1347  PDBBaseClassSymbolEnumerator &bases_enum,
1348  lldb_private::ClangASTImporter::LayoutInfo &layout_info) const {
1349  std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> base_classes;
1350 
1351  while (auto base = bases_enum.getNext()) {
1352  auto base_type = symbol_file.ResolveTypeUID(base->getTypeId());
1353  if (!base_type)
1354  continue;
1355 
1356  auto base_comp_type = base_type->GetFullCompilerType();
1357  if (!base_comp_type.GetCompleteType()) {
1358  symbol_file.GetObjectFile()->GetModule()->ReportError(
1359  ":: Class '%s' has a base class '%s' "
1360  "which does not have a complete definition.",
1361  record_type.GetTypeName().GetCString(),
1362  base_comp_type.GetTypeName().GetCString());
1363  if (TypeSystemClang::StartTagDeclarationDefinition(base_comp_type))
1364  TypeSystemClang::CompleteTagDeclarationDefinition(base_comp_type);
1365  }
1366 
1367  auto access = TranslateMemberAccess(base->getAccess());
1368 
1369  auto is_virtual = base->isVirtualBaseClass();
1370 
1371  std::unique_ptr<clang::CXXBaseSpecifier> base_spec =
1372  m_ast.CreateBaseClassSpecifier(base_comp_type.GetOpaqueQualType(),
1373  access, is_virtual,
1374  record_kind == clang::TTK_Class);
1375  lldbassert(base_spec);
1376 
1377  base_classes.push_back(std::move(base_spec));
1378 
1379  if (is_virtual)
1380  continue;
1381 
1382  auto decl = m_ast.GetAsCXXRecordDecl(base_comp_type.GetOpaqueQualType());
1383  if (!decl)
1384  continue;
1385 
1386  auto offset = clang::CharUnits::fromQuantity(base->getOffset());
1387  layout_info.base_offsets.insert(std::make_pair(decl, offset));
1388  }
1389 
1391  std::move(base_classes));
1392 }
1393 
1395  lldb_private::CompilerType &record_type,
1396  PDBFuncSymbolEnumerator &methods_enum) {
1397  while (std::unique_ptr<PDBSymbolFunc> method = methods_enum.getNext())
1398  if (clang::CXXMethodDecl *decl =
1399  AddRecordMethod(symbol_file, record_type, *method))
1400  m_uid_to_decl[method->getSymIndexId()] = decl;
1401 }
1402 
1403 clang::CXXMethodDecl *
1405  lldb_private::CompilerType &record_type,
1406  const llvm::pdb::PDBSymbolFunc &method) const {
1407  std::string name =
1409 
1410  Type *method_type = symbol_file.ResolveTypeUID(method.getSymIndexId());
1411  // MSVC specific __vecDelDtor.
1412  if (!method_type)
1413  return nullptr;
1414 
1415  CompilerType method_comp_type = method_type->GetFullCompilerType();
1416  if (!method_comp_type.GetCompleteType()) {
1417  symbol_file.GetObjectFile()->GetModule()->ReportError(
1418  ":: Class '%s' has a method '%s' whose type cannot be completed.",
1419  record_type.GetTypeName().GetCString(),
1420  method_comp_type.GetTypeName().GetCString());
1421  if (TypeSystemClang::StartTagDeclarationDefinition(method_comp_type))
1422  TypeSystemClang::CompleteTagDeclarationDefinition(method_comp_type);
1423  }
1424 
1425  AccessType access = TranslateMemberAccess(method.getAccess());
1426  if (access == eAccessNone)
1427  access = eAccessPublic;
1428 
1429  // TODO: get mangled name for the method.
1431  record_type.GetOpaqueQualType(), name.c_str(),
1432  /*mangled_name*/ nullptr, method_comp_type, access, method.isVirtual(),
1433  method.isStatic(), method.hasInlineAttribute(),
1434  /*is_explicit*/ false, // FIXME: Need this field in CodeView.
1435  /*is_attr_used*/ false,
1436  /*is_artificial*/ method.isCompilerGenerated());
1437 }
lldb_private::Declaration::SetLine
void SetLine(uint32_t line)
Set accessor for the declaration line number.
Definition: Declaration.h:170
lldb_private::ClangASTImporter::LayoutInfo::field_offsets
llvm::DenseMap< const clang::FieldDecl *, uint64_t > field_offsets
Definition: ClangASTImporter.h:73
TranslateEnumEncoding
static lldb::Encoding TranslateEnumEncoding(PDB_VariantType type)
Definition: PDBASTParser.cpp:81
PDBASTParser::GetDeclForSymbol
clang::Decl * GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol)
Definition: PDBASTParser.cpp:830
SymbolFilePDB.h
SymbolFilePDB
Definition: SymbolFilePDB.h:24
lldb_private::TypeSystemClang::CreateParameterDeclaration
clang::ParmVarDecl * CreateParameterDeclaration(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, const char *name, const CompilerType &param_type, int storage, bool add_decl=false)
Definition: TypeSystemClang.cpp:2195
lldb_private::SymbolFile
Definition: SymbolFile.h:37
lldb_private::TypeSystemClang::TransferBaseClasses
bool TransferBaseClasses(lldb::opaque_compiler_type_t type, std::vector< std::unique_ptr< clang::CXXBaseSpecifier >> bases)
Definition: TypeSystemClang.cpp:7715
lldb_private::TypeSystemClang::getASTContext
clang::ASTContext & getASTContext()
Returns the clang::ASTContext instance managed by this TypeSystemClang.
Definition: TypeSystemClang.cpp:688
GetDeclarationForSymbol
static bool GetDeclarationForSymbol(const PDBSymbol &symbol, Declaration &decl)
Definition: PDBASTParser.cpp:183
lldb_private::TypeSystemClang::CreateDeclContext
CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx)
Creates a CompilerDeclContext from the given DeclContext with the current TypeSystemClang instance as...
Definition: TypeSystemClang.cpp:1204
lldb::eBasicTypeBool
@ eBasicTypeBool
Definition: lldb-enumerations.h:762
lldb::eAccessProtected
@ eAccessProtected
Definition: lldb-enumerations.h:511
lldb_private::TypeSystemClang::CreateFunctionType
CompilerType CreateFunctionType(const CompilerType &result_type, const CompilerType *args, unsigned num_args, bool is_variadic, unsigned type_quals, clang::CallingConv cc=clang::CC_C)
Definition: TypeSystemClang.cpp:2157
TypeMap.h
PDBASTParser::GetClangASTImporter
lldb_private::ClangASTImporter & GetClangASTImporter()
Definition: PDBASTParser.h:63
lldb_private::Type::eEncodingIsTypedefUID
@ eEncodingIsTypedefUID
This type is pointer to a type whose UID is m_encoding_uid.
Definition: Type.h:77
SymbolFilePDB::GetPDBSession
llvm::pdb::IPDBSession & GetPDBSession()
Definition: SymbolFilePDB.cpp:1716
GetPDBBuiltinTypeName
static ConstString GetPDBBuiltinTypeName(const PDBSymbolTypeBuiltin &pdb_type, CompilerType &compiler_type)
Definition: PDBASTParser.cpp:151
MSVCUndecoratedNameParser
Definition: MSVCUndecoratedNameParser.h:31
lldb_private::TypeSystemClang::CreateFunctionDeclaration
clang::FunctionDecl * CreateFunctionDeclaration(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, llvm::StringRef name, const CompilerType &function_Type, clang::StorageClass storage, bool is_inline)
Definition: TypeSystemClang.cpp:2123
lldb_private::TypeSystemClang::GetTranslationUnitDecl
clang::TranslationUnitDecl * GetTranslationUnitDecl()
Definition: TypeSystemClang.h:221
PDBASTParser::m_forward_decl_to_uid
CXXRecordDeclToUidMap m_forward_decl_to_uid
Definition: PDBASTParser.h:109
MSVCUndecoratedNameParser::GetSpecifiers
llvm::ArrayRef< MSVCUndecoratedNameSpecifier > GetSpecifiers() const
Definition: MSVCUndecoratedNameParser.h:35
lldb_private::ClangASTMetadata::SetUserID
void SetUserID(lldb::user_id_t user_id)
Definition: ClangASTMetadata.h:29
lldb_private::Type::GetLayoutCompilerType
CompilerType GetLayoutCompilerType()
Definition: Type.cpp:651
LLDB_INVALID_UID
#define LLDB_INVALID_UID
Definition: lldb-defines.h:92
lldb_private::TypeSystemClang::GetBuiltinTypeForEncodingAndBitSize
CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size) override
Definition: TypeSystemClang.cpp:799
Module.h
PDBASTParser::AddRecordMethods
void AddRecordMethods(lldb_private::SymbolFile &symbol_file, lldb_private::CompilerType &record_type, PDBFuncSymbolEnumerator &methods_enum)
Definition: PDBASTParser.cpp:1394
lldb::eEncodingIEEE754
@ eEncodingIEEE754
float
Definition: lldb-enumerations.h:150
PDBASTParser::AddEnumValue
bool AddEnumValue(lldb_private::CompilerType enum_type, const llvm::pdb::PDBSymbolData &data)
Definition: PDBASTParser.cpp:1143
GetAccessibilityForUdt
static AccessType GetAccessibilityForUdt(const PDBSymbolTypeUDT &udt)
Definition: PDBASTParser.cpp:233
lldb_private::ClangASTImporter::LayoutInfo
Definition: ClangASTImporter.h:66
PDBASTParser::CompleteTypeFromUDT
bool CompleteTypeFromUDT(lldb_private::SymbolFile &symbol_file, lldb_private::CompilerType &compiler_type, llvm::pdb::PDBSymbolTypeUDT &udt)
Definition: PDBASTParser.cpp:1191
lldb_private::TypeSystemClang::GetTypeForIdentifier
CompilerType GetTypeForIdentifier(ConstString type_name, clang::DeclContext *decl_context=nullptr)
Definition: TypeSystemClang.h:252
lldb_private::SymbolFile::GetObjectFile
ObjectFile * GetObjectFile()
Definition: SymbolFile.h:266
lldb_private::CompilerType::GetOpaqueQualType
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:173
GetDeclFromContextByName
static clang::NamedDecl * GetDeclFromContextByName(const clang::ASTContext &ast, const clang::DeclContext &decl_context, llvm::StringRef name)
Definition: PDBASTParser.cpp:320
lldb::eBasicTypeChar
@ eBasicTypeChar
Definition: lldb-enumerations.h:744
lldb_private::CompilerType::AddVolatileModifier
CompilerType AddVolatileModifier() const
Return a new CompilerType adds a volatile modifier to this type if this type is valid and the type sy...
Definition: CompilerType.cpp:441
MSVCUndecoratedNameParser::DropScope
static llvm::StringRef DropScope(llvm::StringRef name)
Definition: MSVCUndecoratedNameParser.cpp:91
PDBASTParser::~PDBASTParser
~PDBASTParser()
lldb_private::TypeSystemClang::CreateArrayType
CompilerType CreateArrayType(const CompilerType &element_type, size_t element_count, bool is_vector)
Definition: TypeSystemClang.cpp:2229
GetBuiltinTypeForPDBEncodingAndBitSize
static CompilerType GetBuiltinTypeForPDBEncodingAndBitSize(TypeSystemClang &clang_ast, const PDBSymbolTypeBuiltin &pdb_type, Encoding encoding, uint32_t width)
Definition: PDBASTParser.cpp:103
ClangUtil.h
PDBASTParser::AddRecordBases
void AddRecordBases(lldb_private::SymbolFile &symbol_file, lldb_private::CompilerType &record_type, int record_kind, PDBBaseClassSymbolEnumerator &bases_enum, lldb_private::ClangASTImporter::LayoutInfo &layout_info) const
Definition: PDBASTParser.cpp:1344
PDBASTParser::ParseDeclsForDeclContext
void ParseDeclsForDeclContext(const clang::DeclContext *decl_context)
Definition: PDBASTParser.cpp:1093
PDBASTParser::FindNamespaceDecl
clang::NamespaceDecl * FindNamespaceDecl(const clang::DeclContext *parent, llvm::StringRef name)
Definition: PDBASTParser.cpp:1118
lldb::eBasicTypeFloat
@ eBasicTypeFloat
Definition: lldb-enumerations.h:764
lldb_private::Type::ResolveState
ResolveState
Definition: Type.h:90
llvm::pdb::ConcreteSymbolEnumerator
Definition: PDBASTParser.h:32
lldb_private::ClangASTImporter::LayoutInfo::base_offsets
OffsetMap base_offsets
Definition: ClangASTImporter.h:74
UInt
#define UInt(x)
Definition: EmulateInstructionARM64.cpp:71
lldb::eEncodingInvalid
@ eEncodingInvalid
Definition: lldb-enumerations.h:147
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb::eEncodingSint
@ eEncodingSint
signed integer
Definition: lldb-enumerations.h:149
LIBLLDB_LOG_AST
#define LIBLLDB_LOG_AST
Definition: Logging.h:45
ClangASTMetadata.h
lldb_private::SymbolFile::ResolveTypeUID
virtual Type * ResolveTypeUID(lldb::user_id_t type_uid)=0
SymbolFilePDB::ResolveTypeUID
lldb_private::Type * ResolveTypeUID(lldb::user_id_t type_uid) override
Definition: SymbolFilePDB.cpp:557
lldb_private::TypeSystemClang::GetAsCXXRecordDecl
static clang::CXXRecordDecl * GetAsCXXRecordDecl(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:7209
lldb_private::CompilerType::CreateTypedef
CompilerType CreateTypedef(const char *name, const CompilerDeclContext &decl_ctx, uint32_t payload) const
Create a typedef to this type using "name" as the name of the typedef this type is valid and the type...
Definition: CompilerType.cpp:455
TypeSystemClang.h
lldb_private::Declaration::SetColumn
void SetColumn(uint16_t column)
Set accessor for the declaration column number.
Definition: Declaration.h:177
PDBASTParser::AddRecordMembers
void AddRecordMembers(lldb_private::SymbolFile &symbol_file, lldb_private::CompilerType &record_type, PDBDataSymbolEnumerator &members_enum, lldb_private::ClangASTImporter::LayoutInfo &layout_info)
Definition: PDBASTParser.cpp:1231
PDBASTParser::m_parent_to_namespaces
ParentToNamespacesMap m_parent_to_namespaces
Definition: PDBASTParser.h:111
PDBASTParser::AddRecordMethod
clang::CXXMethodDecl * AddRecordMethod(lldb_private::SymbolFile &symbol_file, lldb_private::CompilerType &record_type, const llvm::pdb::PDBSymbolFunc &method) const
Definition: PDBASTParser.cpp:1404
lldb_private::TypeSystemClang::CreateEnumerationType
CompilerType CreateEnumerationType(const char *name, clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, const Declaration &decl, const CompilerType &integer_qual_type, bool is_scoped)
Definition: TypeSystemClang.cpp:2294
lldb::eAccessNone
@ eAccessNone
Definition: lldb-enumerations.h:508
Declaration.h
lldb::eBasicTypeInt
@ eBasicTypeInt
Definition: lldb-enumerations.h:754
lldb_private::ClangASTImporter::CompleteType
bool CompleteType(const CompilerType &compiler_type)
Definition: ClangASTImporter.cpp:505
llvm::pdb
Definition: DWARFLocationExpression.h:21
lldb::eBasicTypeDouble
@ eBasicTypeDouble
Definition: lldb-enumerations.h:765
lldb::eEncodingUint
@ eEncodingUint
unsigned integer
Definition: lldb-enumerations.h:148
lldb_private::ConstString
Definition: ConstString.h:40
MSVCUndecoratedNameParser.h
lldb_private::CompilerType::AddConstModifier
CompilerType AddConstModifier() const
Return a new CompilerType adds a const modifier to this type if this type is valid and the type syste...
Definition: CompilerType.cpp:434
GetClassOrFunctionParent
static std::unique_ptr< llvm::pdb::PDBSymbol > GetClassOrFunctionParent(const llvm::pdb::PDBSymbol &symbol)
Definition: PDBASTParser.cpp:270
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
lldb_private::ClangASTMetadata::SetIsDynamicCXXType
void SetIsDynamicCXXType(bool b)
Definition: ClangASTMetadata.h:27
lldb_private::Declaration::SetFile
void SetFile(const FileSpec &file_spec)
Set accessor for the declaration file specification.
Definition: Declaration.h:163
PDBASTParser::m_uid_to_decl
UidToDeclMap m_uid_to_decl
Definition: PDBASTParser.h:110
TranslateMemberAccess
static AccessType TranslateMemberAccess(PDB_MemberAccess access)
Definition: PDBASTParser.cpp:209
PDBASTParser::GetDeclContextContainingSymbol
clang::DeclContext * GetDeclContextContainingSymbol(const llvm::pdb::PDBSymbol &symbol)
Definition: PDBASTParser.cpp:1019
lldb::eBasicTypeVoid
@ eBasicTypeVoid
Definition: lldb-enumerations.h:743
lldb_private::TypeSystemClang::GetUniqueNamespaceDeclaration
clang::NamespaceDecl * GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, bool is_inline=false)
Definition: TypeSystemClang.cpp:1843
set
set(option_framework FRAMEWORK) endif() if(LLDB_ENABLE_PYTHON) get_target_property(python_bindings_dir swig_wrapper_python BINARY_DIR) set(lldb_python_wrapper $
Definition: API/CMakeLists.txt:9
PDBASTParser::m_ast
lldb_private::TypeSystemClang & m_ast
Definition: PDBASTParser.h:106
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::ClangASTMetadata
Definition: ClangASTMetadata.h:18
TypeSystem.h
lldb_private::Type::ResolveState::Full
@ Full
TranslateCallingConvention
static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc)
Definition: PDBASTParser.cpp:336
lldb_private::CompilerType::IsValid
bool IsValid() const
Definition: CompilerType.h:72
lldb_private::CompilerType::GetLValueReferenceType
CompilerType GetLValueReferenceType() const
Return a new CompilerType that is a L value reference to this type if this type is valid and the type...
Definition: CompilerType.cpp:414
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::TypeSystemClang::AddMethodOverridesForCXXRecordType
void AddMethodOverridesForCXXRecordType(lldb::opaque_compiler_type_t type)
Definition: TypeSystemClang.cpp:7692
lldb_private::CompilerType::GetCompleteType
bool GetCompleteType() const
Type Completion.
Definition: CompilerType.cpp:264
lldb_private::ClangASTImporter::SetRecordLayout
void SetRecordLayout(clang::RecordDecl *decl, const LayoutInfo &layout)
Sets the layout for the given RecordDecl.
Definition: ClangASTImporter.cpp:548
lldb_private::TypeSystemClang::SetFunctionParameters
void SetFunctionParameters(clang::FunctionDecl *function_decl, llvm::ArrayRef< clang::ParmVarDecl * > params)
Definition: TypeSystemClang.cpp:2213
lldb::eAccessPublic
@ eAccessPublic
Definition: lldb-enumerations.h:509
lldbassert
#define lldbassert(x)
Definition: LLDBAssert.h:15
PDBASTParser::CreateLLDBTypeFromPDBType
lldb::TypeSP CreateLLDBTypeFromPDBType(const llvm::pdb::PDBSymbol &type)
Definition: PDBASTParser.cpp:362
lldb_private::CompilerType::GetPointerType
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
Definition: CompilerType.cpp:407
lldb::eBasicTypeLongDouble
@ eBasicTypeLongDouble
Definition: lldb-enumerations.h:766
GetMSInheritance
static clang::MSInheritanceAttr::Spelling GetMSInheritance(const PDBSymbolTypeUDT &udt)
Definition: PDBASTParser.cpp:250
lldb_private::OptionalClangModuleID
A Clang module ID.
Definition: TypeSystemClang.h:57
TranslateBuiltinEncoding
static lldb::Encoding TranslateBuiltinEncoding(PDB_BuiltinType type)
Definition: PDBASTParser.cpp:60
uint32_t
lldb_private::TypeSystemClang::GetCompleteDecl
bool GetCompleteDecl(clang::Decl *decl)
Definition: TypeSystemClang.h:180
lldb::eAccessPrivate
@ eAccessPrivate
Definition: lldb-enumerations.h:510
lldb_private::TypeSystemClang::GetEnumerationIntegerType
CompilerType GetEnumerationIntegerType(lldb::opaque_compiler_type_t type) override
Definition: TypeSystemClang.cpp:4258
PDBASTParser::m_decl_context_to_uid
DeclContextToUidMap m_decl_context_to_uid
Definition: PDBASTParser.h:113
PDBASTParser::GetDeclContextForSymbol
clang::DeclContext * GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol)
Definition: PDBASTParser.cpp:991
lldb_private::TypeSystemClang::CreateVariableDeclaration
clang::VarDecl * CreateVariableDeclaration(clang::DeclContext *decl_context, OptionalClangModuleID owning_module, const char *name, clang::QualType type)
Definition: TypeSystemClang.cpp:1975
IsAnonymousNamespaceName
static bool IsAnonymousNamespaceName(llvm::StringRef name)
Definition: PDBASTParser.cpp:332
lldb_private::CompilerType::GetTypeName
ConstString GetTypeName() const
Definition: CompilerType.cpp:277
lldb_private::Type
Definition: Type.h:66
lldb_private::Type::GetForwardCompilerType
CompilerType GetForwardCompilerType()
Definition: Type.cpp:656
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
lldb_private::CompilerType::AddRestrictModifier
CompilerType AddRestrictModifier() const
Return a new CompilerType adds a restrict modifier to this type if this type is valid and the type sy...
Definition: CompilerType.cpp:448
PDBASTParser::CompleteTypeFromPDB
bool CompleteTypeFromPDB(lldb_private::CompilerType &compiler_type)
Definition: PDBASTParser.cpp:789
lldb::Encoding
Encoding
Register encoding definitions.
Definition: lldb-enumerations.h:146
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
lldb_private::TypeSystemClang::CreateRecordType
CompilerType CreateRecordType(clang::DeclContext *decl_ctx, OptionalClangModuleID owning_module, lldb::AccessType access_type, llvm::StringRef name, int kind, lldb::LanguageType language, ClangASTMetadata *metadata=nullptr, bool exports_symbols=false)
Definition: TypeSystemClang.cpp:1274
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
PDBASTParser::PDBASTParser
PDBASTParser(lldb_private::TypeSystemClang &ast)
Definition: PDBASTParser.cpp:356
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Type::ResolveState::Forward
@ Forward
lldb_private::TypeSystemClang::GetBasicType
CompilerType GetBasicType(lldb::BasicType type)
Definition: TypeSystemClang.cpp:934
GetDefaultAccessibilityForUdtKind
static AccessType GetDefaultAccessibilityForUdtKind(PDB_UdtType udt_kind)
Definition: PDBASTParser.cpp:221
lldb_private::TypeSystemClang
A TypeSystem implementation based on Clang.
Definition: TypeSystemClang.h:106
lldb_private::TypeSystemClang::AddEnumerationValueToEnumerationType
clang::EnumConstantDecl * AddEnumerationValueToEnumerationType(const CompilerType &enum_type, const Declaration &decl, const char *name, int64_t enum_value, uint32_t enum_value_bit_size)
Definition: TypeSystemClang.cpp:8309
lldb_private::TypeSystem::GetSymbolFile
virtual SymbolFile * GetSymbolFile() const
Definition: TypeSystem.h:92
lldb_private::TypeSystemClang::AddMethodToCXXRecordType
clang::CXXMethodDecl * AddMethodToCXXRecordType(lldb::opaque_compiler_type_t type, llvm::StringRef name, const char *mangled_name, const CompilerType &method_type, lldb::AccessType access, bool is_virtual, bool is_static, bool is_inline, bool is_explicit, bool is_attr_used, bool is_artificial)
Definition: TypeSystemClang.cpp:7501
lldb_private::TypeSystemClang::GetDeclContextForType
static clang::DeclContext * GetDeclContextForType(clang::QualType type)
Definition: TypeSystemClang.cpp:2606
lldb_private::Declaration
Definition: Declaration.h:24
PDBASTParser::NamespacesSet
std::set< clang::NamespaceDecl * > NamespacesSet
Definition: PDBASTParser.h:71
lldb
Definition: SBAddress.h:15
TranslateUdtKind
static int TranslateUdtKind(PDB_UdtType pdb_kind)
Definition: PDBASTParser.cpp:46
PDBASTParser.h
lldb_private::Type::GetFullCompilerType
CompilerType GetFullCompilerType()
Definition: Type.cpp:646
PDBASTParser::m_namespaces
NamespacesSet m_namespaces
Definition: PDBASTParser.h:112
lldb::AccessType
AccessType
Definition: lldb-enumerations.h:507
SymbolFile.h
lldb_private::TypeSystemClang::CreateBaseClassSpecifier
std::unique_ptr< clang::CXXBaseSpecifier > CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type, lldb::AccessType access, bool is_virtual, bool base_of_class)
Definition: TypeSystemClang.cpp:7702
lldb_private::ClangASTImporter::LayoutInfo::bit_size
uint64_t bit_size
Definition: ClangASTImporter.h:71
lldb_private::CompilerType::GetRValueReferenceType
CompilerType GetRValueReferenceType() const
Return a new CompilerType that is a R value reference to this type if this type is valid and the type...
Definition: CompilerType.cpp:421
lldb_private::Type::eEncodingIsUID
@ eEncodingIsUID
This type is the type whose UID is m_encoding_uid.
Definition: Type.h:70
lldb::eLanguageTypeC_plus_plus
@ eLanguageTypeC_plus_plus
ISO C++:1998.
Definition: lldb-enumerations.h:441