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