From e6b36cdd4d571c91081e2d5f8c0b31830093d110 Mon Sep 17 00:00:00 2001 From: Greg Clayton Date: Tue, 8 Dec 2015 01:02:08 +0000 Subject: [PATCH] Trying to submit 254476 one more time. This implement -gmodule debugging support. It was previously reverted due to issues that showed up only on linux. I was able to reproduce these issues and fix the underlying cause. So this is the same patch as 254476 with the following two fixes: - Fix not trying to complete classes that don't have external sources - Fix ClangASTSource::CompleteType() to check the decl context of types that it finds by basename to ensure we don't complete a type "S" with a type like "std::S". Before this fix ClangASTSource::CompleteType() would accept _any_ type that had a matching basename and copy it into the other type. llvm-svn: 254980 --- lldb/include/lldb/Symbol/ClangASTContext.h | 42 +- lldb/include/lldb/Symbol/ClangASTImporter.h | 11 +- .../Symbol/ClangExternalASTSourceCallbacks.h | 5 + lldb/include/lldb/Symbol/SymbolFile.h | 3 +- lldb/include/lldb/Symbol/SymbolVendor.h | 3 + lldb/include/lldb/Symbol/Type.h | 28 + lldb/include/lldb/lldb-forward.h | 1 + lldb/include/lldb/lldb-private-enumerations.h | 19 + .../TestCppIncompleteTypes.py | 4 +- .../ExpressionParser/Clang/ClangASTSource.cpp | 5 + .../Plugins/SymbolFile/DWARF/DWARFASTParser.h | 12 + .../SymbolFile/DWARF/DWARFASTParserClang.cpp | 241 ++++++- .../SymbolFile/DWARF/DWARFASTParserClang.h | 20 + .../Plugins/SymbolFile/DWARF/DWARFDIE.cpp | 86 +++ .../Plugins/SymbolFile/DWARF/DWARFDIE.h | 9 + .../SymbolFile/DWARF/SymbolFileDWARF.cpp | 175 ++++- .../SymbolFile/DWARF/SymbolFileDWARF.h | 15 +- lldb/source/Symbol/ClangASTContext.cpp | 664 +++++++++++++++--- lldb/source/Symbol/ClangASTImporter.cpp | 97 ++- .../ClangExternalASTSourceCallbacks.cpp | 14 + lldb/source/Symbol/SymbolFile.cpp | 8 + lldb/source/Symbol/SymbolVendor.cpp | 15 + lldb/source/Symbol/Type.cpp | 34 +- 23 files changed, 1323 insertions(+), 188 deletions(-) diff --git a/lldb/include/lldb/Symbol/ClangASTContext.h b/lldb/include/lldb/Symbol/ClangASTContext.h index 738d450a81d2..c8ff7458d055 100644 --- a/lldb/include/lldb/Symbol/ClangASTContext.h +++ b/lldb/include/lldb/Symbol/ClangASTContext.h @@ -151,7 +151,16 @@ public: { return ClangASTContext::GetCompleteDecl(getASTContext(), decl); } - + + static void + DumpDeclHiearchy (clang::Decl *decl); + + static void + DumpDeclContextHiearchy (clang::DeclContext *decl_ctx); + + static bool + DeclsAreEquivalent (clang::Decl *lhs_decl, clang::Decl *rhs_decl); + static bool GetCompleteDecl (clang::ASTContext *ast, clang::Decl *decl); @@ -1006,10 +1015,18 @@ public: lldb::AccessType access, bool is_artificial); - bool + static bool SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern); - + + static bool + CanImport (const CompilerType &type, lldb_private::ClangASTImporter &importer); + + static bool + Import (const CompilerType &type, lldb_private::ClangASTImporter &importer); + + static bool + GetHasExternalStorage (const CompilerType &type); //------------------------------------------------------------------ // Tag Declarations //------------------------------------------------------------------ @@ -1092,13 +1109,19 @@ public: void DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream *s) override; - + + static void + DumpTypeName (const CompilerType &type); + static clang::EnumDecl * GetAsEnumDecl (const CompilerType& type); static clang::RecordDecl * GetAsRecordDecl (const CompilerType& type); - + + static clang::TagDecl * + GetAsTagDecl (const CompilerType& type); + clang::CXXRecordDecl * GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type); @@ -1109,9 +1132,12 @@ public: GetQualType (const CompilerType& type) { // Make sure we have a clang type before making a clang::QualType - ClangASTContext *ast = llvm::dyn_cast_or_null(type.GetTypeSystem()); - if (ast) - return clang::QualType::getFromOpaquePtr(type.GetOpaqueQualType()); + if (type.GetOpaqueQualType()) + { + ClangASTContext *ast = llvm::dyn_cast_or_null(type.GetTypeSystem()); + if (ast) + return clang::QualType::getFromOpaquePtr(type.GetOpaqueQualType()); + } return clang::QualType(); } diff --git a/lldb/include/lldb/Symbol/ClangASTImporter.h b/lldb/include/lldb/Symbol/ClangASTImporter.h index e5155023a105..8c3f8735c2e1 100644 --- a/lldb/include/lldb/Symbol/ClangASTImporter.h +++ b/lldb/include/lldb/Symbol/ClangASTImporter.h @@ -107,7 +107,11 @@ public: CopyType (clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx, lldb::opaque_compiler_type_t type); - + + CompilerType + CopyType (ClangASTContext &dst, + const CompilerType &src_type); + clang::Decl * CopyDecl (clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx, @@ -134,7 +138,10 @@ public: bool CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl); - + + bool + CompleteAndFetchChildren (clang::QualType type); + bool RequireCompleteType (clang::QualType type); diff --git a/lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h b/lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h index bf2018fd48c4..5a00aa0072ab 100644 --- a/lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h +++ b/lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h @@ -97,6 +97,11 @@ public: { } + void + FindExternalLexicalDecls(const clang::DeclContext *DC, + llvm::function_ref IsKindWeWant, + llvm::SmallVectorImpl &Result) override; + bool FindExternalVisibleDeclsByName(const clang::DeclContext *decl_ctx, clang::DeclarationName decl_name) override; void CompleteType(clang::TagDecl *tag_decl) override; diff --git a/lldb/include/lldb/Symbol/SymbolFile.h b/lldb/include/lldb/Symbol/SymbolFile.h index f6c3ac00bcde..3ead79d6fc4b 100644 --- a/lldb/include/lldb/Symbol/SymbolFile.h +++ b/lldb/include/lldb/Symbol/SymbolFile.h @@ -15,7 +15,6 @@ #include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerDecl.h" #include "lldb/Symbol/CompilerDeclContext.h" - #include "lldb/Symbol/Type.h" namespace lldb_private { @@ -142,6 +141,8 @@ public: virtual uint32_t FindFunctions (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list); virtual uint32_t FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list); virtual uint32_t FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types); + virtual size_t FindTypes (const std::vector &context, bool append, TypeMap& types); + // virtual uint32_t FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, TypeList& types) = 0; virtual TypeList * GetTypeList (); virtual size_t GetTypes (lldb_private::SymbolContextScope *sc_scope, diff --git a/lldb/include/lldb/Symbol/SymbolVendor.h b/lldb/include/lldb/Symbol/SymbolVendor.h index e57e8e3d0509..c57ac8800c47 100644 --- a/lldb/include/lldb/Symbol/SymbolVendor.h +++ b/lldb/include/lldb/Symbol/SymbolVendor.h @@ -128,6 +128,9 @@ public: size_t max_matches, TypeMap& types); + virtual size_t + FindTypes (const std::vector &context, bool append, TypeMap& types); + virtual CompilerDeclContext FindNamespace (const SymbolContext& sc, const ConstString &name, diff --git a/lldb/include/lldb/Symbol/Type.h b/lldb/include/lldb/Symbol/Type.h index a96a8e2b0a1d..224e0a112df3 100644 --- a/lldb/include/lldb/Symbol/Type.h +++ b/lldb/include/lldb/Symbol/Type.h @@ -24,6 +24,31 @@ namespace lldb_private { +//---------------------------------------------------------------------- +// CompilerContext allows an array of these items to be passed to +// perform detailed lookups in SymbolVendor and SymbolFile functions. +//---------------------------------------------------------------------- +struct CompilerContext +{ + CompilerContext (CompilerContextKind t, const ConstString &n) : + type(t), + name(n) + { + } + + bool + operator == (const CompilerContext &rhs) const + { + return type == rhs.type && name == rhs.name; + } + + void + Dump () const; + + CompilerContextKind type; + ConstString name; +}; + class SymbolFileType : public std::enable_shared_from_this, public UserID @@ -35,6 +60,9 @@ class SymbolFileType : { } + SymbolFileType (SymbolFile &symbol_file, const lldb::TypeSP &type_sp); + + ~SymbolFileType () { } diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index e494b297d11c..516f31911c2b 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -62,6 +62,7 @@ class CommandObject; class CommandReturnObject; class Communication; class CompactUnwindInfo; +struct CompilerContext; class CompilerDecl; class CompilerDeclContext; class CompilerType; diff --git a/lldb/include/lldb/lldb-private-enumerations.h b/lldb/include/lldb/lldb-private-enumerations.h index ef69fabd6f18..5f8f96c6da46 100644 --- a/lldb/include/lldb/lldb-private-enumerations.h +++ b/lldb/include/lldb/lldb-private-enumerations.h @@ -241,6 +241,25 @@ enum class TypeValidatorResult : bool { Success = true, Failure = false }; + +//---------------------------------------------------------------------- +// Enumerations that can be used to specify scopes types when looking up +// types. +//---------------------------------------------------------------------- +enum class CompilerContextKind +{ + Invalid = 0, + TranslationUnit, + Module, + Namespace, + Class, + Structure, + Union, + Function, + Variable, + Enumeration, + Typedef +}; } // namespace lldb_private diff --git a/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py b/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py index 69ea26edbdff..324f476efb9b 100644 --- a/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py +++ b/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py @@ -14,11 +14,11 @@ class TestCppIncompleteTypes(TestBase): value_f = frame.EvaluateExpression("f") self.assertTrue(value_f.IsValid(), "'expr f' results in a valid SBValue object") - self.assertFalse(value_f.GetError().Success(), "'expr f' results in an error, but LLDB does not crash") + self.assertTrue(value_f.GetError().Success(), "'expr f' is successful") value_a = frame.EvaluateExpression("a") self.assertTrue(value_a.IsValid(), "'expr a' results in a valid SBValue object") - self.assertFalse(value_a.GetError().Success(), "'expr a' results in an error, but LLDB does not crash") + self.assertTrue(value_a.GetError().Success(), "'expr a' is successful") @skipIfGcc @skipIfWindows # Clang on Windows asserts in external record layout in this case. diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp index d29cb3eaa664..d2ea4390560a 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp @@ -322,6 +322,11 @@ ClangASTSource::CompleteType (TagDecl *tag_decl) TagDecl *candidate_tag_decl = const_cast(tag_type->getDecl()); + // We have found a type by basename and we need to make sure the decl contexts + // are the same before we can try to complete this type with another + if (!ClangASTContext::DeclsAreEquivalent (tag_decl, candidate_tag_decl)) + continue; + if (m_ast_importer_sp->CompleteTagDeclWithOrigin (tag_decl, candidate_tag_decl)) found = true; } diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h index 2fb360440f63..ab20844bfcfd 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h @@ -32,6 +32,18 @@ public: ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc, const DWARFDIE &die) = 0; + virtual bool + CanCompleteType (const lldb_private::CompilerType &compiler_type) + { + return false; + } + + virtual bool + CompleteType (const lldb_private::CompilerType &compiler_type) + { + return false; + } + virtual bool CompleteTypeFromDWARF (const DWARFDIE &die, lldb_private::Type *type, diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp index caa8c63f8adc..68a0285b69df 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp @@ -24,11 +24,14 @@ #include "lldb/Core/StreamString.h" #include "lldb/Core/Value.h" #include "lldb/Host/Host.h" +#include "lldb/Symbol/ClangASTImporter.h" #include "lldb/Symbol/ClangExternalASTSourceCommon.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/Function.h" #include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/TypeList.h" +#include "lldb/Symbol/TypeMap.h" #include "lldb/Target/Language.h" #include "Plugins/Language/ObjC/ObjCLanguage.h" @@ -114,6 +117,78 @@ struct BitfieldInfo } }; + +ClangASTImporter & +DWARFASTParserClang::GetClangASTImporter() +{ + if (!m_clang_ast_importer_ap) + { + m_clang_ast_importer_ap.reset (new ClangASTImporter); + } + return *m_clang_ast_importer_ap; +} + + +TypeSP +DWARFASTParserClang::ParseTypeFromDWO (const DWARFDIE &die, Log *log) +{ + ModuleSP dwo_module_sp = die.GetContainingDWOModule(); + if (dwo_module_sp) + { + // This type comes from an external DWO module + std::vector dwo_context; + die.GetDWOContext(dwo_context); + TypeMap dwo_types; + if (dwo_module_sp->GetSymbolVendor()->FindTypes(dwo_context, true, dwo_types)) + { + const size_t num_dwo_types = dwo_types.GetSize(); + if (num_dwo_types == 1) + { + // We found a real definition for this type elsewhere + // so lets use it and cache the fact that we found + // a complete type for this die + TypeSP dwo_type_sp = dwo_types.GetTypeAtIndex(0); + if (dwo_type_sp) + { + lldb_private::CompilerType dwo_type = dwo_type_sp->GetForwardCompilerType(); + + lldb_private::CompilerType type = GetClangASTImporter().CopyType (m_ast, dwo_type); + + //printf ("copied_qual_type: ast = %p, clang_type = %p, name = '%s'\n", m_ast, copied_qual_type.getAsOpaquePtr(), external_type->GetName().GetCString()); + if (type) + { + SymbolFileDWARF *dwarf = die.GetDWARF(); + TypeSP type_sp (new Type (die.GetID(), + dwarf, + dwo_type_sp->GetName(), + dwo_type_sp->GetByteSize(), + NULL, + LLDB_INVALID_UID, + Type::eEncodingInvalid, + &dwo_type_sp->GetDeclaration(), + type, + Type::eResolveStateForward)); + + dwarf->GetTypeList()->Insert(type_sp); + dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); + clang::TagDecl *tag_decl = ClangASTContext::GetAsTagDecl(type); + if (tag_decl) + LinkDeclContextToDIE(tag_decl, die); + else + { + clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die); + if (defn_decl_ctx) + LinkDeclContextToDIE(defn_decl_ctx, die); + } + return type_sp; + } + } + } + } + } + return TypeSP(); +} + TypeSP DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc, const DWARFDIE &die, @@ -487,15 +562,15 @@ DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc, if (dwarf->GetUniqueDWARFASTTypeMap().Find(type_name_const_str, die, decl, byte_size_valid ? byte_size : -1, *unique_ast_entry_ap)) - { - type_sp = unique_ast_entry_ap->m_type_sp; - if (type_sp) { - dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); - return type_sp; + type_sp = unique_ast_entry_ap->m_type_sp; + if (type_sp) + { + dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); + return type_sp; + } } } - } } DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr); @@ -600,6 +675,11 @@ DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc, type_name_cstr); } + // See if the type comes from a DWO module and if so, track down that type. + type_sp = ParseTypeFromDWO(die, log); + if (type_sp) + return type_sp; + DWARFDeclContext die_decl_ctx; die.GetDWARFDeclContext(die_decl_ctx); @@ -833,7 +913,7 @@ DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc, case DW_AT_type: encoding_form = form_value; break; case DW_AT_byte_size: byte_size = form_value.Unsigned(); break; case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break; - case DW_AT_declaration: break; //is_forward_declaration = form_value.Boolean(); break; + case DW_AT_declaration: is_forward_declaration = form_value.Boolean(); break; case DW_AT_allocated: case DW_AT_associated: case DW_AT_bit_stride: @@ -850,6 +930,54 @@ DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc, } } + if (is_forward_declaration) + { + type_sp = ParseTypeFromDWO(die, log); + if (type_sp) + return type_sp; + + DWARFDeclContext die_decl_ctx; + die.GetDWARFDeclContext(die_decl_ctx); + + type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx); + + if (!type_sp) + { + SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile(); + if (debug_map_symfile) + { + // We weren't able to find a full declaration in + // this DWARF, see if we have a declaration anywhere + // else... + type_sp = debug_map_symfile->FindDefinitionTypeForDWARFDeclContext (die_decl_ctx); + } + } + + if (type_sp) + { + if (log) + { + dwarf->GetObjectFile()->GetModule()->LogMessage (log, + "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a forward declaration, complete type is 0x%8.8" PRIx64, + static_cast(this), + die.GetOffset(), + DW_TAG_value_to_name(tag), + type_name_cstr, + type_sp->GetID()); + } + + // We found a real definition for this type elsewhere + // so lets use it and cache the fact that we found + // a complete type for this die + dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get(); + clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE( + dwarf->DebugInfo()->GetDIE(DIERef(type_sp->GetID()))); + if (defn_decl_ctx) + LinkDeclContextToDIE(defn_decl_ctx, die); + return type_sp; + } + + } DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr); CompilerType enumerator_clang_type; @@ -1130,7 +1258,7 @@ DWARFASTParserClang::ParseTypeFromDWARF (const SymbolContext& sc, if (class_type) { bool alternate_defn = false; - if (class_type->GetID() != decl_ctx_die.GetID()) + if (class_type->GetID() != decl_ctx_die.GetID() || decl_ctx_die.GetContainingDWOModuleDIE()) { alternate_defn = true; @@ -1797,6 +1925,33 @@ DWARFASTParserClang::ParseTemplateParameterInfos (const DWARFDIE &parent_die, return template_param_infos.args.size() == template_param_infos.names.size(); } +bool +DWARFASTParserClang::CanCompleteType (const lldb_private::CompilerType &compiler_type) +{ + if (m_clang_ast_importer_ap) + return ClangASTContext::CanImport(compiler_type, GetClangASTImporter()); + else + return false; +} + +bool +DWARFASTParserClang::CompleteType (const lldb_private::CompilerType &compiler_type) +{ + if (CanCompleteType(compiler_type)) + { + if (ClangASTContext::Import(compiler_type, GetClangASTImporter())) + { + ClangASTContext::CompleteTagDeclarationDefinition(compiler_type); + return true; + } + else + { + ClangASTContext::SetHasExternalStorage (compiler_type.GetOpaqueQualType(), false); + } + } + return false; +} + bool DWARFASTParserClang::CompleteTypeFromDWARF (const DWARFDIE &die, lldb_private::Type *type, @@ -1868,25 +2023,17 @@ DWARFASTParserClang::CompleteTypeFromDWARF (const DWARFDIE &die, DWARFDIECollection member_function_dies; DelayedPropertyList delayed_properties; - if (!ParseChildMembers (sc, - die, - clang_type, - class_language, - base_classes, - member_accessibilities, - member_function_dies, - delayed_properties, - default_accessibility, - is_a_class, - layout_info)) - { - auto module = dwarf->GetObjectFile()->GetModule(); - module->ReportError (":: Class %s has members with incomplete type.", die.GetName()); - if (die.GetCU()->GetProducer() == DWARFCompileUnit::eProducerClang) - module->ReportError(":: Try compiling the source file with -fno-limit-debug-info."); - - return false; - } + ParseChildMembers (sc, + die, + clang_type, + class_language, + base_classes, + member_accessibilities, + member_function_dies, + delayed_properties, + default_accessibility, + is_a_class, + layout_info); // Now parse any methods if there were any... size_t num_functions = member_function_dies.Size(); @@ -1977,7 +2124,14 @@ DWARFASTParserClang::CompleteTypeFromDWARF (const DWARFDIE &die, if (die.GetCU()->GetProducer() == DWARFCompileUnit::eProducerClang) module->ReportError (":: Try compiling the source file with -fno-limit-debug-info."); - return false; + // We have no choice other than to pretend that the base class + // is complete. If we don't do this, clang will crash when we + // call setBases() inside of "clang_type.SetBaseClassesForClassType()" + // below. Since we provide layout assistance, all ivars in this + // class and other classes will be fine, this is the best we can do + // short of crashing. + ClangASTContext::StartTagDeclarationDefinition (base_class_type); + ClangASTContext::CompleteTagDeclarationDefinition (base_class_type); } } } @@ -2420,7 +2574,6 @@ DWARFASTParserClang::ParseChildMembers (const SymbolContext& sc, if (!parent_die) return 0; - uint32_t incomplete_member_info_count = 0; uint32_t member_idx = 0; BitfieldInfo last_field_info; @@ -2754,8 +2907,8 @@ DWARFASTParserClang::ParseChildMembers (const SymbolContext& sc, } CompilerType member_clang_type = member_type->GetLayoutCompilerType (); - if (!member_clang_type.IsCompleteType() && !member_clang_type.GetCompleteType()) - incomplete_member_info_count += 1; + if (!member_clang_type.IsCompleteType()) + member_clang_type.GetCompleteType(); { // Older versions of clang emit array[0] and array[1] in the same way (). @@ -2789,6 +2942,30 @@ DWARFASTParserClang::ParseChildMembers (const SymbolContext& sc, } } + if (ClangASTContext::IsCXXClassType(member_clang_type) && member_clang_type.GetCompleteType() == false) + { + if (die.GetCU()->GetProducer() == DWARFCompileUnit::eProducerClang) + module_sp->ReportError ("DWARF DIE at 0x%8.8x (class %s) has a member variable 0x%8.8x (%s) whose type is a forward declaration, not a complete definition.\nTry compiling the source file with -fno-limit-debug-info", + parent_die.GetOffset(), + parent_die.GetName(), + die.GetOffset(), + name); + else + module_sp->ReportError ("DWARF DIE at 0x%8.8x (class %s) has a member variable 0x%8.8x (%s) whose type is a forward declaration, not a complete definition.\nPlease file a bug against the compiler and include the preprocessed output for %s", + parent_die.GetOffset(), + parent_die.GetName(), + die.GetOffset(), + name, + sc.comp_unit ? sc.comp_unit->GetPath().c_str() : "the source file"); + // We have no choice other than to pretend that the member class + // is complete. If we don't do this, clang will crash when trying + // to layout the class. Since we provide layout assistance, all + // ivars in this class and other classes will be fine, this is + // the best we can do short of crashing. + ClangASTContext::StartTagDeclarationDefinition(member_clang_type); + ClangASTContext::CompleteTagDeclarationDefinition(member_clang_type); + } + field_decl = ClangASTContext::AddFieldToRecordType (class_clang_type, name, member_clang_type, @@ -2978,7 +3155,7 @@ DWARFASTParserClang::ParseChildMembers (const SymbolContext& sc, } } - return incomplete_member_info_count == 0; + return true; } diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h index e46972e261b1..3814758fdd2c 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h @@ -46,6 +46,12 @@ public: ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc, const DWARFDIE &die) override; + bool + CanCompleteType (const lldb_private::CompilerType &compiler_type) override; + + bool + CompleteType (const lldb_private::CompilerType &compiler_type) override; + bool CompleteTypeFromDWARF (const DWARFDIE &die, lldb_private::Type *type, @@ -175,6 +181,19 @@ protected: void LinkDeclToDIE (clang::Decl *decl, const DWARFDIE &die); + lldb_private::ClangASTImporter & + GetClangASTImporter(); + + lldb::TypeSP + ParseTypeFromDWO (const DWARFDIE &die, lldb_private::Log *log); + + //---------------------------------------------------------------------- + // Return true if this type is a declaration to a type in an external + // module. + //---------------------------------------------------------------------- + lldb::ModuleSP + GetModuleForType (const DWARFDIE &die); + typedef llvm::SmallPtrSet DIEPointerSet; typedef llvm::DenseMap DIEToDeclContextMap; //typedef llvm::DenseMap DeclContextToDIEMap; @@ -188,6 +207,7 @@ protected: DIEToDeclContextMap m_die_to_decl_ctx; DeclContextToDIEMap m_decl_ctx_to_die; RecordDeclToLayoutMap m_record_decl_to_layout_map; + std::unique_ptr m_clang_ast_importer_ap; }; #endif // SymbolFileDWARF_DWARFASTParserClang_h_ diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp index 2ca4394b28ee..0564de9e5dd1 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp @@ -22,8 +22,11 @@ #include "lldb/Core/Module.h" #include "lldb/Symbol/ObjectFile.h" +#include "lldb/Symbol/Type.h" #include "lldb/Symbol/TypeSystem.h" +using namespace lldb_private; + DIERef DWARFDIE::GetDIERef() const { @@ -307,6 +310,50 @@ DWARFDIE::GetDWARFDeclContext (DWARFDeclContext &dwarf_decl_ctx) const } } +void +DWARFDIE::GetDWOContext (std::vector &context) const +{ + const dw_tag_t tag = Tag(); + if (tag == DW_TAG_compile_unit) + return; + DWARFDIE parent = GetParent(); + if (parent) + parent.GetDWOContext(context); + switch (tag) + { + case DW_TAG_module: + context.push_back(CompilerContext(CompilerContextKind::Module, ConstString(GetName()))); + break; + case DW_TAG_namespace: + context.push_back(CompilerContext(CompilerContextKind::Namespace, ConstString(GetName()))); + break; + case DW_TAG_structure_type: + context.push_back(CompilerContext(CompilerContextKind::Structure, ConstString(GetName()))); + break; + case DW_TAG_union_type: + context.push_back(CompilerContext(CompilerContextKind::Union, ConstString(GetName()))); + break; + case DW_TAG_class_type: + context.push_back(CompilerContext(CompilerContextKind::Class, ConstString(GetName()))); + break; + case DW_TAG_enumeration_type: + context.push_back(CompilerContext(CompilerContextKind::Enumeration, ConstString(GetName()))); + break; + case DW_TAG_subprogram: + context.push_back(CompilerContext(CompilerContextKind::Function, ConstString(GetPubname()))); + break; + case DW_TAG_variable: + context.push_back(CompilerContext(CompilerContextKind::Variable, ConstString(GetPubname()))); + break; + case DW_TAG_typedef: + context.push_back(CompilerContext(CompilerContextKind::Typedef, ConstString(GetName()))); + break; + default: + break; + } +} + + DWARFDIE DWARFDIE::GetParentDeclContextDIE () const @@ -371,6 +418,45 @@ DWARFDIE::IsStructOrClass () const return tag == DW_TAG_class_type || tag == DW_TAG_structure_type; } + +DWARFDIE +DWARFDIE::GetContainingDWOModuleDIE () const +{ + if (IsValid()) + { + DWARFDIE top_module_die; + // Now make sure this DIE is scoped in a DW_TAG_module tag and return true if so + for (DWARFDIE parent = GetParent(); parent.IsValid(); parent = parent.GetParent()) + { + const dw_tag_t tag = parent.Tag(); + if (tag == DW_TAG_module) + top_module_die = parent; + else if (tag == DW_TAG_compile_unit) + break; + } + + return top_module_die; + } + return DWARFDIE(); +} + +lldb::ModuleSP +DWARFDIE::GetContainingDWOModule () const +{ + if (IsValid()) + { + DWARFDIE dwo_module_die = GetContainingDWOModuleDIE(); + + if (dwo_module_die) + { + const char *module_name = dwo_module_die.GetName(); + if (module_name) + return GetDWARF()->GetDWOModule (lldb_private::ConstString(module_name)); + } + } + return lldb::ModuleSP(); +} + bool DWARFDIE::HasChildren () const { diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h index f3e72d74d195..db37a45ad01a 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h @@ -126,6 +126,12 @@ public: m_die = nullptr; } + lldb::ModuleSP + GetContainingDWOModule () const; + + DWARFDIE + GetContainingDWOModuleDIE () const; + //---------------------------------------------------------------------- // Accessing information about a DIE //---------------------------------------------------------------------- @@ -217,6 +223,9 @@ public: void GetDWARFDeclContext (DWARFDeclContext &dwarf_decl_ctx) const; + void + GetDWOContext (std::vector &context) const; + //---------------------------------------------------------------------- // Getting attribute values from the DIE. // diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp index 70293384e7fb..fd254ad9c29a 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp @@ -1077,9 +1077,9 @@ SymbolFileDWARF::ParseImportedModules (const lldb_private::SymbolContext &sc, st if (ClangModulesDeclVendor::LanguageSupportsClangModules(sc.comp_unit->GetLanguage())) { UpdateExternalModuleListIfNeeded(); - for (const std::pair &external_type_module : m_external_type_modules) + for (const auto &pair : m_external_type_modules) { - imported_modules.push_back(external_type_module.second.m_name); + imported_modules.push_back(pair.first); } } } @@ -1515,13 +1515,32 @@ bool SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type) { CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type); - return GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType()); + if (GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType())) + { + return true; + } + TypeSystem *type_system = compiler_type.GetTypeSystem(); + if (type_system) + { + DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); + if (dwarf_ast) + return dwarf_ast->CanCompleteType(compiler_type); + } + return false; } bool SymbolFileDWARF::CompleteType (CompilerType &compiler_type) { + TypeSystem *type_system = compiler_type.GetTypeSystem(); + if (type_system) + { + DWARFASTParser *dwarf_ast = type_system->GetDWARFParser(); + if (dwarf_ast && dwarf_ast->CanCompleteType(compiler_type)) + return dwarf_ast->CompleteType(compiler_type); + } + // We have a struct/union/class/enum that needs to be fully resolved. CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type); auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType()); @@ -1641,6 +1660,17 @@ SymbolFileDWARF::GetFunction (const DWARFDIE &die, SymbolContext& sc) return false; } +lldb::ModuleSP +SymbolFileDWARF::GetDWOModule (ConstString name) +{ + UpdateExternalModuleListIfNeeded(); + const auto &pos = m_external_type_modules.find(name); + if (pos != m_external_type_modules.end()) + return pos->second; + else + return lldb::ModuleSP(); +} + void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() { @@ -1658,37 +1688,24 @@ SymbolFileDWARF::UpdateExternalModuleListIfNeeded() const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly(); if (die && die.HasChildren() == false) { - const uint64_t name_strp = die.GetAttributeValueAsUnsigned (DW_AT_name, UINT64_MAX); - const uint64_t dwo_path_strp = die.GetAttributeValueAsUnsigned (DW_AT_GNU_dwo_name, UINT64_MAX); - - if (name_strp != UINT64_MAX) + const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr); + + if (name) { - if (m_external_type_modules.find(dwo_path_strp) == m_external_type_modules.end()) + ConstString const_name(name); + if (m_external_type_modules.find(const_name) == m_external_type_modules.end()) { - const char *name = get_debug_str_data().PeekCStr(name_strp); - const char *dwo_path = get_debug_str_data().PeekCStr(dwo_path_strp); - if (name || dwo_path) + ModuleSP module_sp; + const char *dwo_path = die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr); + if (dwo_path) { - ModuleSP module_sp; - if (dwo_path) - { - ModuleSpec dwo_module_spec; - dwo_module_spec.GetFileSpec().SetFile(dwo_path, false); - dwo_module_spec.GetArchitecture() = m_obj_file->GetModule()->GetArchitecture(); - //printf ("Loading dwo = '%s'\n", dwo_path); - Error error = ModuleList::GetSharedModule (dwo_module_spec, module_sp, NULL, NULL, NULL); - } - - if (dwo_path_strp != LLDB_INVALID_UID) - { - m_external_type_modules[dwo_path_strp] = ClangModuleInfo { ConstString(name), module_sp }; - } - else - { - // This hack should be removed promptly once clang emits both. - m_external_type_modules[name_strp] = ClangModuleInfo { ConstString(name), module_sp }; - } + ModuleSpec dwo_module_spec; + dwo_module_spec.GetFileSpec().SetFile(dwo_path, false); + dwo_module_spec.GetArchitecture() = m_obj_file->GetModule()->GetArchitecture(); + //printf ("Loading dwo = '%s'\n", dwo_path); + Error error = ModuleList::GetSharedModule (dwo_module_spec, module_sp, NULL, NULL, NULL); } + m_external_type_modules[const_name] = module_sp; } } } @@ -2970,6 +2987,104 @@ SymbolFileDWARF::FindTypes (const SymbolContext& sc, } return num_matches; } + else + { + UpdateExternalModuleListIfNeeded(); + + for (const auto &pair : m_external_type_modules) + { + ModuleSP external_module_sp = pair.second; + if (external_module_sp) + { + SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor(); + if (sym_vendor) + { + const uint32_t num_external_matches = sym_vendor->FindTypes (sc, + name, + parent_decl_ctx, + append, + max_matches, + types); + if (num_external_matches) + return num_external_matches; + } + } + } + } + + return 0; +} + + +size_t +SymbolFileDWARF::FindTypes (const std::vector &context, + bool append, + TypeMap& types) +{ + if (!append) + types.Clear(); + + if (context.empty()) + return 0; + + DIEArray die_offsets; + + ConstString name = context.back().name; + + if (m_using_apple_tables) + { + if (m_apple_types_ap.get()) + { + const char *name_cstr = name.GetCString(); + m_apple_types_ap->FindByName (name_cstr, die_offsets); + } + } + else + { + if (!m_indexed) + Index (); + + m_type_index.Find (name, die_offsets); + } + + const size_t num_die_matches = die_offsets.size(); + + if (num_die_matches) + { + size_t num_matches = 0; + DWARFDebugInfo* debug_info = DebugInfo(); + for (size_t i=0; iGetDIE (die_ref); + + if (die) + { + std::vector die_context; + die.GetDWOContext(die_context); + if (die_context != context) + continue; + + Type *matching_type = ResolveType (die, true, true); + if (matching_type) + { + // We found a type pointer, now find the shared pointer form our type list + types.InsertUnique (matching_type->shared_from_this()); + ++num_matches; + } + } + else + { + if (m_using_apple_tables) + { + GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n", + die_ref.die_offset, name.GetCString()); + } + } + + } + return num_matches; + } return 0; } diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h index 818ce68eabbf..2bdbc37c51f6 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h @@ -211,6 +211,11 @@ public: uint32_t max_matches, lldb_private::TypeMap& types) override; + size_t + FindTypes (const std::vector &context, + bool append, + lldb_private::TypeMap& types) override; + lldb_private::TypeList * GetTypeList () override; @@ -306,6 +311,9 @@ public: virtual lldb_private::DWARFExpression::LocationListFormat GetLocationListFormat() const; + lldb::ModuleSP + GetDWOModule (lldb_private::ConstString name); + protected: typedef llvm::DenseMap DIEToTypePtr; typedef llvm::DenseMap DIEToVariableSP; @@ -483,12 +491,7 @@ protected: typedef std::set TypeSet; - typedef struct { - lldb_private::ConstString m_name; - lldb::ModuleSP m_module_sp; - } ClangModuleInfo; - - typedef std::map ExternalTypeModuleMap; + typedef std::map ExternalTypeModuleMap; void GetTypes (const DWARFDIE &die, diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 6373b1afd3e6..3f90c9367224 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -2280,6 +2280,157 @@ ClangASTContext::GetPointerSizedIntType (clang::ASTContext *ast, bool is_signed) return CompilerType(); } +void +ClangASTContext::DumpDeclContextHiearchy (clang::DeclContext *decl_ctx) +{ + if (decl_ctx) + { + DumpDeclContextHiearchy (decl_ctx->getParent()); + + clang::NamedDecl *named_decl = llvm::dyn_cast(decl_ctx); + if (named_decl) + { + printf ("%20s: %s\n", decl_ctx->getDeclKindName(), named_decl->getDeclName().getAsString().c_str()); + } + else + { + printf ("%20s\n", decl_ctx->getDeclKindName()); + } + } +} + +void +ClangASTContext::DumpDeclHiearchy (clang::Decl *decl) +{ + if (decl == nullptr) + return; + DumpDeclContextHiearchy(decl->getDeclContext()); + + clang::RecordDecl *record_decl = llvm::dyn_cast(decl); + if (record_decl) + { + printf ("%20s: %s%s\n", decl->getDeclKindName(), record_decl->getDeclName().getAsString().c_str(), record_decl->isInjectedClassName() ? " (injected class name)" : ""); + + } + else + { + clang::NamedDecl *named_decl = llvm::dyn_cast(decl); + if (named_decl) + { + printf ("%20s: %s\n", decl->getDeclKindName(), named_decl->getDeclName().getAsString().c_str()); + } + else + { + printf ("%20s\n", decl->getDeclKindName()); + } + } +} + +bool +ClangASTContext::DeclsAreEquivalent (clang::Decl *lhs_decl, clang::Decl *rhs_decl) +{ + if (lhs_decl && rhs_decl) + { + //---------------------------------------------------------------------- + // Make sure the decl kinds match first + //---------------------------------------------------------------------- + const clang::Decl::Kind lhs_decl_kind = lhs_decl->getKind(); + const clang::Decl::Kind rhs_decl_kind = rhs_decl->getKind(); + + if (lhs_decl_kind == rhs_decl_kind) + { + //------------------------------------------------------------------ + // Now check that the decl contexts kinds are all equivalent + // before we have to check any names of the decl contexts... + //------------------------------------------------------------------ + clang::DeclContext *lhs_decl_ctx = lhs_decl->getDeclContext(); + clang::DeclContext *rhs_decl_ctx = rhs_decl->getDeclContext(); + if (lhs_decl_ctx && rhs_decl_ctx) + { + while (1) + { + if (lhs_decl_ctx && rhs_decl_ctx) + { + const clang::Decl::Kind lhs_decl_ctx_kind = lhs_decl_ctx->getDeclKind(); + const clang::Decl::Kind rhs_decl_ctx_kind = rhs_decl_ctx->getDeclKind(); + if (lhs_decl_ctx_kind == rhs_decl_ctx_kind) + { + lhs_decl_ctx = lhs_decl_ctx->getParent(); + rhs_decl_ctx = rhs_decl_ctx->getParent(); + + if (lhs_decl_ctx == nullptr && rhs_decl_ctx == nullptr) + break; + } + else + return false; + } + else + return false; + } + + //-------------------------------------------------------------- + // Now make sure the name of the decls match + //-------------------------------------------------------------- + clang::NamedDecl *lhs_named_decl = llvm::dyn_cast(lhs_decl); + clang::NamedDecl *rhs_named_decl = llvm::dyn_cast(rhs_decl); + if (lhs_named_decl && rhs_named_decl) + { + clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName(); + clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName(); + if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) + { + if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString()) + return false; + } + else + return false; + } + else + return false; + + //-------------------------------------------------------------- + // We know that the decl context kinds all match, so now we need + // to make sure the names match as well + //-------------------------------------------------------------- + lhs_decl_ctx = lhs_decl->getDeclContext(); + rhs_decl_ctx = rhs_decl->getDeclContext(); + while (1) + { + switch (lhs_decl_ctx->getDeclKind()) + { + case clang::Decl::TranslationUnit: + // We don't care about the translation unit names + return true; + default: + { + clang::NamedDecl *lhs_named_decl = llvm::dyn_cast(lhs_decl_ctx); + clang::NamedDecl *rhs_named_decl = llvm::dyn_cast(rhs_decl_ctx); + if (lhs_named_decl && rhs_named_decl) + { + clang::DeclarationName lhs_decl_name = lhs_named_decl->getDeclName(); + clang::DeclarationName rhs_decl_name = rhs_named_decl->getDeclName(); + if (lhs_decl_name.getNameKind() == rhs_decl_name.getNameKind()) + { + if (lhs_decl_name.getAsString() != rhs_decl_name.getAsString()) + return false; + } + else + return false; + } + else + return false; + } + break; + + } + lhs_decl_ctx = lhs_decl_ctx->getParent(); + rhs_decl_ctx = rhs_decl_ctx->getParent(); + } + } + } + } + return false; +} bool ClangASTContext::GetCompleteDecl (clang::ASTContext *ast, clang::Decl *decl) @@ -2451,81 +2602,112 @@ GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool all case clang::Type::ConstantArray: case clang::Type::IncompleteArray: case clang::Type::VariableArray: - { - const clang::ArrayType *array_type = llvm::dyn_cast(qual_type.getTypePtr()); - - if (array_type) - return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); - } - break; - - case clang::Type::Record: - case clang::Type::Enum: - { - const clang::TagType *tag_type = llvm::dyn_cast(qual_type.getTypePtr()); - if (tag_type) { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) + const clang::ArrayType *array_type = llvm::dyn_cast(qual_type.getTypePtr()); + + if (array_type) + return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); + } + break; + case clang::Type::Record: + { + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) { - if (tag_decl->isCompleteDefinition()) - return true; - - if (!allow_completion) - return false; - - if (tag_decl->hasExternalLexicalStorage()) + if (cxx_record_decl->hasExternalLexicalStorage()) { - if (ast) + const bool is_complete = cxx_record_decl->isCompleteDefinition(); + const bool fields_loaded = cxx_record_decl->hasLoadedFieldsFromExternalStorage(); + if (is_complete && fields_loaded) + return true; + + if (!allow_completion) + return false; + + // Call the field_begin() accessor to for it to use the external source + // to load the fields... + clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); + if (external_ast_source) { - clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); - if (external_ast_source) + external_ast_source->CompleteType(cxx_record_decl); + if (cxx_record_decl->isCompleteDefinition()) { - external_ast_source->CompleteType(tag_decl); - return !tag_type->isIncompleteType(); + cxx_record_decl->setHasLoadedFieldsFromExternalStorage (true); + cxx_record_decl->field_begin(); } } } - return false; } + const clang::TagType *tag_type = llvm::cast(qual_type.getTypePtr()); + return !tag_type->isIncompleteType(); + } + break; + + case clang::Type::Enum: + { + const clang::TagType *tag_type = llvm::dyn_cast(qual_type.getTypePtr()); + if (tag_type) + { + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) + { + if (tag_decl->getDefinition()) + return true; + + if (!allow_completion) + return false; + + if (tag_decl->hasExternalLexicalStorage()) + { + if (ast) + { + clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); + if (external_ast_source) + { + external_ast_source->CompleteType(tag_decl); + return !tag_type->isIncompleteType(); + } + } + } + return false; + } + } + } - - } break; - case clang::Type::ObjCObject: case clang::Type::ObjCInterface: - { - const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); - if (objc_class_type) { - clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); - // We currently can't complete objective C types through the newly added ASTContext - // because it only supports TagDecl objects right now... - if (class_interface_decl) + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); + if (objc_class_type) { - if (class_interface_decl->getDefinition()) - return true; - - if (!allow_completion) - return false; - - if (class_interface_decl->hasExternalLexicalStorage()) + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + // We currently can't complete objective C types through the newly added ASTContext + // because it only supports TagDecl objects right now... + if (class_interface_decl) { - if (ast) + if (class_interface_decl->getDefinition()) + return true; + + if (!allow_completion) + return false; + + if (class_interface_decl->hasExternalLexicalStorage()) { - clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); - if (external_ast_source) + if (ast) { - external_ast_source->CompleteType (class_interface_decl); - return !objc_class_type->isIncompleteType(); + clang::ExternalASTSource *external_ast_source = ast->getExternalSource(); + if (external_ast_source) + { + external_ast_source->CompleteType (class_interface_decl); + return !objc_class_type->isIncompleteType(); + } } } + return false; } - return false; } } - } break; case clang::Type::Typedef: @@ -2536,7 +2718,10 @@ GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool all case clang::Type::Paren: return GetCompleteQualType (ast, llvm::cast(qual_type)->desugar(), allow_completion); - + + case clang::Type::Attributed: + return GetCompleteQualType (ast, llvm::cast(qual_type)->getModifiedType(), allow_completion); + default: break; } @@ -7160,6 +7345,16 @@ ClangASTContext::GetAsRecordDecl (const CompilerType& type) return nullptr; } +clang::TagDecl * +ClangASTContext::GetAsTagDecl (const CompilerType& type) +{ + clang::QualType qual_type = GetCanonicalQualType(type); + if (qual_type.isNull()) + return nullptr; + else + return qual_type->getAsTagDecl(); +} + clang::CXXRecordDecl * ClangASTContext::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type) { @@ -8036,6 +8231,64 @@ ClangASTContext::AddMethodToObjCObjectType (const CompilerType& type, return objc_method_decl; } +bool +ClangASTContext::GetHasExternalStorage (const CompilerType &type) +{ + if (IsClangType(type)) + return false; + + clang::QualType qual_type (GetCanonicalQualType(type)); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + { + clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + return cxx_record_decl->hasExternalLexicalStorage () || cxx_record_decl->hasExternalVisibleStorage(); + } + break; + + case clang::Type::Enum: + { + clang::EnumDecl *enum_decl = llvm::cast(qual_type)->getDecl(); + if (enum_decl) + return enum_decl->hasExternalLexicalStorage () || enum_decl->hasExternalVisibleStorage(); + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + { + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type.getTypePtr()); + assert (objc_class_type); + if (objc_class_type) + { + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + + if (class_interface_decl) + return class_interface_decl->hasExternalLexicalStorage () || class_interface_decl->hasExternalVisibleStorage (); + } + } + break; + + case clang::Type::Typedef: + return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr())); + + case clang::Type::Elaborated: + return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast(qual_type)->getNamedType().getAsOpaquePtr())); + + case clang::Type::Paren: + return GetHasExternalStorage (CompilerType(type.GetTypeSystem(), llvm::cast(qual_type)->desugar().getAsOpaquePtr())); + + default: + break; + } + return false; +} + + bool ClangASTContext::SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern) { @@ -8106,38 +8359,173 @@ ClangASTContext::SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool } +bool +ClangASTContext::CanImport (const CompilerType &type, lldb_private::ClangASTImporter &importer) +{ + if (IsClangType(type)) + { + // TODO: remove external completion BOOL + // CompleteAndFetchChildren should get the Decl out and check for the + + clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type))); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + { + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + { + if (importer.ResolveDeclOrigin (cxx_record_decl, NULL, NULL)) + return true; + } + } + break; + + case clang::Type::Enum: + { + clang::EnumDecl *enum_decl = llvm::cast(qual_type)->getDecl(); + if (enum_decl) + { + if (importer.ResolveDeclOrigin (enum_decl, NULL, NULL)) + return true; + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + { + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); + if (objc_class_type) + { + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + // We currently can't complete objective C types through the newly added ASTContext + // because it only supports TagDecl objects right now... + if (class_interface_decl) + { + if (importer.ResolveDeclOrigin (class_interface_decl, NULL, NULL)) + return true; + } + } + } + break; + + + case clang::Type::Typedef: + return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()), importer); + + case clang::Type::Elaborated: + return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast(qual_type)->getNamedType().getAsOpaquePtr()), importer); + + case clang::Type::Paren: + return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast(qual_type)->desugar().getAsOpaquePtr()), importer); + + default: + break; + } + } + return false; +} +bool +ClangASTContext::Import (const CompilerType &type, lldb_private::ClangASTImporter &importer) +{ + if (IsClangType(type)) + { + // TODO: remove external completion BOOL + // CompleteAndFetchChildren should get the Decl out and check for the + + clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type))); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + { + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + { + if (importer.ResolveDeclOrigin (cxx_record_decl, NULL, NULL)) + return importer.CompleteAndFetchChildren(qual_type); + } + } + break; + + case clang::Type::Enum: + { + clang::EnumDecl *enum_decl = llvm::cast(qual_type)->getDecl(); + if (enum_decl) + { + if (importer.ResolveDeclOrigin (enum_decl, NULL, NULL)) + return importer.CompleteAndFetchChildren(qual_type); + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + { + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); + if (objc_class_type) + { + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + // We currently can't complete objective C types through the newly added ASTContext + // because it only supports TagDecl objects right now... + if (class_interface_decl) + { + if (importer.ResolveDeclOrigin (class_interface_decl, NULL, NULL)) + return importer.CompleteAndFetchChildren(qual_type); + } + } + } + break; + + + case clang::Type::Typedef: + return Import (CompilerType(type.GetTypeSystem(), llvm::cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()), importer); + + case clang::Type::Elaborated: + return Import (CompilerType(type.GetTypeSystem(),llvm::cast(qual_type)->getNamedType().getAsOpaquePtr()), importer); + + case clang::Type::Paren: + return Import (CompilerType(type.GetTypeSystem(),llvm::cast(qual_type)->desugar().getAsOpaquePtr()), importer); + + default: + break; + } + } + return false; +} + + #pragma mark TagDecl bool ClangASTContext::StartTagDeclarationDefinition (const CompilerType &type) { - if (type) + clang::QualType qual_type (ClangASTContext::GetQualType(type)); + if (!qual_type.isNull()) { - - clang::QualType qual_type (GetQualType(type)); - const clang::Type *t = qual_type.getTypePtr(); - if (t) + const clang::TagType *tag_type = qual_type->getAs(); + if (tag_type) { - const clang::TagType *tag_type = llvm::dyn_cast(t); - if (tag_type) + clang::TagDecl *tag_decl = tag_type->getDecl(); + if (tag_decl) { - clang::TagDecl *tag_decl = tag_type->getDecl(); - if (tag_decl) - { - tag_decl->startDefinition(); - return true; - } + tag_decl->startDefinition(); + return true; } - - const clang::ObjCObjectType *object_type = llvm::dyn_cast(t); - if (object_type) + } + + const clang::ObjCObjectType *object_type = qual_type->getAs(); + if (object_type) + { + clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface(); + if (interface_decl) { - clang::ObjCInterfaceDecl *interface_decl = object_type->getInterface(); - if (interface_decl) - { - interface_decl->startDefinition(); - return true; - } + interface_decl->startDefinition(); + return true; } } } @@ -8147,26 +8535,22 @@ ClangASTContext::StartTagDeclarationDefinition (const CompilerType &type) bool ClangASTContext::CompleteTagDeclarationDefinition (const CompilerType& type) { - if (type) + clang::QualType qual_type (ClangASTContext::GetQualType(type)); + if (!qual_type.isNull()) { - clang::QualType qual_type (GetQualType(type)); - if (qual_type.isNull()) - return false; - ClangASTContext *lldb_ast = llvm::dyn_cast(type.GetTypeSystem()); - if (lldb_ast == nullptr) - return false; - clang::ASTContext *ast = lldb_ast->getASTContext(); - clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); if (cxx_record_decl) { - cxx_record_decl->completeDefinition(); - + if (!cxx_record_decl->isCompleteDefinition()) + cxx_record_decl->completeDefinition(); + cxx_record_decl->setHasLoadedFieldsFromExternalStorage(true); + cxx_record_decl->setHasExternalLexicalStorage (false); + cxx_record_decl->setHasExternalVisibleStorage (false); return true; } - const clang::EnumType *enutype = llvm::dyn_cast(qual_type.getTypePtr()); + const clang::EnumType *enutype = qual_type->getAs(); if (enutype) { @@ -8174,25 +8558,33 @@ ClangASTContext::CompleteTagDeclarationDefinition (const CompilerType& type) if (enum_decl) { - /// TODO This really needs to be fixed. - - unsigned NumPositiveBits = 1; - unsigned NumNegativeBits = 0; - - clang::QualType promotion_qual_type; - // If the enum integer type is less than an integer in bit width, - // then we must promote it to an integer size. - if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy)) + if (!enum_decl->isCompleteDefinition()) { - if (enum_decl->getIntegerType()->isSignedIntegerType()) - promotion_qual_type = ast->IntTy; + ClangASTContext *lldb_ast = llvm::dyn_cast(type.GetTypeSystem()); + if (lldb_ast == nullptr) + return false; + clang::ASTContext *ast = lldb_ast->getASTContext(); + + /// TODO This really needs to be fixed. + + unsigned NumPositiveBits = 1; + unsigned NumNegativeBits = 0; + + clang::QualType promotion_qual_type; + // If the enum integer type is less than an integer in bit width, + // then we must promote it to an integer size. + if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy)) + { + if (enum_decl->getIntegerType()->isSignedIntegerType()) + promotion_qual_type = ast->IntTy; + else + promotion_qual_type = ast->UnsignedIntTy; + } else - promotion_qual_type = ast->UnsignedIntTy; + promotion_qual_type = enum_decl->getIntegerType(); + + enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits); } - else - promotion_qual_type = enum_decl->getIntegerType(); - - enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits); return true; } } @@ -8976,6 +9368,72 @@ ClangASTContext::DumpTypeDescription (lldb::opaque_compiler_type_t type, Stream } } +void +ClangASTContext::DumpTypeName (const CompilerType &type) +{ + if (IsClangType(type)) + { + clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type))); + + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + { + const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + printf("class %s", cxx_record_decl->getName().str().c_str()); + } + break; + + case clang::Type::Enum: + { + clang::EnumDecl *enum_decl = llvm::cast(qual_type)->getDecl(); + if (enum_decl) + { + printf("enum %s", enum_decl->getName().str().c_str()); + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + { + const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast(qual_type); + if (objc_class_type) + { + clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + // We currently can't complete objective C types through the newly added ASTContext + // because it only supports TagDecl objects right now... + if (class_interface_decl) + printf("@class %s", class_interface_decl->getName().str().c_str()); + } + } + break; + + + case clang::Type::Typedef: + printf("typedef %s", llvm::cast(qual_type)->getDecl()->getName().str().c_str()); + break; + + case clang::Type::Elaborated: + printf("elaborated "); + return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast(qual_type)->getNamedType().getAsOpaquePtr())); + + case clang::Type::Paren: + printf("paren "); + return DumpTypeName (CompilerType (type.GetTypeSystem(), llvm::cast(qual_type)->desugar().getAsOpaquePtr())); + + default: + printf("ClangASTContext::DumpTypeName() type_class = %u", type_class); + break; + } + } + +} + + + clang::ClassTemplateDecl * ClangASTContext::ParseClassTemplateDecl (clang::DeclContext *decl_ctx, lldb::AccessType access_type, diff --git a/lldb/source/Symbol/ClangASTImporter.cpp b/lldb/source/Symbol/ClangASTImporter.cpp index 94ac816b1821..141937072c73 100644 --- a/lldb/source/Symbol/ClangASTImporter.cpp +++ b/lldb/source/Symbol/ClangASTImporter.cpp @@ -67,6 +67,31 @@ ClangASTImporter::CopyType (clang::ASTContext *dst_ast, return CopyType (dst_ast, src_ast, QualType::getFromOpaquePtr(type)).getAsOpaquePtr(); } +CompilerType +ClangASTImporter::CopyType (ClangASTContext &dst_ast, + const CompilerType &src_type) +{ + clang::ASTContext *dst_clang_ast = dst_ast.getASTContext(); + if (dst_clang_ast) + { + ClangASTContext *src_ast = llvm::dyn_cast_or_null(src_type.GetTypeSystem()); + if (src_ast) + { + clang::ASTContext *src_clang_ast = src_ast->getASTContext(); + if (src_clang_ast) + { + lldb::opaque_compiler_type_t dst_clang_type = CopyType(dst_clang_ast, + src_clang_ast, + src_type.GetOpaqueQualType()); + + if (dst_clang_type) + return CompilerType(&dst_ast, dst_clang_type); + } + } + } + return CompilerType(); +} + clang::Decl * ClangASTImporter::CopyDecl (clang::ASTContext *dst_ast, clang::ASTContext *src_ast, @@ -428,6 +453,68 @@ ClangASTImporter::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface return true; } +bool +ClangASTImporter::CompleteAndFetchChildren (clang::QualType type) +{ + if (!RequireCompleteType(type)) + return false; + + if (const TagType *tag_type = type->getAs()) + { + TagDecl *tag_decl = tag_type->getDecl(); + + DeclOrigin decl_origin = GetDeclOrigin(tag_decl); + + if (!decl_origin.Valid()) + return false; + + MinionSP minion_sp (GetMinion(&tag_decl->getASTContext(), decl_origin.ctx)); + + TagDecl *origin_tag_decl = llvm::dyn_cast(decl_origin.decl); + + for (Decl *origin_child_decl : origin_tag_decl->decls()) + { + minion_sp->Import(origin_child_decl); + } + + if (RecordDecl *record_decl = dyn_cast(origin_tag_decl)) + { + record_decl->setHasLoadedFieldsFromExternalStorage(true); + } + + return true; + } + + if (const ObjCObjectType *objc_object_type = type->getAs()) + { + if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface()) + { + DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl); + + if (!decl_origin.Valid()) + return false; + + MinionSP minion_sp (GetMinion(&objc_interface_decl->getASTContext(), decl_origin.ctx)); + + ObjCInterfaceDecl *origin_interface_decl = llvm::dyn_cast(decl_origin.decl); + + for (Decl *origin_child_decl : origin_interface_decl->decls()) + { + minion_sp->Import(origin_child_decl); + } + + return true; + } + else + { + return false; + } + } + + return true; +} + + bool ClangASTImporter::RequireCompleteType (clang::QualType type) { @@ -793,10 +880,14 @@ ClangASTImporter::Minion::Imported (clang::Decl *from, clang::Decl *to) { if (isa(to) || isa(to)) { - NamedDecl *to_named_decl = dyn_cast(to); + RecordDecl *from_record_decl = dyn_cast(from); + if (from_record_decl == nullptr || from_record_decl->isInjectedClassName() == false) + { + NamedDecl *to_named_decl = dyn_cast(to); - if (!m_decls_already_deported->count(to_named_decl)) - m_decls_to_deport->insert(to_named_decl); + if (!m_decls_already_deported->count(to_named_decl)) + m_decls_to_deport->insert(to_named_decl); + } } } diff --git a/lldb/source/Symbol/ClangExternalASTSourceCallbacks.cpp b/lldb/source/Symbol/ClangExternalASTSourceCallbacks.cpp index cd6972cce972..6c804f4d969c 100644 --- a/lldb/source/Symbol/ClangExternalASTSourceCallbacks.cpp +++ b/lldb/source/Symbol/ClangExternalASTSourceCallbacks.cpp @@ -41,6 +41,7 @@ #endif #include "lldb/Core/Log.h" +#include "clang/AST/Decl.h" using namespace clang; using namespace lldb_private; @@ -160,3 +161,16 @@ ClangExternalASTSourceCallbacks::layoutRecordType( return false; } +void +ClangExternalASTSourceCallbacks::FindExternalLexicalDecls (const clang::DeclContext *decl_ctx, + llvm::function_ref IsKindWeWant, + llvm::SmallVectorImpl &decls) +{ + if (m_callback_tag_decl && decl_ctx) + { + clang::TagDecl *tag_decl = llvm::dyn_cast(const_cast(decl_ctx)); + if (tag_decl) + CompleteType(tag_decl); + } +} + diff --git a/lldb/source/Symbol/SymbolFile.cpp b/lldb/source/Symbol/SymbolFile.cpp index 5486468181fa..51e35048d5cd 100644 --- a/lldb/source/Symbol/SymbolFile.cpp +++ b/lldb/source/Symbol/SymbolFile.cpp @@ -142,3 +142,11 @@ SymbolFile::FindTypes (const SymbolContext& sc, const ConstString &name, const C return 0; } + +size_t +SymbolFile::FindTypes (const std::vector &context, bool append, TypeMap& types) +{ + if (!append) + types.Clear(); + return 0; +} diff --git a/lldb/source/Symbol/SymbolVendor.cpp b/lldb/source/Symbol/SymbolVendor.cpp index 97e2575aaa0d..b361d400f228 100644 --- a/lldb/source/Symbol/SymbolVendor.cpp +++ b/lldb/source/Symbol/SymbolVendor.cpp @@ -360,6 +360,21 @@ SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const return 0; } +size_t +SymbolVendor::FindTypes (const std::vector &context, bool append, TypeMap& types) +{ + ModuleSP module_sp(GetModule()); + if (module_sp) + { + lldb_private::Mutex::Locker locker(module_sp->GetMutex()); + if (m_sym_file_ap.get()) + return m_sym_file_ap->FindTypes(context, append, types); + } + if (!append) + types.Clear(); + return 0; +} + size_t SymbolVendor::GetTypes (SymbolContextScope *sc_scope, uint32_t type_mask, diff --git a/lldb/source/Symbol/Type.cpp b/lldb/source/Symbol/Type.cpp index b0c273d2e22f..cd0cb830682c 100644 --- a/lldb/source/Symbol/Type.cpp +++ b/lldb/source/Symbol/Type.cpp @@ -7,8 +7,12 @@ // //===----------------------------------------------------------------------===// -// Other libraries and framework includes +// C Includes +#include +// C++ Includes +// Other libraries and framework includes +// Project includes #include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/Module.h" @@ -36,6 +40,27 @@ using namespace lldb; using namespace lldb_private; +void +CompilerContext::Dump() const +{ + switch (type) + { + case CompilerContextKind::Invalid: printf("Invalid"); break; + case CompilerContextKind::TranslationUnit: printf("TranslationUnit"); break; + case CompilerContextKind::Module: printf("Module"); break; + case CompilerContextKind::Namespace: printf("Namespace"); break; + case CompilerContextKind::Class: printf("Class"); break; + case CompilerContextKind::Structure: printf("Structure"); break; + case CompilerContextKind::Union: printf("Union"); break; + case CompilerContextKind::Function: printf("Function"); break; + case CompilerContextKind::Variable: printf("Variable"); break; + case CompilerContextKind::Enumeration: printf("Enumeration"); break; + case CompilerContextKind::Typedef: printf("Typedef"); break; + default: printf("???(%u)", type); + } + printf("(\"%s\")\n", name.GetCString()); +} + class TypeAppendVisitor { public: @@ -62,6 +87,13 @@ TypeListImpl::Append (const lldb_private::TypeList &type_list) type_list.ForEach(cb); } +SymbolFileType::SymbolFileType (SymbolFile &symbol_file, const lldb::TypeSP &type_sp) : + UserID (type_sp ? type_sp->GetID() : LLDB_INVALID_UID), + m_symbol_file (symbol_file), + m_type_sp (type_sp) +{ +} + Type * SymbolFileType::GetType ()