Index: lldb/include/lldb/Symbol/CompilerType.h =================================================================== --- lldb/include/lldb/Symbol/CompilerType.h +++ lldb/include/lldb/Symbol/CompilerType.h @@ -242,8 +242,10 @@ /// Create a typedef to this type using "name" as the name of the typedef this /// type is valid and the type system supports typedefs, else return an /// invalid type. + /// \param payload The typesystem-specific \p lldb::Type payload. CompilerType CreateTypedef(const char *name, - const CompilerDeclContext &decl_ctx) const; + const CompilerDeclContext &decl_ctx, + uint32_t payload) const; /// If the current object represents a typedef type, get the underlying type CompilerType GetTypedefedType() const; Index: lldb/include/lldb/Symbol/TypeSystem.h =================================================================== --- lldb/include/lldb/Symbol/TypeSystem.h +++ lldb/include/lldb/Symbol/TypeSystem.h @@ -259,9 +259,12 @@ virtual CompilerType AddRestrictModifier(lldb::opaque_compiler_type_t type); + /// \param opaque_payload The m_payload field of Type, which may + /// carry TypeSystem-specific extra information. virtual CompilerType CreateTypedef(lldb::opaque_compiler_type_t type, const char *name, - const CompilerDeclContext &decl_ctx); + const CompilerDeclContext &decl_ctx, + uint32_t opaque_payload); // Exploring the type Index: lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp =================================================================== --- lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp +++ lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp @@ -993,7 +993,7 @@ clang::NamespaceDecl *namespace_decl = m_clang_ast_context->GetUniqueNamespaceDeclaration( - g_lldb_local_vars_namespace_cstr, nullptr); + g_lldb_local_vars_namespace_cstr, nullptr, ModuleID()); if (!namespace_decl) return; Index: lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h =================================================================== --- lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h +++ lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h @@ -10,14 +10,21 @@ #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXTERNALASTSOURCECALLBACKS_H #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" -#include "clang/AST/ExternalASTSource.h" +#include "clang/Basic/Module.h" namespace lldb_private { class TypeSystemClang; class ClangExternalASTSourceCallbacks : public clang::ExternalASTSource { + /// LLVM RTTI support. + static char ID; + public: + /// LLVM RTTI support. + bool isA(const void *ClassID) const override { return ClassID == &ID; } + static bool classof(const clang::ExternalASTSource *s) { return s->isA(&ID); } + ClangExternalASTSourceCallbacks(TypeSystemClang &ast) : m_ast(ast) {} void FindExternalLexicalDecls( @@ -37,8 +44,20 @@ llvm::DenseMap &VirtualBaseOffsets) override; + TypeSystemClang &GetTypeSystem() const { return m_ast; } + + /// Module-related methods. + /// \{ + llvm::Optional + getSourceDescriptor(unsigned ID) override; + clang::Module *getModule(unsigned ID) override; + unsigned RegisterModule(clang::Module *module); + unsigned GetIDForModule(clang::Module *module); + /// \} private: TypeSystemClang &m_ast; + std::vector m_modules; + llvm::DenseMap m_ids; }; } // namespace lldb_private Index: lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.cpp =================================================================== --- lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.cpp +++ lldb/source/Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.cpp @@ -13,6 +13,8 @@ using namespace lldb_private; +char ClangExternalASTSourceCallbacks::ID; + void ClangExternalASTSourceCallbacks::CompleteType(clang::TagDecl *tag_decl) { m_ast.CompleteTagDecl(tag_decl); } @@ -43,3 +45,27 @@ CompleteType(tag_decl); } } + +unsigned ClangExternalASTSourceCallbacks::RegisterModule(clang::Module *module) { + m_modules.push_back(module); + unsigned id = m_modules.size(); + m_ids.insert({module, id}); + return id; +} + +llvm::Optional +ClangExternalASTSourceCallbacks::getSourceDescriptor(unsigned id) { + if (clang::Module *module = getModule(id)) + return {*module}; + return {}; +} + +clang::Module *ClangExternalASTSourceCallbacks::getModule(unsigned id) { + if (id && id <= m_modules.size()) + return m_modules[id - 1]; + return nullptr; +} + +unsigned ClangExternalASTSourceCallbacks::GetIDForModule(clang::Module *module) { + return m_ids[module]; +} Index: lldb/source/Plugins/Language/ObjC/NSDictionary.cpp =================================================================== --- lldb/source/Plugins/Language/ObjC/NSDictionary.cpp +++ lldb/source/Plugins/Language/ObjC/NSDictionary.cpp @@ -76,8 +76,9 @@ if (!compiler_type) { compiler_type = target_ast_context->CreateRecordType( - nullptr, lldb::eAccessPublic, g___lldb_autogen_nspair.GetCString(), - clang::TTK_Struct, lldb::eLanguageTypeC); + nullptr, ModuleID(), lldb::eAccessPublic, + g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct, + lldb::eLanguageTypeC); if (compiler_type) { TypeSystemClang::StartTagDeclarationDefinition(compiler_type); Index: lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp =================================================================== --- lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp +++ lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp @@ -123,8 +123,9 @@ if (is_templated) return clang::QualType(); // This is where we bail out. Sorry! - CompilerType union_type(ast_ctx.CreateRecordType( - nullptr, lldb::eAccessPublic, name, kind, lldb::eLanguageTypeC)); + CompilerType union_type(ast_ctx.CreateRecordType(nullptr, ModuleID(), + lldb::eAccessPublic, name, + kind, lldb::eLanguageTypeC)); if (union_type) { TypeSystemClang::StartTagDeclarationDefinition(union_type); Index: lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp =================================================================== --- lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp +++ lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp @@ -788,7 +788,7 @@ clang_type = m_ast.CreateEnumerationType( attrs.name.GetCString(), GetClangDeclContextContainingDIE(die, nullptr), - attrs.decl, enumerator_clang_type, attrs.is_scoped_enum); + ModuleID(), attrs.decl, enumerator_clang_type, attrs.is_scoped_enum); } else { enumerator_clang_type = m_ast.GetEnumerationIntegerType(clang_type); } @@ -1171,7 +1171,7 @@ function_decl = m_ast.CreateFunctionDeclaration( ignore_containing_context ? m_ast.GetTranslationUnitDecl() : containing_decl_ctx, - attrs.name.GetCString(), clang_type, attrs.storage, + ModuleID(), attrs.name.GetCString(), clang_type, attrs.storage, attrs.is_inline); if (has_template_params) { @@ -1180,11 +1180,11 @@ template_function_decl = m_ast.CreateFunctionDeclaration( ignore_containing_context ? m_ast.GetTranslationUnitDecl() : containing_decl_ctx, - attrs.name.GetCString(), clang_type, attrs.storage, + ModuleID(), attrs.name.GetCString(), clang_type, attrs.storage, attrs.is_inline); clang::FunctionTemplateDecl *func_template_decl = m_ast.CreateFunctionTemplateDecl( - containing_decl_ctx, template_function_decl, + containing_decl_ctx, ModuleID(), template_function_decl, attrs.name.GetCString(), template_param_infos); m_ast.CreateFunctionTemplateSpecializationInfo( function_decl, func_template_decl, template_param_infos); @@ -1582,9 +1582,9 @@ TypeSystemClang::TemplateParameterInfos template_param_infos; if (ParseTemplateParameterInfos(die, template_param_infos)) { clang::ClassTemplateDecl *class_template_decl = - m_ast.ParseClassTemplateDecl(decl_ctx, attrs.accessibility, - attrs.name.GetCString(), tag_decl_kind, - template_param_infos); + m_ast.ParseClassTemplateDecl( + decl_ctx, ModuleID(), attrs.accessibility, + attrs.name.GetCString(), tag_decl_kind, template_param_infos); if (!class_template_decl) { if (log) { dwarf->GetObjectFile()->GetModule()->LogMessage( @@ -1599,7 +1599,7 @@ clang::ClassTemplateSpecializationDecl *class_specialization_decl = m_ast.CreateClassTemplateSpecializationDecl( - decl_ctx, class_template_decl, tag_decl_kind, + decl_ctx, ModuleID(), class_template_decl, tag_decl_kind, template_param_infos); clang_type = m_ast.CreateClassTemplateSpecializationType( class_specialization_decl); @@ -1613,8 +1613,9 @@ if (!clang_type_was_created) { clang_type_was_created = true; clang_type = m_ast.CreateRecordType( - decl_ctx, attrs.accessibility, attrs.name.GetCString(), tag_decl_kind, - attrs.class_language, &metadata, attrs.exports_symbols); + decl_ctx, ModuleID(), attrs.accessibility, attrs.name.GetCString(), + tag_decl_kind, attrs.class_language, &metadata, + attrs.exports_symbols); } } @@ -3060,9 +3061,9 @@ function_param_types.push_back(type->GetForwardCompilerType()); clang::ParmVarDecl *param_var_decl = - m_ast.CreateParameterDeclaration(containing_decl_ctx, name, - type->GetForwardCompilerType(), - storage); + m_ast.CreateParameterDeclaration( + containing_decl_ctx, ModuleID(), name, + type->GetForwardCompilerType(), storage); assert(param_var_decl); function_param_decls.push_back(param_var_decl); @@ -3131,8 +3132,8 @@ Status error; lldb::VariableSP var_sp; auto valobj_sp = frame->GetValueForVariableExpressionPath( - var_die.GetName(), eNoDynamicValues, 0, var_sp, - error); + var_die.GetName(), eNoDynamicValues, 0, + var_sp, error); if (valobj_sp) { num_elements = valobj_sp->GetValueAsUnsigned(0); break; @@ -3260,7 +3261,7 @@ TypeSystemClang::DeclContextGetAsDeclContext( dwarf->GetDeclContextContainingUID(die.GetID())); decl = m_ast.CreateVariableDeclaration( - decl_context, name, + decl_context, ModuleID(), name, ClangUtil::GetQualType(type->GetForwardCompilerType())); } break; @@ -3277,8 +3278,8 @@ if (clang::NamedDecl *clang_imported_decl = llvm::dyn_cast( (clang::Decl *)imported_decl.GetOpaqueDecl())) - decl = - m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl); + decl = m_ast.CreateUsingDeclaration(decl_context, ModuleID(), + clang_imported_decl); } } break; @@ -3297,7 +3298,8 @@ if (clang::NamespaceDecl *ns_decl = TypeSystemClang::DeclContextGetAsNamespaceDecl( imported_decl_ctx)) - decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl); + decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ModuleID(), + ns_decl); } } break; @@ -3427,7 +3429,7 @@ DWARFDIE decl_context_die; clang::DeclContext *decl_context = GetClangDeclContextContainingDIE(die, &decl_context_die); - decl = m_ast.CreateBlockDeclaration(decl_context); + decl = m_ast.CreateBlockDeclaration(decl_context, ModuleID()); if (decl) LinkDeclContextToDIE((clang::DeclContext *)decl, die); @@ -3455,7 +3457,7 @@ die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0; namespace_decl = m_ast.GetUniqueNamespaceDeclaration( - namespace_name, containing_decl_ctx, is_inline); + namespace_name, containing_decl_ctx, ModuleID(), is_inline); Log *log = nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO)); if (log) { Index: lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp =================================================================== --- lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp +++ lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp @@ -776,8 +776,9 @@ metadata.SetUserID(toOpaqueUid(id)); metadata.SetIsDynamicCXXType(false); - CompilerType ct = m_clang.CreateRecordType( - context, access, uname, ttk, lldb::eLanguageTypeC_plus_plus, &metadata); + CompilerType ct = + m_clang.CreateRecordType(context, ModuleID(), access, uname, ttk, + lldb::eLanguageTypeC_plus_plus, &metadata); lldbassert(ct.IsValid()); @@ -804,7 +805,7 @@ PdbAstBuilder::GetOrCreateNamespaceDecl(const char *name, clang::DeclContext &context) { return m_clang.GetUniqueNamespaceDeclaration( - IsAnonymousNamespaceName(name) ? nullptr : name, &context); + IsAnonymousNamespaceName(name) ? nullptr : name, &context, ModuleID()); } clang::BlockDecl * @@ -814,7 +815,7 @@ clang::DeclContext *scope = GetParentDeclContext(block_id); - clang::BlockDecl *block_decl = m_clang.CreateBlockDeclaration(scope); + clang::BlockDecl *block_decl = m_clang.CreateBlockDeclaration(scope, ModuleID()); m_uid_to_decl.insert({toOpaqueUid(block_id), block_decl}); DeclStatus status; @@ -831,7 +832,7 @@ clang::QualType qt = GetOrCreateType(var_info.type); clang::VarDecl *var_decl = m_clang.CreateVariableDeclaration( - &scope, var_info.name.str().c_str(), qt); + &scope, ModuleID(), var_info.name.str().c_str(), qt); m_uid_to_decl[toOpaqueUid(uid)] = var_decl; DeclStatus status; @@ -879,7 +880,7 @@ std::string uname = std::string(DropNameScope(udt.Name)); CompilerType ct = m_clang.CreateTypedefType(ToCompilerType(qt), uname.c_str(), - ToCompilerDeclContext(*scope)); + ToCompilerDeclContext(*scope), 0); clang::TypedefNameDecl *tnd = m_clang.GetAsTypedefDecl(ct); DeclStatus status; status.resolved = true; @@ -1012,7 +1013,7 @@ proc_name.consume_front("::"); clang::FunctionDecl *function_decl = m_clang.CreateFunctionDeclaration( - parent, proc_name.str().c_str(), func_ct, storage, false); + parent, ModuleID(), proc_name.str().c_str(), func_ct, storage, false); lldbassert(m_uid_to_decl.count(toOpaqueUid(func_id)) == 0); m_uid_to_decl[toOpaqueUid(func_id)] = function_decl; @@ -1080,7 +1081,7 @@ CompilerType param_type_ct = m_clang.GetType(qt); clang::ParmVarDecl *param = m_clang.CreateParameterDeclaration( - &function_decl, param_name.str().c_str(), param_type_ct, + &function_decl, ModuleID(), param_name.str().c_str(), param_type_ct, clang::SC_None, true); lldbassert(m_uid_to_decl.count(toOpaqueUid(param_uid)) == 0); @@ -1102,8 +1103,8 @@ Declaration declaration; CompilerType enum_ct = m_clang.CreateEnumerationType( - uname.c_str(), decl_context, declaration, ToCompilerType(underlying_type), - er.isScoped()); + uname.c_str(), decl_context, ModuleID(), declaration, + ToCompilerType(underlying_type), er.isScoped()); TypeSystemClang::StartTagDeclarationDefinition(enum_ct); TypeSystemClang::SetHasExternalStorage(enum_ct.GetOpaqueQualType(), true); Index: lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp =================================================================== --- lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp +++ lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp @@ -409,9 +409,9 @@ metadata.SetUserID(type.getSymIndexId()); metadata.SetIsDynamicCXXType(false); - clang_type = - m_ast.CreateRecordType(decl_context, access, name, tag_type_kind, - lldb::eLanguageTypeC_plus_plus, &metadata); + clang_type = m_ast.CreateRecordType( + decl_context, ModuleID(), access, name, tag_type_kind, + lldb::eLanguageTypeC_plus_plus, &metadata); assert(clang_type.IsValid()); auto record_decl = @@ -497,8 +497,8 @@ // Class). Set it false for now. bool isScoped = false; - ast_enum = m_ast.CreateEnumerationType(name.c_str(), decl_context, decl, - builtin_type, isScoped); + ast_enum = m_ast.CreateEnumerationType( + name.c_str(), decl_context, ModuleID(), decl, builtin_type, isScoped); auto enum_decl = TypeSystemClang::GetAsEnumDecl(ast_enum); assert(enum_decl); @@ -550,7 +550,7 @@ CompilerType target_ast_type = target_type->GetFullCompilerType(); ast_typedef = m_ast.CreateTypedefType( - target_ast_type, name.c_str(), m_ast.CreateDeclContext(decl_ctx)); + target_ast_type, name.c_str(), m_ast.CreateDeclContext(decl_ctx), 0); if (!ast_typedef) return nullptr; @@ -901,7 +901,7 @@ return nullptr; decl = m_ast.CreateVariableDeclaration( - decl_context, name.c_str(), + decl_context, ModuleID(), name.c_str(), ClangUtil::GetQualType(type->GetLayoutCompilerType())); } @@ -927,8 +927,8 @@ : clang::StorageClass::SC_None; auto decl = m_ast.CreateFunctionDeclaration( - decl_context, name.c_str(), type->GetForwardCompilerType(), storage, - func->hasInlineAttribute()); + decl_context, ModuleID(), name.c_str(), type->GetForwardCompilerType(), + storage, func->hasInlineAttribute()); std::vector params; if (std::unique_ptr sig = func->getSignature()) { @@ -941,7 +941,7 @@ continue; clang::ParmVarDecl *param = m_ast.CreateParameterDeclaration( - decl, nullptr, arg_type->GetForwardCompilerType(), + decl, ModuleID(), nullptr, arg_type->GetForwardCompilerType(), clang::SC_None, true); if (param) params.push_back(param); @@ -1057,7 +1057,7 @@ : namespace_name.data(); clang::NamespaceDecl *namespace_decl = m_ast.GetUniqueNamespaceDeclaration(namespace_name_c_str, - curr_context); + curr_context, ModuleID()); m_parent_to_namespaces[curr_context].insert(namespace_decl); m_namespaces.insert(namespace_decl); Index: lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp =================================================================== --- lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp +++ lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp @@ -418,9 +418,10 @@ if (m_dispatch_tsd_indexes_addr != LLDB_INVALID_ADDRESS) { CompilerType uint16 = ast_ctx->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16); - CompilerType dispatch_tsd_indexes_s = ast_ctx->CreateRecordType( - nullptr, lldb::eAccessPublic, "__lldb_dispatch_tsd_indexes_s", - clang::TTK_Struct, lldb::eLanguageTypeC); + CompilerType dispatch_tsd_indexes_s = + ast_ctx->CreateRecordType(nullptr, ModuleID(), lldb::eAccessPublic, + "__lldb_dispatch_tsd_indexes_s", + clang::TTK_Struct, lldb::eLanguageTypeC); TypeSystemClang::StartTagDeclarationDefinition(dispatch_tsd_indexes_s); TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s, Index: lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h =================================================================== --- lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h +++ lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h @@ -53,13 +53,29 @@ class ClangASTSource; class Declaration; +/// A Clang module ID. +struct ModuleID { + unsigned id = 0; + + ModuleID() = default; + explicit ModuleID(unsigned id) : id(id) {} + bool HasValue() const { return id; } + llvm::Optional get() const { + return id ? llvm::Optional(id) : llvm::None; + } +}; + /// The implementation of lldb::Type's m_payload field for TypeSystemClang. class TypePayloadClang { - /// Layout: bit 31 ... IsCompleteObjCClass. - uint32_t m_payload = 0; + /// The Layout is as follows: + /// \verbatim + /// bit 0..30 ... Owning Module ID. + /// bit 31 ...... IsCompleteObjCClass. + /// \endverbatim + uint32_t m_payload; public: TypePayloadClang() = default; - explicit TypePayloadClang(bool is_complete_objc_class); + explicit TypePayloadClang(bool is_complete_objc_class, ModuleID owning_module); explicit TypePayloadClang(uint32_t opaque_payload) : m_payload(opaque_payload) {} operator uint32_t() { return m_payload; } @@ -69,6 +85,11 @@ m_payload = is_complete_objc_class ? Flags(m_payload).Set(ObjCClassBit) : Flags(m_payload).Clear(ObjCClassBit); } + ModuleID GetOwningModuleID() { + return ModuleID(Flags(m_payload).Clear(ObjCClassBit)); + } + void SetOwningModuleID(ModuleID id); + /// \} }; /// A TypeSystem implementation based on Clang. @@ -293,7 +314,13 @@ static uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes); + /// Synthesize a clang::Module and return its ID or 0. + unsigned GetOrCreateClangModule(llvm::StringRef name, unsigned parent, + bool is_framework = false, + bool is_explicit = false); + CompilerType CreateRecordType(clang::DeclContext *decl_ctx, + ModuleID owning_module, lldb::AccessType access_type, llvm::StringRef name, int kind, lldb::LanguageType language, @@ -319,6 +346,7 @@ clang::FunctionTemplateDecl * CreateFunctionTemplateDecl(clang::DeclContext *decl_ctx, + ModuleID owning_module, clang::FunctionDecl *func_decl, const char *name, const TemplateParameterInfos &infos); @@ -327,7 +355,7 @@ const TemplateParameterInfos &infos); clang::ClassTemplateDecl * - CreateClassTemplateDecl(clang::DeclContext *decl_ctx, + CreateClassTemplateDecl(clang::DeclContext *decl_ctx, ModuleID owning_module, lldb::AccessType access_type, const char *class_name, int kind, const TemplateParameterInfos &infos); @@ -335,7 +363,7 @@ CreateTemplateTemplateParmDecl(const char *template_name); clang::ClassTemplateSpecializationDecl *CreateClassTemplateSpecializationDecl( - clang::DeclContext *decl_ctx, + clang::DeclContext *decl_ctx, ModuleID owning_module, clang::ClassTemplateDecl *class_template_decl, int kind, const TemplateParameterInfos &infos); @@ -355,7 +383,8 @@ static bool RecordHasFields(const clang::RecordDecl *record_decl); CompilerType CreateObjCClass(llvm::StringRef name, - clang::DeclContext *decl_ctx, bool isForwardDecl, + clang::DeclContext *decl_ctx, + ModuleID owning_module, bool isForwardDecl, bool isInternal, ClangASTMetadata *metadata = nullptr); @@ -373,14 +402,13 @@ clang::NamespaceDecl * GetUniqueNamespaceDeclaration(const char *name, clang::DeclContext *decl_ctx, - bool is_inline = false); + ModuleID owning_module, bool is_inline = false); // Function Types - clang::FunctionDecl * - CreateFunctionDeclaration(clang::DeclContext *decl_ctx, const char *name, - const CompilerType &function_Type, int storage, - bool is_inline); + clang::FunctionDecl *CreateFunctionDeclaration( + clang::DeclContext *decl_ctx, ModuleID owning_module, const char *name, + const CompilerType &function_Type, int storage, bool is_inline); CompilerType CreateFunctionType(const CompilerType &result_type, const CompilerType *args, unsigned num_args, @@ -395,6 +423,7 @@ } clang::ParmVarDecl *CreateParameterDeclaration(clang::DeclContext *decl_ctx, + ModuleID owning_module, const char *name, const CompilerType ¶m_type, int storage, @@ -413,6 +442,7 @@ // Enumeration Types CompilerType CreateEnumerationType(const char *name, clang::DeclContext *decl_ctx, + ModuleID owning_module, const Declaration &decl, const CompilerType &integer_qual_type, bool is_scoped); @@ -479,6 +509,9 @@ /// TypeSystemClang. CompilerDeclContext CreateDeclContext(clang::DeclContext *ctx); + /// Set the owning module for \p decl. + static void SetOwningModule(clang::Decl *decl, ModuleID owning_module); + std::vector DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name, const bool ignore_using_decls) override; @@ -641,11 +674,13 @@ // Creating related types - // Using the current type, create a new typedef to that type using - // "typedef_name" as the name and "decl_ctx" as the decl context. + /// Using the current type, create a new typedef to that type using + /// "typedef_name" as the name and "decl_ctx" as the decl context. + /// \param payload is an opaque TypePayloadClang. static CompilerType CreateTypedefType(const CompilerType &type, const char *typedef_name, - const CompilerDeclContext &compiler_decl_ctx); + const CompilerDeclContext &compiler_decl_ctx, + uint32_t opaque_payload); CompilerType GetArrayElementType(lldb::opaque_compiler_type_t type, uint64_t *stride) override; @@ -696,7 +731,8 @@ CompilerType CreateTypedef(lldb::opaque_compiler_type_t type, const char *name, - const CompilerDeclContext &decl_ctx) override; + const CompilerDeclContext &decl_ctx, + uint32_t opaque_payload) override; // If the current object represents a typedef type, get the underlying type CompilerType GetTypedefedType(lldb::opaque_compiler_type_t type) override; @@ -955,20 +991,24 @@ GetAsObjCInterfaceDecl(const CompilerType &type); clang::ClassTemplateDecl *ParseClassTemplateDecl( - clang::DeclContext *decl_ctx, lldb::AccessType access_type, - const char *parent_name, int tag_decl_kind, + clang::DeclContext *decl_ctx, ModuleID owning_module, + lldb::AccessType access_type, const char *parent_name, int tag_decl_kind, const TypeSystemClang::TemplateParameterInfos &template_param_infos); - clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx); + clang::BlockDecl *CreateBlockDeclaration(clang::DeclContext *ctx, + ModuleID owning_module); clang::UsingDirectiveDecl * CreateUsingDirectiveDeclaration(clang::DeclContext *decl_ctx, + ModuleID owning_module, clang::NamespaceDecl *ns_decl); clang::UsingDecl *CreateUsingDeclaration(clang::DeclContext *current_decl_ctx, + ModuleID owning_module, clang::NamedDecl *target); clang::VarDecl *CreateVariableDeclaration(clang::DeclContext *decl_context, + ModuleID owning_module, const char *name, clang::QualType type); @@ -991,6 +1031,13 @@ clang::DeclarationName GetDeclarationName(const char *name, const CompilerType &function_clang_type); + clang::LangOptions *GetLangOpts() const { + return m_language_options_up.get(); + } + clang::SourceManager *GetSourceMgr() const { + return m_source_manager_up.get(); + } + private: const clang::ClassTemplateSpecializationDecl * GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type); @@ -1008,6 +1055,8 @@ std::unique_ptr m_identifier_table_up; std::unique_ptr m_selector_table_up; std::unique_ptr m_builtins_up; + std::unique_ptr m_header_search_up; + std::unique_ptr m_module_map_up; std::unique_ptr m_dwarf_ast_parser_up; std::unique_ptr m_pdb_ast_parser_up; std::unique_ptr m_mangle_ctx_up; Index: lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp =================================================================== --- lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp +++ lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp @@ -34,6 +34,9 @@ #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetOptions.h" #include "clang/Frontend/FrontendOptions.h" +#include "clang/Lex/HeaderSearch.h" +#include "clang/Lex/HeaderSearchOptions.h" +#include "clang/Lex/ModuleMap.h" #include "clang/Sema/Sema.h" #include "llvm/Support/Signals.h" @@ -316,10 +319,33 @@ return *g_map_ptr; } -TypePayloadClang::TypePayloadClang(bool is_complete_objc_class) { +TypePayloadClang::TypePayloadClang(bool is_complete_objc_class, + ModuleID owning_module) + : m_payload(owning_module.id) { SetIsCompleteObjCClass(is_complete_objc_class); } +void TypePayloadClang::SetOwningModuleID(ModuleID id) { + assert(id.id < ObjCClassBit); + bool is_complete = IsCompleteObjCClass(); + m_payload = id.id; + SetIsCompleteObjCClass(is_complete); +} + +static void SetMemberOwningModule(clang::Decl *member, + const clang::Decl *parent) { + if (!member || !parent) + return; + + ModuleID id(parent->getOwningModuleID()); + if (!id.HasValue()) + return; + + member->setFromASTFile(); + member->setOwningModuleID(*id.get()); + member->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible); +} + char TypeSystemClang::ID; bool TypeSystemClang::IsOperator(llvm::StringRef name, @@ -505,6 +531,10 @@ // // FIXME: This is affected by other options (-fno-inline). Opts.NoInlineDefine = !Opt; + + // This is needed to allocate the extra space for the owning module + // on each decl. + Opts.ModulesLocalVisibility = 1; } TypeSystemClang::TypeSystemClang(llvm::StringRef name, @@ -1186,7 +1216,53 @@ #pragma mark Structure, Unions, Classes -CompilerType TypeSystemClang::CreateRecordType(DeclContext *decl_ctx, +void TypeSystemClang::SetOwningModule(clang::Decl *decl, ModuleID owning_module) { + if (!decl || !owning_module.HasValue()) + return; + + decl->setFromASTFile(); + decl->setOwningModuleID(*owning_module.get()); + decl->setModuleOwnershipKind(clang::Decl::ModuleOwnershipKind::Visible); +} + +unsigned TypeSystemClang::GetOrCreateClangModule(llvm::StringRef name, + unsigned parent, + bool is_framework, + bool is_explicit) { + // Get the external AST source which holds the modules. + auto *ast_source = llvm::dyn_cast_or_null( + getASTContext().getExternalSource()); + assert(ast_source && "external ast source was lost"); + if (!ast_source) + return 0; + + // Lazily initialize the module map. + if (!m_header_search_up) { + auto HSOpts = std::make_shared(); + m_header_search_up = std::make_unique( + HSOpts, *m_source_manager_up, *m_diagnostics_engine_up, + *m_language_options_up, m_target_info_up.get()); + m_module_map_up = std::make_unique( + *m_source_manager_up, *m_diagnostics_engine_up, *m_language_options_up, + m_target_info_up.get(), *m_header_search_up); + } + + // Get or create the module context. + bool created; + clang::Module *module; + auto parent_desc = ast_source->getSourceDescriptor(parent); + std::tie(module, created) = m_module_map_up->findOrCreateModule( + name, parent_desc ? parent_desc->getModuleOrNull() : nullptr, + is_framework, is_explicit); + if (!created) + return ast_source->GetIDForModule(module); + + module->Name = name.str(); + return ast_source->RegisterModule(module); +} + +CompilerType TypeSystemClang::CreateRecordType(clang::DeclContext *decl_ctx, + ModuleID owning_module, AccessType access_type, llvm::StringRef name, int kind, LanguageType language, @@ -1201,7 +1277,8 @@ language == eLanguageTypeObjC_plus_plus) { bool isForwardDecl = true; bool isInternal = false; - return CreateObjCClass(name, decl_ctx, isForwardDecl, isInternal, metadata); + return CreateObjCClass(name, decl_ctx, owning_module, isForwardDecl, + isInternal, metadata); } // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and @@ -1216,6 +1293,7 @@ decl->setDeclContext(decl_ctx); if (has_name) decl->setDeclName(&ast.Idents.get(name)); + SetOwningModule(decl, owning_module); if (!has_name) { // In C++ a lambda is also represented as an unnamed class. This is @@ -1327,13 +1405,13 @@ } clang::FunctionTemplateDecl *TypeSystemClang::CreateFunctionTemplateDecl( - clang::DeclContext *decl_ctx, clang::FunctionDecl *func_decl, - const char *name, const TemplateParameterInfos &template_param_infos) { + clang::DeclContext *decl_ctx, ModuleID owning_module, + clang::FunctionDecl *func_decl, const char *name, + const TemplateParameterInfos &template_param_infos) { // /// Create a function template node. ASTContext &ast = getASTContext(); llvm::SmallVector template_param_decls; - TemplateParameterList *template_param_list = CreateTemplateParameterList( ast, template_param_infos, template_param_decls); FunctionTemplateDecl *func_tmpl_decl = @@ -1342,6 +1420,7 @@ func_tmpl_decl->setLocation(func_decl->getLocation()); func_tmpl_decl->setDeclName(func_decl->getDeclName()); func_tmpl_decl->init(func_decl, template_param_list); + SetOwningModule(func_tmpl_decl, owning_module); for (size_t i = 0, template_param_decl_count = template_param_decls.size(); i < template_param_decl_count; ++i) { @@ -1368,8 +1447,9 @@ } ClassTemplateDecl *TypeSystemClang::CreateClassTemplateDecl( - DeclContext *decl_ctx, lldb::AccessType access_type, const char *class_name, - int kind, const TemplateParameterInfos &template_param_infos) { + DeclContext *decl_ctx, ModuleID owning_module, lldb::AccessType access_type, + const char *class_name, int kind, + const TemplateParameterInfos &template_param_infos) { ASTContext &ast = getASTContext(); ClassTemplateDecl *class_template_decl = nullptr; @@ -1397,6 +1477,7 @@ // What decl context do we use here? TU? The actual decl context? template_cxx_decl->setDeclContext(decl_ctx); template_cxx_decl->setDeclName(decl_name); + SetOwningModule(template_cxx_decl, owning_module); for (size_t i = 0, template_param_decl_count = template_param_decls.size(); i < template_param_decl_count; ++i) { @@ -1414,6 +1495,7 @@ class_template_decl->setDeclName(decl_name); class_template_decl->init(template_cxx_decl, template_param_list); template_cxx_decl->setDescribedClassTemplate(class_template_decl); + SetOwningModule(class_template_decl, owning_module); if (class_template_decl) { if (access_type != eAccessNone) @@ -1453,7 +1535,8 @@ ClassTemplateSpecializationDecl * TypeSystemClang::CreateClassTemplateSpecializationDecl( - DeclContext *decl_ctx, ClassTemplateDecl *class_template_decl, int kind, + DeclContext *decl_ctx, ModuleID owning_module, + ClassTemplateDecl *class_template_decl, int kind, const TemplateParameterInfos &template_param_infos) { ASTContext &ast = getASTContext(); llvm::SmallVector args( @@ -1476,6 +1559,7 @@ ast.getTypeDeclType(class_template_specialization_decl, nullptr); class_template_specialization_decl->setDeclName( class_template_decl->getDeclName()); + SetOwningModule(class_template_decl, owning_module); class_template_specialization_decl->setSpecializationKind( TSK_ExplicitSpecialization); @@ -1595,13 +1679,14 @@ #pragma mark Objective-C Classes CompilerType TypeSystemClang::CreateObjCClass(llvm::StringRef name, - DeclContext *decl_ctx, + clang::DeclContext *decl_ctx, + ModuleID owning_module, bool isForwardDecl, bool isInternal, ClangASTMetadata *metadata) { ASTContext &ast = getASTContext(); assert(!name.empty()); - if (decl_ctx == nullptr) + if (!decl_ctx) decl_ctx = ast.getTranslationUnitDecl(); ObjCInterfaceDecl *decl = ObjCInterfaceDecl::CreateDeserialized(ast, 0); @@ -1609,6 +1694,7 @@ decl->setDeclName(&ast.Idents.get(name)); /*isForwardDecl,*/ decl->setImplicit(isInternal); + SetOwningModule(decl, owning_module); if (decl && metadata) SetMetadata(decl, *metadata); @@ -1646,17 +1732,19 @@ #pragma mark Namespace Declarations NamespaceDecl *TypeSystemClang::GetUniqueNamespaceDeclaration( - const char *name, clang::DeclContext *decl_ctx, bool is_inline) { + const char *name, clang::DeclContext *decl_ctx, ModuleID owning_module, + bool is_inline) { NamespaceDecl *namespace_decl = nullptr; ASTContext &ast = getASTContext(); TranslationUnitDecl *translation_unit_decl = ast.getTranslationUnitDecl(); - if (decl_ctx == nullptr) + if (!decl_ctx) decl_ctx = translation_unit_decl; if (name) { IdentifierInfo &identifier_info = ast.Idents.get(name); DeclarationName decl_name(&identifier_info); - clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); + clang::DeclContext::lookup_result result = + decl_ctx->lookup(decl_name); for (NamedDecl *decl : result) { namespace_decl = dyn_cast(decl); if (namespace_decl) @@ -1699,17 +1787,22 @@ } } } + // Note: namespaces can span multiple modules, so perhaps this isn't a good idea. + SetOwningModule(namespace_decl, owning_module); + VerifyDecl(namespace_decl); return namespace_decl; } clang::BlockDecl * -TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx) { +TypeSystemClang::CreateBlockDeclaration(clang::DeclContext *ctx, + ModuleID owning_module) { if (ctx) { clang::BlockDecl *decl = clang::BlockDecl::CreateDeserialized(getASTContext(), 0); decl->setDeclContext(ctx); ctx->addDecl(decl); + SetOwningModule(decl, owning_module); return decl; } return nullptr; @@ -1733,7 +1826,7 @@ } clang::UsingDirectiveDecl *TypeSystemClang::CreateUsingDirectiveDeclaration( - clang::DeclContext *decl_ctx, clang::NamespaceDecl *ns_decl) { + clang::DeclContext *decl_ctx, ModuleID owning_module,clang::NamespaceDecl *ns_decl) { if (decl_ctx && ns_decl) { auto *translation_unit = getASTContext().getTranslationUnitDecl(); clang::UsingDirectiveDecl *using_decl = clang::UsingDirectiveDecl::Create( @@ -1743,6 +1836,7 @@ FindLCABetweenDecls(decl_ctx, ns_decl, translation_unit)); decl_ctx->addDecl(using_decl); + SetOwningModule(using_decl, owning_module); return using_decl; } return nullptr; @@ -1750,14 +1844,17 @@ clang::UsingDecl * TypeSystemClang::CreateUsingDeclaration(clang::DeclContext *current_decl_ctx, + ModuleID owning_module, clang::NamedDecl *target) { - if (current_decl_ctx != nullptr && target != nullptr) { + if (current_decl_ctx && target) { clang::UsingDecl *using_decl = clang::UsingDecl::Create( getASTContext(), current_decl_ctx, clang::SourceLocation(), clang::NestedNameSpecifierLoc(), clang::DeclarationNameInfo(), false); + SetOwningModule(using_decl, owning_module); clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create( getASTContext(), current_decl_ctx, clang::SourceLocation(), using_decl, target); + SetOwningModule(shadow_decl, owning_module); using_decl->addShadowDecl(shadow_decl); current_decl_ctx->addDecl(using_decl); return using_decl; @@ -1766,7 +1863,8 @@ } clang::VarDecl *TypeSystemClang::CreateVariableDeclaration( - clang::DeclContext *decl_context, const char *name, clang::QualType type) { + clang::DeclContext *decl_context, ModuleID owning_module, const char *name, + clang::QualType type) { if (decl_context) { clang::VarDecl *var_decl = clang::VarDecl::CreateDeserialized(getASTContext(), 0); @@ -1774,6 +1872,7 @@ if (name && name[0]) var_decl->setDeclName(&getASTContext().Idents.getOwn(name)); var_decl->setType(type); + SetOwningModule(var_decl, owning_module); var_decl->setAccess(clang::AS_public); decl_context->addDecl(var_decl); return var_decl; @@ -1885,11 +1984,11 @@ } FunctionDecl *TypeSystemClang::CreateFunctionDeclaration( - DeclContext *decl_ctx, const char *name, + clang::DeclContext *decl_ctx, ModuleID owning_module, const char *name, const CompilerType &function_clang_type, int storage, bool is_inline) { FunctionDecl *func_decl = nullptr; ASTContext &ast = getASTContext(); - if (decl_ctx == nullptr) + if (!decl_ctx) decl_ctx = ast.getTranslationUnitDecl(); const bool hasWrittenPrototype = true; @@ -1906,6 +2005,7 @@ func_decl->setHasWrittenPrototype(hasWrittenPrototype); func_decl->setConstexprKind(isConstexprSpecified ? CSK_constexpr : CSK_unspecified); + SetOwningModule(func_decl, owning_module); if (func_decl) decl_ctx->addDecl(func_decl); @@ -1954,7 +2054,7 @@ } ParmVarDecl *TypeSystemClang::CreateParameterDeclaration( - clang::DeclContext *decl_ctx, const char *name, + clang::DeclContext *decl_ctx, ModuleID owning_module, const char *name, const CompilerType ¶m_type, int storage, bool add_decl) { ASTContext &ast = getASTContext(); auto *decl = ParmVarDecl::CreateDeserialized(ast, 0); @@ -1963,6 +2063,7 @@ decl->setDeclName(&ast.Idents.get(name)); decl->setType(ClangUtil::GetQualType(param_type)); decl->setStorageClass(static_cast(storage)); + SetOwningModule(decl, owning_module); if (add_decl) decl_ctx->addDecl(decl); @@ -2024,8 +2125,9 @@ return type; } - type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(), - clang::TTK_Struct, lldb::eLanguageTypeC); + type = CreateRecordType(nullptr, ModuleID(), lldb::eAccessPublic, + type_name.GetCString(), clang::TTK_Struct, + lldb::eLanguageTypeC); StartTagDeclarationDefinition(type); for (const auto &field : type_fields) AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic, @@ -2050,11 +2152,10 @@ #pragma mark Enumeration Types -CompilerType -TypeSystemClang::CreateEnumerationType(const char *name, DeclContext *decl_ctx, - const Declaration &decl, - const CompilerType &integer_clang_type, - bool is_scoped) { +CompilerType TypeSystemClang::CreateEnumerationType( + const char *name, clang::DeclContext *decl_ctx, ModuleID owning_module, + const Declaration &decl, const CompilerType &integer_clang_type, + bool is_scoped) { // TODO: Do something intelligent with the Declaration object passed in // like maybe filling in the SourceLocation with it... ASTContext &ast = getASTContext(); @@ -2068,6 +2169,7 @@ enum_decl->setScoped(is_scoped); enum_decl->setScopedUsingClassTag(is_scoped); enum_decl->setFixed(false); + SetOwningModule(enum_decl, owning_module); if (enum_decl) { if (decl_ctx) decl_ctx->addDecl(enum_decl); @@ -4254,7 +4356,7 @@ CompilerType TypeSystemClang::CreateTypedefType( const CompilerType &type, const char *typedef_name, - const CompilerDeclContext &compiler_decl_ctx) { + const CompilerDeclContext &compiler_decl_ctx, uint32_t payload) { if (type && typedef_name && typedef_name[0]) { TypeSystemClang *ast = llvm::dyn_cast(type.GetTypeSystem()); @@ -4265,7 +4367,7 @@ clang::DeclContext *decl_ctx = TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx); - if (decl_ctx == nullptr) + if (!decl_ctx) decl_ctx = ast->getASTContext().getTranslationUnitDecl(); clang::TypedefDecl *decl = @@ -4274,6 +4376,7 @@ decl->setDeclName(&clang_ast.Idents.get(typedef_name)); decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type)); + SetOwningModule(decl, TypePayloadClang(payload).GetOwningModuleID()); decl->setAccess(clang::AS_public); // TODO respect proper access specifier decl_ctx->addDecl(decl); @@ -4362,24 +4465,23 @@ return CompilerType(); } -CompilerType -TypeSystemClang::CreateTypedef(lldb::opaque_compiler_type_t type, - const char *typedef_name, - const CompilerDeclContext &compiler_decl_ctx) { +CompilerType TypeSystemClang::CreateTypedef( + lldb::opaque_compiler_type_t type, const char *typedef_name, + const CompilerDeclContext &compiler_decl_ctx, uint32_t payload) { if (type) { clang::ASTContext &clang_ast = getASTContext(); clang::QualType qual_type(GetQualType(type)); clang::DeclContext *decl_ctx = TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx); - if (decl_ctx == nullptr) + if (!decl_ctx) decl_ctx = getASTContext().getTranslationUnitDecl(); - clang::TypedefDecl *decl = - clang::TypedefDecl::CreateDeserialized(clang_ast, 0); - decl->setDeclContext(decl_ctx); - decl->setDeclName(&clang_ast.Idents.get(typedef_name)); - decl->setTypeSourceInfo(clang_ast.getTrivialTypeSourceInfo(qual_type)); + clang::TypedefDecl *decl = clang::TypedefDecl::Create( + clang_ast, decl_ctx, clang::SourceLocation(), clang::SourceLocation(), + &clang_ast.Idents.get(typedef_name), + clang_ast.getTrivialTypeSourceInfo(qual_type)); + SetOwningModule(decl, TypePayloadClang(payload).GetOwningModuleID()); clang::TagDecl *tdecl = nullptr; if (!qual_type.isNull()) { @@ -6921,6 +7023,7 @@ field->setType(ClangUtil::GetQualType(field_clang_type)); if (bit_width) field->setBitWidth(bit_width); + SetMemberOwningModule(field, record_decl); if (name.empty()) { // Determine whether this field corresponds to an anonymous struct or @@ -6962,6 +7065,7 @@ ivar->setBitWidth(bit_width); ivar->setSynthesize(is_synthesized); field = ivar; + SetMemberOwningModule(field, class_interface_decl); if (field) { class_interface_decl->addDecl(field); @@ -7023,6 +7127,7 @@ ast->getASTContext(), record_decl, clang::SourceLocation(), nested_field_decl->getIdentifier(), nested_field_decl->getType(), {chain, 2}); + SetMemberOwningModule(indirect_field, record_decl); indirect_field->setImplicit(); @@ -7053,7 +7158,8 @@ nested_indirect_field_decl->getIdentifier(), nested_indirect_field_decl->getType(), {chain, nested_chain_size + 1}); - + SetMemberOwningModule(indirect_field, record_decl); + indirect_field->setImplicit(); indirect_field->setAccess(TypeSystemClang::UnifyAccessSpecifiers( @@ -7119,6 +7225,7 @@ var_decl->setDeclName(ident); var_decl->setType(ClangUtil::GetQualType(var_type)); var_decl->setStorageClass(clang::SC_Static); + SetMemberOwningModule(var_decl, record_decl); if (!var_decl) return nullptr; @@ -7254,6 +7361,7 @@ cxx_method_decl->setConstexprKind(CSK_unspecified); } } + SetMemberOwningModule(cxx_method_decl, cxx_record_decl); clang::AccessSpecifier access_specifier = TypeSystemClang::ConvertAccessTypeToAccessSpecifier(access); @@ -7428,6 +7536,7 @@ ? ivar_decl->getType() : ClangUtil::GetQualType(property_clang_type), prop_type_source); + SetMemberOwningModule(property_decl, class_interface_decl); if (!property_decl) return false; @@ -7519,6 +7628,7 @@ getter->setDefined(isDefined); getter->setDeclImplementation(impControl); getter->setRelatedResultType(HasRelatedResultType); + SetMemberOwningModule(getter, class_interface_decl); if (getter) { if (metadata) @@ -7560,6 +7670,7 @@ setter->setDefined(isDefined); setter->setDeclImplementation(impControl); setter->setRelatedResultType(HasRelatedResultType); + SetMemberOwningModule(setter, class_interface_decl); if (setter) { if (metadata) @@ -7688,6 +7799,7 @@ objc_method_decl->setDefined(isDefined); objc_method_decl->setDeclImplementation(impControl); objc_method_decl->setRelatedResultType(HasRelatedResultType); + SetMemberOwningModule(objc_method_decl, class_interface_decl); if (objc_method_decl == nullptr) return nullptr; @@ -7918,6 +8030,7 @@ enumerator_decl->setDeclName(&getASTContext().Idents.get(name)); enumerator_decl->setType(clang::QualType(enutype, 0)); enumerator_decl->setInitVal(value); + SetMemberOwningModule(enumerator_decl, enutype->getDecl()); if (!enumerator_decl) return nullptr; @@ -8812,14 +8925,14 @@ } clang::ClassTemplateDecl *TypeSystemClang::ParseClassTemplateDecl( - clang::DeclContext *decl_ctx, lldb::AccessType access_type, - const char *parent_name, int tag_decl_kind, + clang::DeclContext *decl_ctx, ModuleID owning_module, + lldb::AccessType access_type, const char *parent_name, int tag_decl_kind, const TypeSystemClang::TemplateParameterInfos &template_param_infos) { if (template_param_infos.IsValid()) { std::string template_basename(parent_name); template_basename.erase(template_basename.find('<')); - return CreateClassTemplateDecl(decl_ctx, access_type, + return CreateClassTemplateDecl(decl_ctx, owning_module, access_type, template_basename.c_str(), tag_decl_kind, template_param_infos); } Index: lldb/source/Symbol/CompilerType.cpp =================================================================== --- lldb/source/Symbol/CompilerType.cpp +++ lldb/source/Symbol/CompilerType.cpp @@ -439,11 +439,11 @@ return CompilerType(); } -CompilerType -CompilerType::CreateTypedef(const char *name, - const CompilerDeclContext &decl_ctx) const { +CompilerType CompilerType::CreateTypedef(const char *name, + const CompilerDeclContext &decl_ctx, + uint32_t payload) const { if (IsValid()) - return m_type_system->CreateTypedef(m_type, name, decl_ctx); + return m_type_system->CreateTypedef(m_type, name, decl_ctx, payload); else return CompilerType(); } Index: lldb/source/Symbol/Type.cpp =================================================================== --- lldb/source/Symbol/Type.cpp +++ lldb/source/Symbol/Type.cpp @@ -505,7 +505,7 @@ case eEncodingIsTypedefUID: m_compiler_type = encoding_type->GetForwardCompilerType().CreateTypedef( m_name.AsCString("__lldb_invalid_typedef_name"), - GetSymbolFile()->GetDeclContextContainingUID(GetID())); + GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload); m_name.Clear(); break; @@ -563,7 +563,7 @@ case eEncodingIsTypedefUID: m_compiler_type = void_compiler_type.CreateTypedef( m_name.AsCString("__lldb_invalid_typedef_name"), - GetSymbolFile()->GetDeclContextContainingUID(GetID())); + GetSymbolFile()->GetDeclContextContainingUID(GetID()), m_payload); break; case eEncodingIsPointerUID: Index: lldb/source/Symbol/TypeSystem.cpp =================================================================== --- lldb/source/Symbol/TypeSystem.cpp +++ lldb/source/Symbol/TypeSystem.cpp @@ -113,7 +113,8 @@ CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type, const char *name, - const CompilerDeclContext &decl_ctx) { + const CompilerDeclContext &decl_ctx, + uint32_t opaque_payload) { return CompilerType(); } Index: lldb/unittests/Symbol/TestTypeSystemClang.cpp =================================================================== --- lldb/unittests/Symbol/TestTypeSystemClang.cpp +++ lldb/unittests/Symbol/TestTypeSystemClang.cpp @@ -14,6 +14,7 @@ #include "lldb/Host/HostInfo.h" #include "lldb/Symbol/Declaration.h" #include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclObjC.h" #include "clang/AST/ExprCXX.h" #include "gtest/gtest.h" @@ -257,9 +258,10 @@ CompilerType basic_compiler_type = ast.GetBasicType(basic_type); EXPECT_TRUE(basic_compiler_type.IsValid()); - CompilerType enum_type = - ast.CreateEnumerationType("my_enum", ast.GetTranslationUnitDecl(), - Declaration(), basic_compiler_type, scoped); + CompilerType enum_type = ast.CreateEnumerationType( + "my_enum", ast.GetTranslationUnitDecl(), ModuleID(), Declaration(), + basic_compiler_type, scoped); + CompilerType t = ast.GetEnumerationIntegerType(enum_type); // Check that the type we put in at the start is found again. EXPECT_EQ(basic_compiler_type.GetTypeName(), t.GetTypeName()); @@ -267,14 +269,38 @@ } } +TEST_F(TestTypeSystemClang, TestOwningModule) { + TypeSystemClang ast("module_ast", HostInfo::GetTargetTriple()); + CompilerType basic_compiler_type = ast.GetBasicType(BasicType::eBasicTypeInt); + CompilerType enum_type = ast.CreateEnumerationType( + "my_enum", ast.GetTranslationUnitDecl(), ModuleID(100), Declaration(), + basic_compiler_type, false); + auto *ed = TypeSystemClang::GetAsEnumDecl(enum_type); + EXPECT_FALSE(!ed); + EXPECT_EQ(ed->getOwningModuleID(), 100u); + + CompilerType record_type = ast.CreateRecordType( + nullptr, ModuleID(200), lldb::eAccessPublic, "FooRecord", + clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); + auto *rd = TypeSystemClang::GetAsRecordDecl(record_type); + EXPECT_FALSE(!rd); + EXPECT_EQ(rd->getOwningModuleID(), 200u); + + CompilerType class_type = ast.CreateObjCClass( + "objc_class", ast.GetTranslationUnitDecl(), ModuleID(300), false, false); + auto *cd = TypeSystemClang::GetAsObjCInterfaceDecl(class_type); + EXPECT_FALSE(!cd); + EXPECT_EQ(cd->getOwningModuleID(), 300u); +} + TEST_F(TestTypeSystemClang, TestIsClangType) { clang::ASTContext &context = m_ast->getASTContext(); lldb::opaque_compiler_type_t bool_ctype = TypeSystemClang::GetOpaqueCompilerType(&context, lldb::eBasicTypeBool); CompilerType bool_type(m_ast.get(), bool_ctype); CompilerType record_type = m_ast->CreateRecordType( - nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct, - lldb::eLanguageTypeC_plus_plus, nullptr); + nullptr, ModuleID(100), lldb::eAccessPublic, "FooRecord", + clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); // Clang builtin type and record type should pass EXPECT_TRUE(ClangUtil::IsClangType(bool_type)); EXPECT_TRUE(ClangUtil::IsClangType(record_type)); @@ -285,7 +311,7 @@ TEST_F(TestTypeSystemClang, TestRemoveFastQualifiers) { CompilerType record_type = m_ast->CreateRecordType( - nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct, + nullptr, ModuleID(), lldb::eAccessPublic, "FooRecord", clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); QualType qt; @@ -357,7 +383,7 @@ // Test that a record with no fields returns false CompilerType empty_base = m_ast->CreateRecordType( - nullptr, lldb::eAccessPublic, "EmptyBase", clang::TTK_Struct, + nullptr, ModuleID(), lldb::eAccessPublic, "EmptyBase", clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); TypeSystemClang::StartTagDeclarationDefinition(empty_base); TypeSystemClang::CompleteTagDeclarationDefinition(empty_base); @@ -368,8 +394,8 @@ // Test that a record with direct fields returns true CompilerType non_empty_base = m_ast->CreateRecordType( - nullptr, lldb::eAccessPublic, "NonEmptyBase", clang::TTK_Struct, - lldb::eLanguageTypeC_plus_plus, nullptr); + nullptr, ModuleID(), lldb::eAccessPublic, "NonEmptyBase", + clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); TypeSystemClang::StartTagDeclarationDefinition(non_empty_base); FieldDecl *non_empty_base_field_decl = m_ast->AddFieldToRecordType( non_empty_base, "MyField", int_type, eAccessPublic, 0); @@ -384,8 +410,8 @@ // Test that a record with no direct fields, but fields in a base returns true CompilerType empty_derived = m_ast->CreateRecordType( - nullptr, lldb::eAccessPublic, "EmptyDerived", clang::TTK_Struct, - lldb::eLanguageTypeC_plus_plus, nullptr); + nullptr, ModuleID(), lldb::eAccessPublic, "EmptyDerived", + clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); TypeSystemClang::StartTagDeclarationDefinition(empty_derived); std::unique_ptr non_empty_base_spec = m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(), @@ -407,8 +433,8 @@ // Test that a record with no direct fields, but fields in a virtual base // returns true CompilerType empty_derived2 = m_ast->CreateRecordType( - nullptr, lldb::eAccessPublic, "EmptyDerived2", clang::TTK_Struct, - lldb::eLanguageTypeC_plus_plus, nullptr); + nullptr, ModuleID(), lldb::eAccessPublic, "EmptyDerived2", + clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr); TypeSystemClang::StartTagDeclarationDefinition(empty_derived2); std::unique_ptr non_empty_vbase_spec = m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(), @@ -439,13 +465,14 @@ // template struct foo; ClassTemplateDecl *decl = m_ast->CreateClassTemplateDecl( - m_ast->GetTranslationUnitDecl(), eAccessPublic, "foo", TTK_Struct, infos); + m_ast->GetTranslationUnitDecl(), ModuleID(), eAccessPublic, "foo", + TTK_Struct, infos); ASSERT_NE(decl, nullptr); // foo ClassTemplateSpecializationDecl *spec_decl = m_ast->CreateClassTemplateSpecializationDecl( - m_ast->GetTranslationUnitDecl(), decl, TTK_Struct, infos); + m_ast->GetTranslationUnitDecl(), ModuleID(), decl, TTK_Struct, infos); ASSERT_NE(spec_decl, nullptr); CompilerType type = m_ast->CreateClassTemplateSpecializationType(spec_decl); ASSERT_TRUE(type); @@ -454,7 +481,8 @@ // typedef foo foo_def; CompilerType typedef_type = m_ast->CreateTypedefType( - type, "foo_def", m_ast->CreateDeclContext(m_ast->GetTranslationUnitDecl())); + type, "foo_def", + m_ast->CreateDeclContext(m_ast->GetTranslationUnitDecl()), 0); CompilerType auto_type( m_ast.get(), @@ -528,13 +556,14 @@ // Prepare the declarations/types we need for the template. CompilerType clang_type = m_ast->CreateFunctionType(int_type, nullptr, 0U, false, 0U); - FunctionDecl *func = - m_ast->CreateFunctionDeclaration(TU, "foo", clang_type, 0, false); + FunctionDecl *func = m_ast->CreateFunctionDeclaration(TU, ModuleID(), "foo", + clang_type, 0, false); TypeSystemClang::TemplateParameterInfos empty_params; // Create the actual function template. clang::FunctionTemplateDecl *func_template = - m_ast->CreateFunctionTemplateDecl(TU, func, "foo", empty_params); + m_ast->CreateFunctionTemplateDecl(TU, ModuleID(), func, "foo", + empty_params); EXPECT_EQ(TU, func_template->getDeclContext()); EXPECT_EQ("foo", func_template->getName()); @@ -558,13 +587,14 @@ // We create the FunctionDecl for the template in the TU DeclContext because: // 1. FunctionDecls can't be in a Record (only CXXMethodDecls can). // 2. It is mirroring the behavior of DWARFASTParserClang::ParseSubroutine. - FunctionDecl *func = - m_ast->CreateFunctionDeclaration(TU, "foo", clang_type, 0, false); + FunctionDecl *func = m_ast->CreateFunctionDeclaration(TU, ModuleID(), "foo", + clang_type, 0, false); TypeSystemClang::TemplateParameterInfos empty_params; // Create the actual function template. clang::FunctionTemplateDecl *func_template = - m_ast->CreateFunctionTemplateDecl(record, func, "foo", empty_params); + m_ast->CreateFunctionTemplateDecl(record, ModuleID(), func, "foo", + empty_params); EXPECT_EQ(record, func_template->getDeclContext()); EXPECT_EQ("foo", func_template->getName()); Index: lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h =================================================================== --- lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h +++ lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h @@ -28,8 +28,8 @@ inline CompilerType createRecord(TypeSystemClang &ast, llvm::StringRef name) { return ast.CreateRecordType(ast.getASTContext().getTranslationUnitDecl(), - lldb::AccessType::eAccessPublic, name, 0, - lldb::LanguageType::eLanguageTypeC); + ModuleID(), lldb::AccessType::eAccessPublic, name, + 0, lldb::LanguageType::eLanguageTypeC); } /// Create a record with the given name and a field with the given type