//===-- ClangASTSource.cpp ------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include "ClangASTSource.h" #include "ClangDeclVendor.h" #include "ClangModulesDeclVendor.h" #include "lldb/Core/Module.h" #include "lldb/Core/ModuleList.h" #include "lldb/Symbol/CompilerDeclContext.h" #include "lldb/Symbol/Function.h" #include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/TaggedASTType.h" #include "lldb/Target/Target.h" #include "lldb/Utility/Log.h" #include "clang/AST/ASTContext.h" #include "clang/AST/RecordLayout.h" #include "clang/Basic/SourceManager.h" #include "Plugins/ExpressionParser/Clang/ClangUtil.h" #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" #include #include using namespace clang; using namespace lldb_private; // Scoped class that will remove an active lexical decl from the set when it // goes out of scope. namespace { class ScopedLexicalDeclEraser { public: ScopedLexicalDeclEraser(std::set &decls, const clang::Decl *decl) : m_active_lexical_decls(decls), m_decl(decl) {} ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); } private: std::set &m_active_lexical_decls; const clang::Decl *m_decl; }; } ClangASTSource::ClangASTSource( const lldb::TargetSP &target, const std::shared_ptr &importer) : m_lookups_enabled(false), m_target(target), m_ast_context(nullptr), m_ast_importer_sp(importer), m_active_lexical_decls(), m_active_lookups() { assert(m_ast_importer_sp && "No ClangASTImporter passed to ClangASTSource?"); } void ClangASTSource::InstallASTContext(TypeSystemClang &clang_ast_context) { m_ast_context = &clang_ast_context.getASTContext(); m_clang_ast_context = &clang_ast_context; m_file_manager = &m_ast_context->getSourceManager().getFileManager(); m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this); } ClangASTSource::~ClangASTSource() { m_ast_importer_sp->ForgetDestination(m_ast_context); if (!m_target) return; // We are in the process of destruction, don't create clang ast context on // demand by passing false to // Target::GetScratchTypeSystemClang(create_on_demand). TypeSystemClang *scratch_clang_ast_context = ScratchTypeSystemClang::GetForTarget(*m_target, false); if (!scratch_clang_ast_context) return; clang::ASTContext &scratch_ast_context = scratch_clang_ast_context->getASTContext(); if (m_ast_context != &scratch_ast_context && m_ast_importer_sp) m_ast_importer_sp->ForgetSource(&scratch_ast_context, m_ast_context); } void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) { if (!m_ast_context) return; m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage(); m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage(); } // The core lookup interface. bool ClangASTSource::FindExternalVisibleDeclsByName( const DeclContext *decl_ctx, DeclarationName clang_decl_name) { if (!m_ast_context) { SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); return false; } std::string decl_name(clang_decl_name.getAsString()); switch (clang_decl_name.getNameKind()) { // Normal identifiers. case DeclarationName::Identifier: { clang::IdentifierInfo *identifier_info = clang_decl_name.getAsIdentifierInfo(); if (!identifier_info || identifier_info->getBuiltinID() != 0) { SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); return false; } } break; // Operator names. case DeclarationName::CXXOperatorName: case DeclarationName::CXXLiteralOperatorName: break; // Using directives found in this context. // Tell Sema we didn't find any or we'll end up getting asked a *lot*. case DeclarationName::CXXUsingDirective: SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); return false; case DeclarationName::ObjCZeroArgSelector: case DeclarationName::ObjCOneArgSelector: case DeclarationName::ObjCMultiArgSelector: { llvm::SmallVector method_decls; NameSearchContext method_search_context(*m_clang_ast_context, method_decls, clang_decl_name, decl_ctx); FindObjCMethodDecls(method_search_context); SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls); return (method_decls.size() > 0); } // These aren't possible in the global context. case DeclarationName::CXXConstructorName: case DeclarationName::CXXDestructorName: case DeclarationName::CXXConversionFunctionName: case DeclarationName::CXXDeductionGuideName: SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); return false; } if (!GetLookupsEnabled()) { // Wait until we see a '$' at the start of a name before we start doing any // lookups so we can avoid lookup up all of the builtin types. if (!decl_name.empty() && decl_name[0] == '$') { SetLookupsEnabled(true); } else { SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); return false; } } ConstString const_decl_name(decl_name.c_str()); const char *uniqued_const_decl_name = const_decl_name.GetCString(); if (m_active_lookups.find(uniqued_const_decl_name) != m_active_lookups.end()) { // We are currently looking up this name... SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); return false; } m_active_lookups.insert(uniqued_const_decl_name); llvm::SmallVector name_decls; NameSearchContext name_search_context(*m_clang_ast_context, name_decls, clang_decl_name, decl_ctx); FindExternalVisibleDecls(name_search_context); SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls); m_active_lookups.erase(uniqued_const_decl_name); return (name_decls.size() != 0); } TagDecl *ClangASTSource::FindCompleteType(const TagDecl *decl) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); if (const NamespaceDecl *namespace_context = dyn_cast(decl->getDeclContext())) { ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer_sp->GetNamespaceMap(namespace_context); LLDB_LOGV(log, " CTD Inspecting namespace map{0} ({1} entries)", namespace_map.get(), namespace_map->size()); if (!namespace_map) return nullptr; for (const ClangASTImporter::NamespaceMapItem &item : *namespace_map) { LLDB_LOG(log, " CTD Searching namespace {0} in module {1}", item.second.GetName(), item.first->GetFileSpec().GetFilename()); TypeList types; ConstString name(decl->getName()); item.first->FindTypesInNamespace(name, item.second, UINT32_MAX, types); for (uint32_t ti = 0, te = types.GetSize(); ti != te; ++ti) { lldb::TypeSP type = types.GetTypeAtIndex(ti); if (!type) continue; CompilerType clang_type(type->GetFullCompilerType()); if (!ClangUtil::IsClangType(clang_type)) continue; const TagType *tag_type = ClangUtil::GetQualType(clang_type)->getAs(); if (!tag_type) continue; TagDecl *candidate_tag_decl = const_cast(tag_type->getDecl()); if (TypeSystemClang::GetCompleteDecl( &candidate_tag_decl->getASTContext(), candidate_tag_decl)) return candidate_tag_decl; } } } else { TypeList types; ConstString name(decl->getName()); const ModuleList &module_list = m_target->GetImages(); bool exact_match = false; llvm::DenseSet searched_symbol_files; module_list.FindTypes(nullptr, name, exact_match, UINT32_MAX, searched_symbol_files, types); for (uint32_t ti = 0, te = types.GetSize(); ti != te; ++ti) { lldb::TypeSP type = types.GetTypeAtIndex(ti); if (!type) continue; CompilerType clang_type(type->GetFullCompilerType()); if (!ClangUtil::IsClangType(clang_type)) continue; const TagType *tag_type = ClangUtil::GetQualType(clang_type)->getAs(); if (!tag_type) continue; 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 (!TypeSystemClang::DeclsAreEquivalent(const_cast(decl), candidate_tag_decl)) continue; if (TypeSystemClang::GetCompleteDecl(&candidate_tag_decl->getASTContext(), candidate_tag_decl)) return candidate_tag_decl; } } return nullptr; } void ClangASTSource::CompleteType(TagDecl *tag_decl) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); if (log) { LLDB_LOG(log, " CompleteTagDecl on (ASTContext*){0} Completing " "(TagDecl*){1} named {2}", m_clang_ast_context->getDisplayName(), tag_decl, tag_decl->getName()); LLDB_LOG(log, " CTD Before:\n{0}", ClangUtil::DumpDecl(tag_decl)); } auto iter = m_active_lexical_decls.find(tag_decl); if (iter != m_active_lexical_decls.end()) return; m_active_lexical_decls.insert(tag_decl); ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl); if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) { // We couldn't complete the type. Maybe there's a definition somewhere // else that can be completed. if (TagDecl *alternate = FindCompleteType(tag_decl)) m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, alternate); } LLDB_LOG(log, " [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl)); } void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); LLDB_LOG(log, " [CompleteObjCInterfaceDecl] on (ASTContext*){0} '{1}' " "Completing an ObjCInterfaceDecl named {1}", m_ast_context, m_clang_ast_context->getDisplayName(), interface_decl->getName()); LLDB_LOG(log, " [COID] Before:\n{0}", ClangUtil::DumpDecl(interface_decl)); ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl); if (original.Valid()) { if (ObjCInterfaceDecl *original_iface_decl = dyn_cast(original.decl)) { ObjCInterfaceDecl *complete_iface_decl = GetCompleteObjCInterface(original_iface_decl); if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl); } } } m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl); if (interface_decl->getSuperClass() && interface_decl->getSuperClass() != interface_decl) CompleteType(interface_decl->getSuperClass()); LLDB_LOG(log, " [COID] After:"); LLDB_LOG(log, " [COID] {0}", ClangUtil::DumpDecl(interface_decl)); } clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface( const clang::ObjCInterfaceDecl *interface_decl) { lldb::ProcessSP process(m_target->GetProcessSP()); if (!process) return nullptr; ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); if (!language_runtime) return nullptr; ConstString class_name(interface_decl->getNameAsString().c_str()); lldb::TypeSP complete_type_sp( language_runtime->LookupInCompleteClassCache(class_name)); if (!complete_type_sp) return nullptr; TypeFromUser complete_type = TypeFromUser(complete_type_sp->GetFullCompilerType()); lldb::opaque_compiler_type_t complete_opaque_type = complete_type.GetOpaqueQualType(); if (!complete_opaque_type) return nullptr; const clang::Type *complete_clang_type = QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr(); const ObjCInterfaceType *complete_interface_type = dyn_cast(complete_clang_type); if (!complete_interface_type) return nullptr; ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl()); return complete_iface_decl; } void ClangASTSource::FindExternalLexicalDecls( const DeclContext *decl_context, llvm::function_ref predicate, llvm::SmallVectorImpl &decls) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); const Decl *context_decl = dyn_cast(decl_context); if (!context_decl) return; auto iter = m_active_lexical_decls.find(context_decl); if (iter != m_active_lexical_decls.end()) return; m_active_lexical_decls.insert(context_decl); ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl); if (log) { if (const NamedDecl *context_named_decl = dyn_cast(context_decl)) LLDB_LOG(log, "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in " "'{2}' (%sDecl*){3}", m_ast_context, m_clang_ast_context->getDisplayName(), context_named_decl->getNameAsString().c_str(), context_decl->getDeclKindName(), static_cast(context_decl)); else if (context_decl) LLDB_LOG(log, "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in " "({2}Decl*){3}", m_ast_context, m_clang_ast_context->getDisplayName(), context_decl->getDeclKindName(), static_cast(context_decl)); else LLDB_LOG(log, "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in a " "NULL context", m_ast_context, m_clang_ast_context->getDisplayName()); } ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(context_decl); if (!original.Valid()) return; LLDB_LOG(log, " FELD Original decl {0} (Decl*){1:x}:\n{2}", static_cast(original.ctx), static_cast(original.decl), ClangUtil::DumpDecl(original.decl)); if (ObjCInterfaceDecl *original_iface_decl = dyn_cast(original.decl)) { ObjCInterfaceDecl *complete_iface_decl = GetCompleteObjCInterface(original_iface_decl); if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { original.decl = complete_iface_decl; original.ctx = &complete_iface_decl->getASTContext(); m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl); } } if (TagDecl *original_tag_decl = dyn_cast(original.decl)) { ExternalASTSource *external_source = original.ctx->getExternalSource(); if (external_source) external_source->CompleteType(original_tag_decl); } const DeclContext *original_decl_context = dyn_cast(original.decl); if (!original_decl_context) return; // Indicates whether we skipped any Decls of the original DeclContext. bool SkippedDecls = false; for (Decl *decl : original_decl_context->decls()) { // The predicate function returns true if the passed declaration kind is // the one we are looking for. // See clang::ExternalASTSource::FindExternalLexicalDecls() if (predicate(decl->getKind())) { if (log) { std::string ast_dump = ClangUtil::DumpDecl(decl); if (const NamedDecl *context_named_decl = dyn_cast(context_decl)) LLDB_LOG(log, " FELD Adding [to {0}Decl {1}] lexical {2}Decl {3}", context_named_decl->getDeclKindName(), context_named_decl->getName(), decl->getDeclKindName(), ast_dump); else LLDB_LOG(log, " FELD Adding lexical {0}Decl {1}", decl->getDeclKindName(), ast_dump); } Decl *copied_decl = CopyDecl(decl); if (!copied_decl) continue; // FIXME: We should add the copied decl to the 'decls' list. This would // add the copied Decl into the DeclContext and make sure that we // correctly propagate that we added some Decls back to Clang. // By leaving 'decls' empty we incorrectly return false from // DeclContext::LoadLexicalDeclsFromExternalStorage which might cause // lookup issues later on. // We can't just add them for now as the ASTImporter already added the // decl into the DeclContext and this would add it twice. if (FieldDecl *copied_field = dyn_cast(copied_decl)) { QualType copied_field_type = copied_field->getType(); m_ast_importer_sp->RequireCompleteType(copied_field_type); } } else { SkippedDecls = true; } } // CopyDecl may build a lookup table which may set up ExternalLexicalStorage // to false. However, since we skipped some of the external Decls we must // set it back! if (SkippedDecls) { decl_context->setHasExternalLexicalStorage(true); // This sets HasLazyExternalLexicalLookups to true. By setting this bit we // ensure that the lookup table is rebuilt, which means the external source // is consulted again when a clang::DeclContext::lookup is called. const_cast(decl_context)->setMustBuildLookupTable(); } return; } void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) { assert(m_ast_context); const ConstString name(context.m_decl_name.getAsString().c_str()); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); if (log) { if (!context.m_decl_context) LLDB_LOG(log, "ClangASTSource::FindExternalVisibleDecls on " "(ASTContext*){0} '{1}' for '{2}' in a NULL DeclContext", m_ast_context, m_clang_ast_context->getDisplayName(), name); else if (const NamedDecl *context_named_decl = dyn_cast(context.m_decl_context)) LLDB_LOG(log, "ClangASTSource::FindExternalVisibleDecls on " "(ASTContext*){0} '{1}' for '{2}' in '{3}'", m_ast_context, m_clang_ast_context->getDisplayName(), name, context_named_decl->getName()); else LLDB_LOG(log, "ClangASTSource::FindExternalVisibleDecls on " "(ASTContext*){0} '{1}' for '{2}' in a '{3}'", m_ast_context, m_clang_ast_context->getDisplayName(), name, context.m_decl_context->getDeclKindName()); } if (isa(context.m_decl_context)) { LookupInNamespace(context); } else if (isa(context.m_decl_context)) { FindObjCPropertyAndIvarDecls(context); } else if (!isa(context.m_decl_context)) { // we shouldn't be getting FindExternalVisibleDecls calls for these return; } else { CompilerDeclContext namespace_decl; LLDB_LOG(log, " CAS::FEVD Searching the root namespace"); FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl); } if (!context.m_namespace_map->empty()) { if (log && log->GetVerbose()) LLDB_LOG(log, " CAS::FEVD Registering namespace map {0} ({1} entries)", context.m_namespace_map.get(), context.m_namespace_map->size()); NamespaceDecl *clang_namespace_decl = AddNamespace(context, context.m_namespace_map); if (clang_namespace_decl) clang_namespace_decl->setHasExternalVisibleStorage(); } } clang::Sema *ClangASTSource::getSema() { return m_clang_ast_context->getSema(); } bool ClangASTSource::IgnoreName(const ConstString name, bool ignore_all_dollar_names) { static const ConstString id_name("id"); static const ConstString Class_name("Class"); if (m_ast_context->getLangOpts().ObjC) if (name == id_name || name == Class_name) return true; StringRef name_string_ref = name.GetStringRef(); // The ClangASTSource is not responsible for finding $-names. return name_string_ref.empty() || (ignore_all_dollar_names && name_string_ref.startswith("$")) || name_string_ref.startswith("_$"); } void ClangASTSource::FindExternalVisibleDecls( NameSearchContext &context, lldb::ModuleSP module_sp, CompilerDeclContext &namespace_decl) { assert(m_ast_context); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); SymbolContextList sc_list; const ConstString name(context.m_decl_name.getAsString().c_str()); if (IgnoreName(name, true)) return; if (!m_target) return; FillNamespaceMap(context, module_sp, namespace_decl); if (context.m_found_type) return; TypeList types; const bool exact_match = true; llvm::DenseSet searched_symbol_files; if (module_sp && namespace_decl) module_sp->FindTypesInNamespace(name, namespace_decl, 1, types); else { m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1, searched_symbol_files, types); } if (size_t num_types = types.GetSize()) { for (size_t ti = 0; ti < num_types; ++ti) { lldb::TypeSP type_sp = types.GetTypeAtIndex(ti); if (log) { const char *name_string = type_sp->GetName().GetCString(); LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\": {1}", name, (name_string ? name_string : "")); } CompilerType full_type = type_sp->GetFullCompilerType(); CompilerType copied_clang_type(GuardedCopyType(full_type)); if (!copied_clang_type) { LLDB_LOG(log, " CAS::FEVD - Couldn't export a type"); continue; } context.AddTypeDecl(copied_clang_type); context.m_found_type = true; break; } } if (!context.m_found_type) { // Try the modules next. FindDeclInModules(context, name); } if (!context.m_found_type) { FindDeclInObjCRuntime(context, name); } } void ClangASTSource::FillNamespaceMap( NameSearchContext &context, lldb::ModuleSP module_sp, const CompilerDeclContext &namespace_decl) { const ConstString name(context.m_decl_name.getAsString().c_str()); if (IgnoreName(name, true)) return; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); if (module_sp && namespace_decl) { CompilerDeclContext found_namespace_decl; if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) { found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl); if (found_namespace_decl) { context.m_namespace_map->push_back( std::pair( module_sp, found_namespace_decl)); LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name, module_sp->GetFileSpec().GetFilename()); } } return; } const ModuleList &target_images = m_target->GetImages(); std::lock_guard guard(target_images.GetMutex()); for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) { lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i); if (!image) continue; CompilerDeclContext found_namespace_decl; SymbolFile *symbol_file = image->GetSymbolFile(); if (!symbol_file) continue; found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl); if (found_namespace_decl) { context.m_namespace_map->push_back( std::pair(image, found_namespace_decl)); LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name, image->GetFileSpec().GetFilename()); } } } template class TaggedASTDecl { public: TaggedASTDecl() : decl(nullptr) {} TaggedASTDecl(D *_decl) : decl(_decl) {} bool IsValid() const { return (decl != nullptr); } bool IsInvalid() const { return !IsValid(); } D *operator->() const { return decl; } D *decl; }; template class TD, class D1> TD DynCast(TD source) { return TD(dyn_cast(source.decl)); } template class DeclFromParser; template class DeclFromUser; template class DeclFromParser : public TaggedASTDecl { public: DeclFromParser() : TaggedASTDecl() {} DeclFromParser(D *_decl) : TaggedASTDecl(_decl) {} DeclFromUser GetOrigin(ClangASTSource &source); }; template class DeclFromUser : public TaggedASTDecl { public: DeclFromUser() : TaggedASTDecl() {} DeclFromUser(D *_decl) : TaggedASTDecl(_decl) {} DeclFromParser Import(ClangASTSource &source); }; template DeclFromUser DeclFromParser::GetOrigin(ClangASTSource &source) { ClangASTImporter::DeclOrigin origin = source.GetDeclOrigin(this->decl); if (!origin.Valid()) return DeclFromUser(); return DeclFromUser(dyn_cast(origin.decl)); } template DeclFromParser DeclFromUser::Import(ClangASTSource &source) { DeclFromParser<> parser_generic_decl(source.CopyDecl(this->decl)); if (parser_generic_decl.IsInvalid()) return DeclFromParser(); return DeclFromParser(dyn_cast(parser_generic_decl.decl)); } bool ClangASTSource::FindObjCMethodDeclsWithOrigin( NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl, const char *log_info) { const DeclarationName &decl_name(context.m_decl_name); clang::ASTContext *original_ctx = &original_interface_decl->getASTContext(); Selector original_selector; if (decl_name.isObjCZeroArgSelector()) { IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString()); original_selector = original_ctx->Selectors.getSelector(0, &ident); } else if (decl_name.isObjCOneArgSelector()) { const std::string &decl_name_string = decl_name.getAsString(); std::string decl_name_string_without_colon(decl_name_string.c_str(), decl_name_string.length() - 1); IdentifierInfo *ident = &original_ctx->Idents.get(decl_name_string_without_colon); original_selector = original_ctx->Selectors.getSelector(1, &ident); } else { SmallVector idents; clang::Selector sel = decl_name.getObjCSelector(); unsigned num_args = sel.getNumArgs(); for (unsigned i = 0; i != num_args; ++i) { idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i))); } original_selector = original_ctx->Selectors.getSelector(num_args, idents.data()); } DeclarationName original_decl_name(original_selector); llvm::SmallVector methods; TypeSystemClang::GetCompleteDecl(original_ctx, original_interface_decl); if (ObjCMethodDecl *instance_method_decl = original_interface_decl->lookupInstanceMethod(original_selector)) { methods.push_back(instance_method_decl); } else if (ObjCMethodDecl *class_method_decl = original_interface_decl->lookupClassMethod( original_selector)) { methods.push_back(class_method_decl); } if (methods.empty()) { return false; } for (NamedDecl *named_decl : methods) { if (!named_decl) continue; ObjCMethodDecl *result_method = dyn_cast(named_decl); if (!result_method) continue; Decl *copied_decl = CopyDecl(result_method); if (!copied_decl) continue; ObjCMethodDecl *copied_method_decl = dyn_cast(copied_decl); if (!copied_method_decl) continue; Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); LLDB_LOG(log, " CAS::FOMD found ({0}) {1}", log_info, ClangUtil::DumpDecl(copied_method_decl)); context.AddNamedDecl(copied_method_decl); } return true; } void ClangASTSource::FindDeclInModules(NameSearchContext &context, ConstString name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); ClangModulesDeclVendor *modules_decl_vendor = m_target->GetClangModulesDeclVendor(); if (!modules_decl_vendor) return; bool append = false; uint32_t max_matches = 1; std::vector decls; if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls)) return; LLDB_LOG(log, " CAS::FEVD Matching entity found for \"{0}\" in the modules", name); clang::NamedDecl *const decl_from_modules = decls[0]; if (llvm::isa(decl_from_modules) || llvm::isa(decl_from_modules) || llvm::isa(decl_from_modules)) { clang::Decl *copied_decl = CopyDecl(decl_from_modules); clang::NamedDecl *copied_named_decl = copied_decl ? dyn_cast(copied_decl) : nullptr; if (!copied_named_decl) { LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the modules"); return; } context.AddNamedDecl(copied_named_decl); context.m_found_type = true; } } void ClangASTSource::FindDeclInObjCRuntime(NameSearchContext &context, ConstString name) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); lldb::ProcessSP process(m_target->GetProcessSP()); if (!process) return; ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); if (!language_runtime) return; DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); if (!decl_vendor) return; bool append = false; uint32_t max_matches = 1; std::vector decls; auto *clang_decl_vendor = llvm::cast(decl_vendor); if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls)) return; LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\" in the runtime", name); clang::Decl *copied_decl = CopyDecl(decls[0]); clang::NamedDecl *copied_named_decl = copied_decl ? dyn_cast(copied_decl) : nullptr; if (!copied_named_decl) { LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the runtime"); return; } context.AddNamedDecl(copied_named_decl); } void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); const DeclarationName &decl_name(context.m_decl_name); const DeclContext *decl_ctx(context.m_decl_context); const ObjCInterfaceDecl *interface_decl = dyn_cast(decl_ctx); if (!interface_decl) return; do { ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl); if (!original.Valid()) break; ObjCInterfaceDecl *original_interface_decl = dyn_cast(original.decl); if (FindObjCMethodDeclsWithOrigin(context, original_interface_decl, "at origin")) return; // found it, no need to look any further } while (false); StreamString ss; if (decl_name.isObjCZeroArgSelector()) { ss.Printf("%s", decl_name.getAsString().c_str()); } else if (decl_name.isObjCOneArgSelector()) { ss.Printf("%s", decl_name.getAsString().c_str()); } else { clang::Selector sel = decl_name.getObjCSelector(); for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) { llvm::StringRef r = sel.getNameForSlot(i); ss.Printf("%s:", r.str().c_str()); } } ss.Flush(); if (ss.GetString().contains("$__lldb")) return; // we don't need any results ConstString selector_name(ss.GetString()); LLDB_LOG(log, "ClangASTSource::FindObjCMethodDecls on (ASTContext*){0} '{1}' " "for selector [{2} {3}]", m_ast_context, m_clang_ast_context->getDisplayName(), interface_decl->getName(), selector_name); SymbolContextList sc_list; const bool include_symbols = false; const bool include_inlines = false; std::string interface_name = interface_decl->getNameAsString(); do { StreamString ms; ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString()); ms.Flush(); ConstString instance_method_name(ms.GetString()); sc_list.Clear(); m_target->GetImages().FindFunctions( instance_method_name, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, sc_list); if (sc_list.GetSize()) break; ms.Clear(); ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString()); ms.Flush(); ConstString class_method_name(ms.GetString()); sc_list.Clear(); m_target->GetImages().FindFunctions( class_method_name, lldb::eFunctionNameTypeFull, include_symbols, include_inlines, sc_list); if (sc_list.GetSize()) break; // Fall back and check for methods in categories. If we find methods this // way, we need to check that they're actually in categories on the desired // class. SymbolContextList candidate_sc_list; m_target->GetImages().FindFunctions( selector_name, lldb::eFunctionNameTypeSelector, include_symbols, include_inlines, candidate_sc_list); for (uint32_t ci = 0, ce = candidate_sc_list.GetSize(); ci != ce; ++ci) { SymbolContext candidate_sc; if (!candidate_sc_list.GetContextAtIndex(ci, candidate_sc)) continue; if (!candidate_sc.function) continue; const char *candidate_name = candidate_sc.function->GetName().AsCString(); const char *cursor = candidate_name; if (*cursor != '+' && *cursor != '-') continue; ++cursor; if (*cursor != '[') continue; ++cursor; size_t interface_len = interface_name.length(); if (strncmp(cursor, interface_name.c_str(), interface_len)) continue; cursor += interface_len; if (*cursor == ' ' || *cursor == '(') sc_list.Append(candidate_sc); } } while (false); if (sc_list.GetSize()) { // We found a good function symbol. Use that. for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) { SymbolContext sc; if (!sc_list.GetContextAtIndex(i, sc)) continue; if (!sc.function) continue; CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext(); if (!function_decl_ctx) continue; ObjCMethodDecl *method_decl = TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx); if (!method_decl) continue; ObjCInterfaceDecl *found_interface_decl = method_decl->getClassInterface(); if (!found_interface_decl) continue; if (found_interface_decl->getName() == interface_decl->getName()) { Decl *copied_decl = CopyDecl(method_decl); if (!copied_decl) continue; ObjCMethodDecl *copied_method_decl = dyn_cast(copied_decl); if (!copied_method_decl) continue; LLDB_LOG(log, " CAS::FOMD found (in symbols)\n{0}", ClangUtil::DumpDecl(copied_method_decl)); context.AddNamedDecl(copied_method_decl); } } return; } // Try the debug information. do { ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( const_cast(interface_decl)); if (!complete_interface_decl) break; // We found the complete interface. The runtime never needs to be queried // in this scenario. DeclFromUser complete_iface_decl( complete_interface_decl); if (complete_interface_decl == interface_decl) break; // already checked this one LLDB_LOG(log, "CAS::FOPD trying origin " "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", complete_interface_decl, &complete_iface_decl->getASTContext()); FindObjCMethodDeclsWithOrigin(context, complete_interface_decl, "in debug info"); return; } while (false); do { // Check the modules only if the debug information didn't have a complete // interface. if (ClangModulesDeclVendor *modules_decl_vendor = m_target->GetClangModulesDeclVendor()) { ConstString interface_name(interface_decl->getNameAsString().c_str()); bool append = false; uint32_t max_matches = 1; std::vector decls; if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches, decls)) break; ObjCInterfaceDecl *interface_decl_from_modules = dyn_cast(decls[0]); if (!interface_decl_from_modules) break; if (FindObjCMethodDeclsWithOrigin(context, interface_decl_from_modules, "in modules")) return; } } while (false); do { // Check the runtime only if the debug information didn't have a complete // interface and the modules don't get us anywhere. lldb::ProcessSP process(m_target->GetProcessSP()); if (!process) break; ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); if (!language_runtime) break; DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); if (!decl_vendor) break; ConstString interface_name(interface_decl->getNameAsString().c_str()); bool append = false; uint32_t max_matches = 1; std::vector decls; auto *clang_decl_vendor = llvm::cast(decl_vendor); if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches, decls)) break; ObjCInterfaceDecl *runtime_interface_decl = dyn_cast(decls[0]); if (!runtime_interface_decl) break; FindObjCMethodDeclsWithOrigin(context, runtime_interface_decl, "in runtime"); } while (false); } static bool FindObjCPropertyAndIvarDeclsWithOrigin( NameSearchContext &context, ClangASTSource &source, DeclFromUser &origin_iface_decl) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); if (origin_iface_decl.IsInvalid()) return false; std::string name_str = context.m_decl_name.getAsString(); StringRef name(name_str); IdentifierInfo &name_identifier( origin_iface_decl->getASTContext().Idents.get(name)); DeclFromUser origin_property_decl( origin_iface_decl->FindPropertyDeclaration( &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance)); bool found = false; if (origin_property_decl.IsValid()) { DeclFromParser parser_property_decl( origin_property_decl.Import(source)); if (parser_property_decl.IsValid()) { LLDB_LOG(log, " CAS::FOPD found\n{0}", ClangUtil::DumpDecl(parser_property_decl.decl)); context.AddNamedDecl(parser_property_decl.decl); found = true; } } DeclFromUser origin_ivar_decl( origin_iface_decl->getIvarDecl(&name_identifier)); if (origin_ivar_decl.IsValid()) { DeclFromParser parser_ivar_decl( origin_ivar_decl.Import(source)); if (parser_ivar_decl.IsValid()) { LLDB_LOG(log, " CAS::FOPD found\n{0}", ClangUtil::DumpDecl(parser_ivar_decl.decl)); context.AddNamedDecl(parser_ivar_decl.decl); found = true; } } return found; } void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); DeclFromParser parser_iface_decl( cast(context.m_decl_context)); DeclFromUser origin_iface_decl( parser_iface_decl.GetOrigin(*this)); ConstString class_name(parser_iface_decl->getNameAsString().c_str()); LLDB_LOG(log, "ClangASTSource::FindObjCPropertyAndIvarDecls on " "(ASTContext*){0} '{1}' for '{2}.{3}'", m_ast_context, m_clang_ast_context->getDisplayName(), parser_iface_decl->getName(), context.m_decl_name.getAsString()); if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, origin_iface_decl)) return; LLDB_LOG(log, "CAS::FOPD couldn't find the property on origin " "(ObjCInterfaceDecl*){0}/(ASTContext*){1}, searching " "elsewhere...", origin_iface_decl.decl, &origin_iface_decl->getASTContext()); SymbolContext null_sc; TypeList type_list; do { ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( const_cast(parser_iface_decl.decl)); if (!complete_interface_decl) break; // We found the complete interface. The runtime never needs to be queried // in this scenario. DeclFromUser complete_iface_decl( complete_interface_decl); if (complete_iface_decl.decl == origin_iface_decl.decl) break; // already checked this one LLDB_LOG(log, "CAS::FOPD trying origin " "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", complete_iface_decl.decl, &complete_iface_decl->getASTContext()); FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, complete_iface_decl); return; } while (false); do { // Check the modules only if the debug information didn't have a complete // interface. ClangModulesDeclVendor *modules_decl_vendor = m_target->GetClangModulesDeclVendor(); if (!modules_decl_vendor) break; bool append = false; uint32_t max_matches = 1; std::vector decls; if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls)) break; DeclFromUser interface_decl_from_modules( dyn_cast(decls[0])); if (!interface_decl_from_modules.IsValid()) break; LLDB_LOG(log, "CAS::FOPD[{0}] trying module " "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", interface_decl_from_modules.decl, &interface_decl_from_modules->getASTContext()); if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, interface_decl_from_modules)) return; } while (false); do { // Check the runtime only if the debug information didn't have a complete // interface and nothing was in the modules. lldb::ProcessSP process(m_target->GetProcessSP()); if (!process) return; ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); if (!language_runtime) return; DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); if (!decl_vendor) break; bool append = false; uint32_t max_matches = 1; std::vector decls; auto *clang_decl_vendor = llvm::cast(decl_vendor); if (!clang_decl_vendor->FindDecls(class_name, append, max_matches, decls)) break; DeclFromUser interface_decl_from_runtime( dyn_cast(decls[0])); if (!interface_decl_from_runtime.IsValid()) break; LLDB_LOG(log, "CAS::FOPD[{0}] trying runtime " "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", interface_decl_from_runtime.decl, &interface_decl_from_runtime->getASTContext()); if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, interface_decl_from_runtime)) return; } while (false); } void ClangASTSource::LookupInNamespace(NameSearchContext &context) { const NamespaceDecl *namespace_context = dyn_cast(context.m_decl_context); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer_sp->GetNamespaceMap(namespace_context); LLDB_LOGV(log, " CAS::FEVD Inspecting namespace map {0} ({1} entries)", namespace_map.get(), namespace_map->size()); if (!namespace_map) return; for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), e = namespace_map->end(); i != e; ++i) { LLDB_LOG(log, " CAS::FEVD Searching namespace {0} in module {1}", i->second.GetName(), i->first->GetFileSpec().GetFilename()); FindExternalVisibleDecls(context, i->first, i->second); } } typedef llvm::DenseMap FieldOffsetMap; typedef llvm::DenseMap BaseOffsetMap; template static bool ImportOffsetMap(llvm::DenseMap &destination_map, llvm::DenseMap &source_map, ClangASTSource &source) { // When importing fields into a new record, clang has a hard requirement that // fields be imported in field offset order. Since they are stored in a // DenseMap with a pointer as the key type, this means we cannot simply // iterate over the map, as the order will be non-deterministic. Instead we // have to sort by the offset and then insert in sorted order. typedef llvm::DenseMap MapType; typedef typename MapType::value_type PairType; std::vector sorted_items; sorted_items.reserve(source_map.size()); sorted_items.assign(source_map.begin(), source_map.end()); llvm::sort(sorted_items.begin(), sorted_items.end(), [](const PairType &lhs, const PairType &rhs) { return lhs.second < rhs.second; }); for (const auto &item : sorted_items) { DeclFromUser user_decl(const_cast(item.first)); DeclFromParser parser_decl(user_decl.Import(source)); if (parser_decl.IsInvalid()) return false; destination_map.insert( std::pair(parser_decl.decl, item.second)); } return true; } template bool ExtractBaseOffsets(const ASTRecordLayout &record_layout, DeclFromUser &record, BaseOffsetMap &base_offsets) { for (CXXRecordDecl::base_class_const_iterator bi = (IsVirtual ? record->vbases_begin() : record->bases_begin()), be = (IsVirtual ? record->vbases_end() : record->bases_end()); bi != be; ++bi) { if (!IsVirtual && bi->isVirtual()) continue; const clang::Type *origin_base_type = bi->getType().getTypePtr(); const clang::RecordType *origin_base_record_type = origin_base_type->getAs(); if (!origin_base_record_type) return false; DeclFromUser origin_base_record( origin_base_record_type->getDecl()); if (origin_base_record.IsInvalid()) return false; DeclFromUser origin_base_cxx_record( DynCast(origin_base_record)); if (origin_base_cxx_record.IsInvalid()) return false; CharUnits base_offset; if (IsVirtual) base_offset = record_layout.getVBaseClassOffset(origin_base_cxx_record.decl); else base_offset = record_layout.getBaseClassOffset(origin_base_cxx_record.decl); base_offsets.insert(std::pair( origin_base_cxx_record.decl, base_offset)); } return true; } bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size, uint64_t &alignment, FieldOffsetMap &field_offsets, BaseOffsetMap &base_offsets, BaseOffsetMap &virtual_base_offsets) { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); LLDB_LOG(log, "LayoutRecordType on (ASTContext*){0} '{1}' for (RecordDecl*)" "{3} [name = '{4}']", m_ast_context, m_clang_ast_context->getDisplayName(), record, record->getName()); DeclFromParser parser_record(record); DeclFromUser origin_record( parser_record.GetOrigin(*this)); if (origin_record.IsInvalid()) return false; FieldOffsetMap origin_field_offsets; BaseOffsetMap origin_base_offsets; BaseOffsetMap origin_virtual_base_offsets; TypeSystemClang::GetCompleteDecl( &origin_record->getASTContext(), const_cast(origin_record.decl)); clang::RecordDecl *definition = origin_record.decl->getDefinition(); if (!definition || !definition->isCompleteDefinition()) return false; const ASTRecordLayout &record_layout( origin_record->getASTContext().getASTRecordLayout(origin_record.decl)); int field_idx = 0, field_count = record_layout.getFieldCount(); for (RecordDecl::field_iterator fi = origin_record->field_begin(), fe = origin_record->field_end(); fi != fe; ++fi) { if (field_idx >= field_count) return false; // Layout didn't go well. Bail out. uint64_t field_offset = record_layout.getFieldOffset(field_idx); origin_field_offsets.insert( std::pair(*fi, field_offset)); field_idx++; } lldbassert(&record->getASTContext() == m_ast_context); DeclFromUser origin_cxx_record( DynCast(origin_record)); if (origin_cxx_record.IsValid()) { if (!ExtractBaseOffsets(record_layout, origin_cxx_record, origin_base_offsets) || !ExtractBaseOffsets(record_layout, origin_cxx_record, origin_virtual_base_offsets)) return false; } if (!ImportOffsetMap(field_offsets, origin_field_offsets, *this) || !ImportOffsetMap(base_offsets, origin_base_offsets, *this) || !ImportOffsetMap(virtual_base_offsets, origin_virtual_base_offsets, *this)) return false; size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth(); alignment = record_layout.getAlignment().getQuantity() * m_ast_context->getCharWidth(); if (log) { LLDB_LOG(log, "LRT returned:"); LLDB_LOG(log, "LRT Original = (RecordDecl*)%p", static_cast(origin_record.decl)); LLDB_LOG(log, "LRT Size = %" PRId64, size); LLDB_LOG(log, "LRT Alignment = %" PRId64, alignment); LLDB_LOG(log, "LRT Fields:"); for (RecordDecl::field_iterator fi = record->field_begin(), fe = record->field_end(); fi != fe; ++fi) { LLDB_LOG(log, "LRT (FieldDecl*){0}, Name = '{1}', Offset = {2} bits", *fi, fi->getName(), field_offsets[*fi]); } DeclFromParser parser_cxx_record = DynCast(parser_record); if (parser_cxx_record.IsValid()) { LLDB_LOG(log, "LRT Bases:"); for (CXXRecordDecl::base_class_const_iterator bi = parser_cxx_record->bases_begin(), be = parser_cxx_record->bases_end(); bi != be; ++bi) { bool is_virtual = bi->isVirtual(); QualType base_type = bi->getType(); const RecordType *base_record_type = base_type->getAs(); DeclFromParser base_record(base_record_type->getDecl()); DeclFromParser base_cxx_record = DynCast(base_record); LLDB_LOG(log, "LRT {0}(CXXRecordDecl*){1}, Name = '{2}', Offset = " "{3} chars", (is_virtual ? "Virtual " : ""), base_cxx_record.decl, base_cxx_record.decl->getName(), (is_virtual ? virtual_base_offsets[base_cxx_record.decl].getQuantity() : base_offsets[base_cxx_record.decl].getQuantity())); } } else { LLDB_LOG(log, "LRD Not a CXXRecord, so no bases"); } } return true; } void ClangASTSource::CompleteNamespaceMap( ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name, ClangASTImporter::NamespaceMapSP &parent_map) const { Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); if (log) { if (parent_map && parent_map->size()) LLDB_LOG(log, "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching " "for namespace {2} in namespace {3}", m_ast_context, m_clang_ast_context->getDisplayName(), name, parent_map->begin()->second.GetName()); else LLDB_LOG(log, "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching " "for namespace {2}", m_ast_context, m_clang_ast_context->getDisplayName(), name); } if (parent_map) { for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(), e = parent_map->end(); i != e; ++i) { CompilerDeclContext found_namespace_decl; lldb::ModuleSP module_sp = i->first; CompilerDeclContext module_parent_namespace_decl = i->second; SymbolFile *symbol_file = module_sp->GetSymbolFile(); if (!symbol_file) continue; found_namespace_decl = symbol_file->FindNamespace(name, module_parent_namespace_decl); if (!found_namespace_decl) continue; namespace_map->push_back(std::pair( module_sp, found_namespace_decl)); LLDB_LOG(log, " CMN Found namespace {0} in module {1}", name, module_sp->GetFileSpec().GetFilename()); } } else { const ModuleList &target_images = m_target->GetImages(); std::lock_guard guard(target_images.GetMutex()); CompilerDeclContext null_namespace_decl; for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) { lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i); if (!image) continue; CompilerDeclContext found_namespace_decl; SymbolFile *symbol_file = image->GetSymbolFile(); if (!symbol_file) continue; found_namespace_decl = symbol_file->FindNamespace(name, null_namespace_decl); if (!found_namespace_decl) continue; namespace_map->push_back(std::pair( image, found_namespace_decl)); LLDB_LOG(log, " CMN[{0}] Found namespace {0} in module {1}", name, image->GetFileSpec().GetFilename()); } } } NamespaceDecl *ClangASTSource::AddNamespace( NameSearchContext &context, ClangASTImporter::NamespaceMapSP &namespace_decls) { if (!namespace_decls) return nullptr; const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second; clang::ASTContext *src_ast = TypeSystemClang::DeclContextGetTypeSystemClang(namespace_decl); if (!src_ast) return nullptr; clang::NamespaceDecl *src_namespace_decl = TypeSystemClang::DeclContextGetAsNamespaceDecl(namespace_decl); if (!src_namespace_decl) return nullptr; Decl *copied_decl = CopyDecl(src_namespace_decl); if (!copied_decl) return nullptr; NamespaceDecl *copied_namespace_decl = dyn_cast(copied_decl); if (!copied_namespace_decl) return nullptr; context.m_decls.push_back(copied_namespace_decl); m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl, namespace_decls); return dyn_cast(copied_decl); } clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) { return m_ast_importer_sp->CopyDecl(m_ast_context, src_decl); } ClangASTImporter::DeclOrigin ClangASTSource::GetDeclOrigin(const clang::Decl *decl) { return m_ast_importer_sp->GetDeclOrigin(decl); } CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) { TypeSystemClang *src_ast = llvm::dyn_cast_or_null(src_type.GetTypeSystem()); if (src_ast == nullptr) return CompilerType(); QualType copied_qual_type = ClangUtil::GetQualType( m_ast_importer_sp->CopyType(*m_clang_ast_context, src_type)); if (copied_qual_type.getAsOpaquePtr() && copied_qual_type->getCanonicalTypeInternal().isNull()) // this shouldn't happen, but we're hardening because the AST importer // seems to be generating bad types on occasion. return CompilerType(); return m_clang_ast_context->GetType(copied_qual_type); }