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