15ffd83dbSDimitry Andric //===-- ClangASTSource.cpp ------------------------------------------------===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric 90b57cec5SDimitry Andric #include "ClangASTSource.h" 100b57cec5SDimitry Andric 119dba64beSDimitry Andric #include "ClangDeclVendor.h" 120b57cec5SDimitry Andric #include "ClangModulesDeclVendor.h" 130b57cec5SDimitry Andric 140b57cec5SDimitry Andric #include "lldb/Core/Module.h" 150b57cec5SDimitry Andric #include "lldb/Core/ModuleList.h" 160b57cec5SDimitry Andric #include "lldb/Symbol/CompilerDeclContext.h" 170b57cec5SDimitry Andric #include "lldb/Symbol/Function.h" 180b57cec5SDimitry Andric #include "lldb/Symbol/SymbolFile.h" 190b57cec5SDimitry Andric #include "lldb/Symbol/TaggedASTType.h" 200b57cec5SDimitry Andric #include "lldb/Target/Target.h" 2181ad6265SDimitry Andric #include "lldb/Utility/LLDBLog.h" 220b57cec5SDimitry Andric #include "lldb/Utility/Log.h" 230b57cec5SDimitry Andric #include "clang/AST/ASTContext.h" 245ffd83dbSDimitry Andric #include "clang/Basic/SourceManager.h" 250b57cec5SDimitry Andric 265ffd83dbSDimitry Andric #include "Plugins/ExpressionParser/Clang/ClangUtil.h" 270b57cec5SDimitry Andric #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" 285ffd83dbSDimitry Andric #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 290b57cec5SDimitry Andric 300b57cec5SDimitry Andric #include <memory> 310b57cec5SDimitry Andric #include <vector> 320b57cec5SDimitry Andric 330b57cec5SDimitry Andric using namespace clang; 340b57cec5SDimitry Andric using namespace lldb_private; 350b57cec5SDimitry Andric 360b57cec5SDimitry Andric // Scoped class that will remove an active lexical decl from the set when it 370b57cec5SDimitry Andric // goes out of scope. 380b57cec5SDimitry Andric namespace { 390b57cec5SDimitry Andric class ScopedLexicalDeclEraser { 400b57cec5SDimitry Andric public: 410b57cec5SDimitry Andric ScopedLexicalDeclEraser(std::set<const clang::Decl *> &decls, 420b57cec5SDimitry Andric const clang::Decl *decl) 430b57cec5SDimitry Andric : m_active_lexical_decls(decls), m_decl(decl) {} 440b57cec5SDimitry Andric 450b57cec5SDimitry Andric ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); } 460b57cec5SDimitry Andric 470b57cec5SDimitry Andric private: 480b57cec5SDimitry Andric std::set<const clang::Decl *> &m_active_lexical_decls; 490b57cec5SDimitry Andric const clang::Decl *m_decl; 500b57cec5SDimitry Andric }; 510b57cec5SDimitry Andric } 520b57cec5SDimitry Andric 535ffd83dbSDimitry Andric ClangASTSource::ClangASTSource( 545ffd83dbSDimitry Andric const lldb::TargetSP &target, 555ffd83dbSDimitry Andric const std::shared_ptr<ClangASTImporter> &importer) 565ffd83dbSDimitry Andric : m_lookups_enabled(false), m_target(target), m_ast_context(nullptr), 575ffd83dbSDimitry Andric m_ast_importer_sp(importer), m_active_lexical_decls(), 585ffd83dbSDimitry Andric m_active_lookups() { 595ffd83dbSDimitry Andric assert(m_ast_importer_sp && "No ClangASTImporter passed to ClangASTSource?"); 600b57cec5SDimitry Andric } 610b57cec5SDimitry Andric 625ffd83dbSDimitry Andric void ClangASTSource::InstallASTContext(TypeSystemClang &clang_ast_context) { 63480093f4SDimitry Andric m_ast_context = &clang_ast_context.getASTContext(); 64480093f4SDimitry Andric m_clang_ast_context = &clang_ast_context; 65480093f4SDimitry Andric m_file_manager = &m_ast_context->getSourceManager().getFileManager(); 66480093f4SDimitry Andric m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this); 670b57cec5SDimitry Andric } 680b57cec5SDimitry Andric 690b57cec5SDimitry Andric ClangASTSource::~ClangASTSource() { 700b57cec5SDimitry Andric m_ast_importer_sp->ForgetDestination(m_ast_context); 710b57cec5SDimitry Andric 72480093f4SDimitry Andric if (!m_target) 73480093f4SDimitry Andric return; 740b57cec5SDimitry Andric 75e8d8bef9SDimitry Andric // Unregister the current ASTContext as a source for all scratch 76e8d8bef9SDimitry Andric // ASTContexts in the ClangASTImporter. Without this the scratch AST might 77e8d8bef9SDimitry Andric // query the deleted ASTContext for additional type information. 78e8d8bef9SDimitry Andric // We unregister from *all* scratch ASTContexts in case a type got exported 79e8d8bef9SDimitry Andric // to a scratch AST that isn't the best fitting scratch ASTContext. 80bdd1243dSDimitry Andric lldb::TypeSystemClangSP scratch_ts_sp = ScratchTypeSystemClang::GetForTarget( 81e8d8bef9SDimitry Andric *m_target, ScratchTypeSystemClang::DefaultAST, false); 82e8d8bef9SDimitry Andric 83bdd1243dSDimitry Andric if (!scratch_ts_sp) 840b57cec5SDimitry Andric return; 850b57cec5SDimitry Andric 86e8d8bef9SDimitry Andric ScratchTypeSystemClang *default_scratch_ast = 87bdd1243dSDimitry Andric llvm::cast<ScratchTypeSystemClang>(scratch_ts_sp.get()); 88e8d8bef9SDimitry Andric // Unregister from the default scratch AST (and all sub-ASTs). 89e8d8bef9SDimitry Andric default_scratch_ast->ForgetSource(m_ast_context, *m_ast_importer_sp); 900b57cec5SDimitry Andric } 910b57cec5SDimitry Andric 920b57cec5SDimitry Andric void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) { 930b57cec5SDimitry Andric if (!m_ast_context) 940b57cec5SDimitry Andric return; 950b57cec5SDimitry Andric 960b57cec5SDimitry Andric m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage(); 970b57cec5SDimitry Andric m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage(); 980b57cec5SDimitry Andric } 990b57cec5SDimitry Andric 1000b57cec5SDimitry Andric // The core lookup interface. 1010b57cec5SDimitry Andric bool ClangASTSource::FindExternalVisibleDeclsByName( 1020b57cec5SDimitry Andric const DeclContext *decl_ctx, DeclarationName clang_decl_name) { 1030b57cec5SDimitry Andric if (!m_ast_context) { 1040b57cec5SDimitry Andric SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 1050b57cec5SDimitry Andric return false; 1060b57cec5SDimitry Andric } 1070b57cec5SDimitry Andric 1080b57cec5SDimitry Andric std::string decl_name(clang_decl_name.getAsString()); 1090b57cec5SDimitry Andric 1100b57cec5SDimitry Andric switch (clang_decl_name.getNameKind()) { 1110b57cec5SDimitry Andric // Normal identifiers. 1120b57cec5SDimitry Andric case DeclarationName::Identifier: { 1130b57cec5SDimitry Andric clang::IdentifierInfo *identifier_info = 1140b57cec5SDimitry Andric clang_decl_name.getAsIdentifierInfo(); 1150b57cec5SDimitry Andric 1160b57cec5SDimitry Andric if (!identifier_info || identifier_info->getBuiltinID() != 0) { 1170b57cec5SDimitry Andric SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 1180b57cec5SDimitry Andric return false; 1190b57cec5SDimitry Andric } 1200b57cec5SDimitry Andric } break; 1210b57cec5SDimitry Andric 1220b57cec5SDimitry Andric // Operator names. 1230b57cec5SDimitry Andric case DeclarationName::CXXOperatorName: 1240b57cec5SDimitry Andric case DeclarationName::CXXLiteralOperatorName: 1250b57cec5SDimitry Andric break; 1260b57cec5SDimitry Andric 1270b57cec5SDimitry Andric // Using directives found in this context. 1280b57cec5SDimitry Andric // Tell Sema we didn't find any or we'll end up getting asked a *lot*. 1290b57cec5SDimitry Andric case DeclarationName::CXXUsingDirective: 1300b57cec5SDimitry Andric SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 1310b57cec5SDimitry Andric return false; 1320b57cec5SDimitry Andric 1330b57cec5SDimitry Andric case DeclarationName::ObjCZeroArgSelector: 1340b57cec5SDimitry Andric case DeclarationName::ObjCOneArgSelector: 1350b57cec5SDimitry Andric case DeclarationName::ObjCMultiArgSelector: { 1360b57cec5SDimitry Andric llvm::SmallVector<NamedDecl *, 1> method_decls; 1370b57cec5SDimitry Andric 1385ffd83dbSDimitry Andric NameSearchContext method_search_context(*m_clang_ast_context, method_decls, 1390b57cec5SDimitry Andric clang_decl_name, decl_ctx); 1400b57cec5SDimitry Andric 1410b57cec5SDimitry Andric FindObjCMethodDecls(method_search_context); 1420b57cec5SDimitry Andric 1430b57cec5SDimitry Andric SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls); 1440b57cec5SDimitry Andric return (method_decls.size() > 0); 1450b57cec5SDimitry Andric } 1460b57cec5SDimitry Andric // These aren't possible in the global context. 1470b57cec5SDimitry Andric case DeclarationName::CXXConstructorName: 1480b57cec5SDimitry Andric case DeclarationName::CXXDestructorName: 1490b57cec5SDimitry Andric case DeclarationName::CXXConversionFunctionName: 1500b57cec5SDimitry Andric case DeclarationName::CXXDeductionGuideName: 1510b57cec5SDimitry Andric SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 1520b57cec5SDimitry Andric return false; 1530b57cec5SDimitry Andric } 1540b57cec5SDimitry Andric 1550b57cec5SDimitry Andric if (!GetLookupsEnabled()) { 1560b57cec5SDimitry Andric // Wait until we see a '$' at the start of a name before we start doing any 1570b57cec5SDimitry Andric // lookups so we can avoid lookup up all of the builtin types. 1580b57cec5SDimitry Andric if (!decl_name.empty() && decl_name[0] == '$') { 1590b57cec5SDimitry Andric SetLookupsEnabled(true); 1600b57cec5SDimitry Andric } else { 1610b57cec5SDimitry Andric SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 1620b57cec5SDimitry Andric return false; 1630b57cec5SDimitry Andric } 1640b57cec5SDimitry Andric } 1650b57cec5SDimitry Andric 1660b57cec5SDimitry Andric ConstString const_decl_name(decl_name.c_str()); 1670b57cec5SDimitry Andric 1680b57cec5SDimitry Andric const char *uniqued_const_decl_name = const_decl_name.GetCString(); 1690b57cec5SDimitry Andric if (m_active_lookups.find(uniqued_const_decl_name) != 1700b57cec5SDimitry Andric m_active_lookups.end()) { 1710b57cec5SDimitry Andric // We are currently looking up this name... 1720b57cec5SDimitry Andric SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 1730b57cec5SDimitry Andric return false; 1740b57cec5SDimitry Andric } 1750b57cec5SDimitry Andric m_active_lookups.insert(uniqued_const_decl_name); 1760b57cec5SDimitry Andric llvm::SmallVector<NamedDecl *, 4> name_decls; 1775ffd83dbSDimitry Andric NameSearchContext name_search_context(*m_clang_ast_context, name_decls, 1785ffd83dbSDimitry Andric clang_decl_name, decl_ctx); 1790b57cec5SDimitry Andric FindExternalVisibleDecls(name_search_context); 1800b57cec5SDimitry Andric SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls); 1810b57cec5SDimitry Andric m_active_lookups.erase(uniqued_const_decl_name); 1820b57cec5SDimitry Andric return (name_decls.size() != 0); 1830b57cec5SDimitry Andric } 1840b57cec5SDimitry Andric 1855ffd83dbSDimitry Andric TagDecl *ClangASTSource::FindCompleteType(const TagDecl *decl) { 18681ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 1870b57cec5SDimitry Andric 1880b57cec5SDimitry Andric if (const NamespaceDecl *namespace_context = 1895ffd83dbSDimitry Andric dyn_cast<NamespaceDecl>(decl->getDeclContext())) { 1900b57cec5SDimitry Andric ClangASTImporter::NamespaceMapSP namespace_map = 1910b57cec5SDimitry Andric m_ast_importer_sp->GetNamespaceMap(namespace_context); 1920b57cec5SDimitry Andric 1930b57cec5SDimitry Andric if (!namespace_map) 1945ffd83dbSDimitry Andric return nullptr; 1950b57cec5SDimitry Andric 196*0fca6ea1SDimitry Andric LLDB_LOGV(log, " CTD Inspecting namespace map{0:x} ({1} entries)", 197972a253aSDimitry Andric namespace_map.get(), namespace_map->size()); 198972a253aSDimitry Andric 1995ffd83dbSDimitry Andric for (const ClangASTImporter::NamespaceMapItem &item : *namespace_map) { 2005ffd83dbSDimitry Andric LLDB_LOG(log, " CTD Searching namespace {0} in module {1}", 2015ffd83dbSDimitry Andric item.second.GetName(), item.first->GetFileSpec().GetFilename()); 2020b57cec5SDimitry Andric 2035ffd83dbSDimitry Andric ConstString name(decl->getName()); 2040b57cec5SDimitry Andric 2055f757f3fSDimitry Andric // Create a type matcher using the CompilerDeclContext for the namespace 2065f757f3fSDimitry Andric // as the context (item.second) and search for the name inside of this 2075f757f3fSDimitry Andric // context. 2085f757f3fSDimitry Andric TypeQuery query(item.second, name); 2095f757f3fSDimitry Andric TypeResults results; 2105f757f3fSDimitry Andric item.first->FindTypes(query, results); 2110b57cec5SDimitry Andric 2125f757f3fSDimitry Andric for (const lldb::TypeSP &type_sp : results.GetTypeMap().Types()) { 2135f757f3fSDimitry Andric CompilerType clang_type(type_sp->GetFullCompilerType()); 2140b57cec5SDimitry Andric 2150b57cec5SDimitry Andric if (!ClangUtil::IsClangType(clang_type)) 2160b57cec5SDimitry Andric continue; 2170b57cec5SDimitry Andric 2180b57cec5SDimitry Andric const TagType *tag_type = 2190b57cec5SDimitry Andric ClangUtil::GetQualType(clang_type)->getAs<TagType>(); 2200b57cec5SDimitry Andric 2210b57cec5SDimitry Andric if (!tag_type) 2220b57cec5SDimitry Andric continue; 2230b57cec5SDimitry Andric 2240b57cec5SDimitry Andric TagDecl *candidate_tag_decl = 2250b57cec5SDimitry Andric const_cast<TagDecl *>(tag_type->getDecl()); 2260b57cec5SDimitry Andric 2275ffd83dbSDimitry Andric if (TypeSystemClang::GetCompleteDecl( 2285ffd83dbSDimitry Andric &candidate_tag_decl->getASTContext(), candidate_tag_decl)) 2295ffd83dbSDimitry Andric return candidate_tag_decl; 2300b57cec5SDimitry Andric } 2310b57cec5SDimitry Andric } 2320b57cec5SDimitry Andric } else { 2330b57cec5SDimitry Andric const ModuleList &module_list = m_target->GetImages(); 2345f757f3fSDimitry Andric // Create a type matcher using a CompilerDecl. Each TypeSystem class knows 2355f757f3fSDimitry Andric // how to fill out a CompilerContext array using a CompilerDecl. 2365f757f3fSDimitry Andric TypeQuery query(CompilerDecl(m_clang_ast_context, (void *)decl)); 2375f757f3fSDimitry Andric TypeResults results; 2385f757f3fSDimitry Andric module_list.FindTypes(nullptr, query, results); 2395f757f3fSDimitry Andric for (const lldb::TypeSP &type_sp : results.GetTypeMap().Types()) { 2400b57cec5SDimitry Andric 2415f757f3fSDimitry Andric CompilerType clang_type(type_sp->GetFullCompilerType()); 2420b57cec5SDimitry Andric 2430b57cec5SDimitry Andric if (!ClangUtil::IsClangType(clang_type)) 2440b57cec5SDimitry Andric continue; 2450b57cec5SDimitry Andric 2460b57cec5SDimitry Andric const TagType *tag_type = 2470b57cec5SDimitry Andric ClangUtil::GetQualType(clang_type)->getAs<TagType>(); 2480b57cec5SDimitry Andric 2490b57cec5SDimitry Andric if (!tag_type) 2500b57cec5SDimitry Andric continue; 2510b57cec5SDimitry Andric 2525ffd83dbSDimitry Andric TagDecl *candidate_tag_decl = const_cast<TagDecl *>(tag_type->getDecl()); 2530b57cec5SDimitry Andric 2545ffd83dbSDimitry Andric if (TypeSystemClang::GetCompleteDecl(&candidate_tag_decl->getASTContext(), 2550b57cec5SDimitry Andric candidate_tag_decl)) 2565ffd83dbSDimitry Andric return candidate_tag_decl; 2570b57cec5SDimitry Andric } 2580b57cec5SDimitry Andric } 2595ffd83dbSDimitry Andric return nullptr; 2605ffd83dbSDimitry Andric } 2615ffd83dbSDimitry Andric 2625ffd83dbSDimitry Andric void ClangASTSource::CompleteType(TagDecl *tag_decl) { 26381ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 2645ffd83dbSDimitry Andric 2655ffd83dbSDimitry Andric if (log) { 2665ffd83dbSDimitry Andric LLDB_LOG(log, 2675ffd83dbSDimitry Andric " CompleteTagDecl on (ASTContext*){0} Completing " 268*0fca6ea1SDimitry Andric "(TagDecl*){1:x} named {2}", 2695ffd83dbSDimitry Andric m_clang_ast_context->getDisplayName(), tag_decl, 2705ffd83dbSDimitry Andric tag_decl->getName()); 2715ffd83dbSDimitry Andric 2725ffd83dbSDimitry Andric LLDB_LOG(log, " CTD Before:\n{0}", ClangUtil::DumpDecl(tag_decl)); 2735ffd83dbSDimitry Andric } 2745ffd83dbSDimitry Andric 2755ffd83dbSDimitry Andric auto iter = m_active_lexical_decls.find(tag_decl); 2765ffd83dbSDimitry Andric if (iter != m_active_lexical_decls.end()) 2775ffd83dbSDimitry Andric return; 2785ffd83dbSDimitry Andric m_active_lexical_decls.insert(tag_decl); 2795ffd83dbSDimitry Andric ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl); 2805ffd83dbSDimitry Andric 2815ffd83dbSDimitry Andric if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) { 2825ffd83dbSDimitry Andric // We couldn't complete the type. Maybe there's a definition somewhere 2835ffd83dbSDimitry Andric // else that can be completed. 2845ffd83dbSDimitry Andric if (TagDecl *alternate = FindCompleteType(tag_decl)) 2855ffd83dbSDimitry Andric m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, alternate); 2860b57cec5SDimitry Andric } 2870b57cec5SDimitry Andric 288480093f4SDimitry Andric LLDB_LOG(log, " [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl)); 2890b57cec5SDimitry Andric } 2900b57cec5SDimitry Andric 2910b57cec5SDimitry Andric void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) { 29281ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 2930b57cec5SDimitry Andric 2945ffd83dbSDimitry Andric LLDB_LOG(log, 295*0fca6ea1SDimitry Andric " [CompleteObjCInterfaceDecl] on (ASTContext*){0:x} '{1}' " 2965ffd83dbSDimitry Andric "Completing an ObjCInterfaceDecl named {1}", 2975ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), 2985ffd83dbSDimitry Andric interface_decl->getName()); 299480093f4SDimitry Andric LLDB_LOG(log, " [COID] Before:\n{0}", 300480093f4SDimitry Andric ClangUtil::DumpDecl(interface_decl)); 3010b57cec5SDimitry Andric 302480093f4SDimitry Andric ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl); 3030b57cec5SDimitry Andric 304480093f4SDimitry Andric if (original.Valid()) { 3050b57cec5SDimitry Andric if (ObjCInterfaceDecl *original_iface_decl = 306480093f4SDimitry Andric dyn_cast<ObjCInterfaceDecl>(original.decl)) { 3070b57cec5SDimitry Andric ObjCInterfaceDecl *complete_iface_decl = 3080b57cec5SDimitry Andric GetCompleteObjCInterface(original_iface_decl); 3090b57cec5SDimitry Andric 3100b57cec5SDimitry Andric if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { 3110b57cec5SDimitry Andric m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl); 3120b57cec5SDimitry Andric } 3130b57cec5SDimitry Andric } 3140b57cec5SDimitry Andric } 3150b57cec5SDimitry Andric 3160b57cec5SDimitry Andric m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl); 3170b57cec5SDimitry Andric 3180b57cec5SDimitry Andric if (interface_decl->getSuperClass() && 3190b57cec5SDimitry Andric interface_decl->getSuperClass() != interface_decl) 3200b57cec5SDimitry Andric CompleteType(interface_decl->getSuperClass()); 3210b57cec5SDimitry Andric 3225ffd83dbSDimitry Andric LLDB_LOG(log, " [COID] After:"); 323480093f4SDimitry Andric LLDB_LOG(log, " [COID] {0}", ClangUtil::DumpDecl(interface_decl)); 3240b57cec5SDimitry Andric } 3250b57cec5SDimitry Andric 3260b57cec5SDimitry Andric clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface( 3270b57cec5SDimitry Andric const clang::ObjCInterfaceDecl *interface_decl) { 3280b57cec5SDimitry Andric lldb::ProcessSP process(m_target->GetProcessSP()); 3290b57cec5SDimitry Andric 3300b57cec5SDimitry Andric if (!process) 3310b57cec5SDimitry Andric return nullptr; 3320b57cec5SDimitry Andric 3330b57cec5SDimitry Andric ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 3340b57cec5SDimitry Andric 3350b57cec5SDimitry Andric if (!language_runtime) 3360b57cec5SDimitry Andric return nullptr; 3370b57cec5SDimitry Andric 3380b57cec5SDimitry Andric ConstString class_name(interface_decl->getNameAsString().c_str()); 3390b57cec5SDimitry Andric 3400b57cec5SDimitry Andric lldb::TypeSP complete_type_sp( 3410b57cec5SDimitry Andric language_runtime->LookupInCompleteClassCache(class_name)); 3420b57cec5SDimitry Andric 3430b57cec5SDimitry Andric if (!complete_type_sp) 3440b57cec5SDimitry Andric return nullptr; 3450b57cec5SDimitry Andric 3460b57cec5SDimitry Andric TypeFromUser complete_type = 3470b57cec5SDimitry Andric TypeFromUser(complete_type_sp->GetFullCompilerType()); 3480b57cec5SDimitry Andric lldb::opaque_compiler_type_t complete_opaque_type = 3490b57cec5SDimitry Andric complete_type.GetOpaqueQualType(); 3500b57cec5SDimitry Andric 3510b57cec5SDimitry Andric if (!complete_opaque_type) 3520b57cec5SDimitry Andric return nullptr; 3530b57cec5SDimitry Andric 3540b57cec5SDimitry Andric const clang::Type *complete_clang_type = 3550b57cec5SDimitry Andric QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr(); 3560b57cec5SDimitry Andric const ObjCInterfaceType *complete_interface_type = 3570b57cec5SDimitry Andric dyn_cast<ObjCInterfaceType>(complete_clang_type); 3580b57cec5SDimitry Andric 3590b57cec5SDimitry Andric if (!complete_interface_type) 3600b57cec5SDimitry Andric return nullptr; 3610b57cec5SDimitry Andric 3620b57cec5SDimitry Andric ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl()); 3630b57cec5SDimitry Andric 3640b57cec5SDimitry Andric return complete_iface_decl; 3650b57cec5SDimitry Andric } 3660b57cec5SDimitry Andric 3670b57cec5SDimitry Andric void ClangASTSource::FindExternalLexicalDecls( 3680b57cec5SDimitry Andric const DeclContext *decl_context, 3690b57cec5SDimitry Andric llvm::function_ref<bool(Decl::Kind)> predicate, 3700b57cec5SDimitry Andric llvm::SmallVectorImpl<Decl *> &decls) { 3710b57cec5SDimitry Andric 37281ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 3730b57cec5SDimitry Andric 3740b57cec5SDimitry Andric const Decl *context_decl = dyn_cast<Decl>(decl_context); 3750b57cec5SDimitry Andric 3760b57cec5SDimitry Andric if (!context_decl) 3770b57cec5SDimitry Andric return; 3780b57cec5SDimitry Andric 3790b57cec5SDimitry Andric auto iter = m_active_lexical_decls.find(context_decl); 3800b57cec5SDimitry Andric if (iter != m_active_lexical_decls.end()) 3810b57cec5SDimitry Andric return; 3820b57cec5SDimitry Andric m_active_lexical_decls.insert(context_decl); 3830b57cec5SDimitry Andric ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl); 3840b57cec5SDimitry Andric 3850b57cec5SDimitry Andric if (log) { 3860b57cec5SDimitry Andric if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl)) 3875ffd83dbSDimitry Andric LLDB_LOG(log, 388*0fca6ea1SDimitry Andric "FindExternalLexicalDecls on (ASTContext*){0:x} '{1}' in " 389bdd1243dSDimitry Andric "'{2}' ({3}Decl*){4}", 3905ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), 3910b57cec5SDimitry Andric context_named_decl->getNameAsString().c_str(), 3920b57cec5SDimitry Andric context_decl->getDeclKindName(), 3930b57cec5SDimitry Andric static_cast<const void *>(context_decl)); 3940b57cec5SDimitry Andric else if (context_decl) 3955ffd83dbSDimitry Andric LLDB_LOG(log, 396*0fca6ea1SDimitry Andric "FindExternalLexicalDecls on (ASTContext*){0:x} '{1}' in " 3975ffd83dbSDimitry Andric "({2}Decl*){3}", 3985ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), 3990b57cec5SDimitry Andric context_decl->getDeclKindName(), 4000b57cec5SDimitry Andric static_cast<const void *>(context_decl)); 4010b57cec5SDimitry Andric else 4025ffd83dbSDimitry Andric LLDB_LOG(log, 403*0fca6ea1SDimitry Andric "FindExternalLexicalDecls on (ASTContext*){0:x} '{1}' in a " 4045ffd83dbSDimitry Andric "NULL context", 4055ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName()); 4060b57cec5SDimitry Andric } 4070b57cec5SDimitry Andric 408480093f4SDimitry Andric ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(context_decl); 4090b57cec5SDimitry Andric 410480093f4SDimitry Andric if (!original.Valid()) 4110b57cec5SDimitry Andric return; 4120b57cec5SDimitry Andric 413*0fca6ea1SDimitry Andric LLDB_LOG(log, " FELD Original decl (ASTContext*){0:x} (Decl*){1:x}:\n{2}", 4145ffd83dbSDimitry Andric static_cast<void *>(original.ctx), 4155ffd83dbSDimitry Andric static_cast<void *>(original.decl), 4165ffd83dbSDimitry Andric ClangUtil::DumpDecl(original.decl)); 4170b57cec5SDimitry Andric 4180b57cec5SDimitry Andric if (ObjCInterfaceDecl *original_iface_decl = 419480093f4SDimitry Andric dyn_cast<ObjCInterfaceDecl>(original.decl)) { 4200b57cec5SDimitry Andric ObjCInterfaceDecl *complete_iface_decl = 4210b57cec5SDimitry Andric GetCompleteObjCInterface(original_iface_decl); 4220b57cec5SDimitry Andric 4230b57cec5SDimitry Andric if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { 424480093f4SDimitry Andric original.decl = complete_iface_decl; 425480093f4SDimitry Andric original.ctx = &complete_iface_decl->getASTContext(); 4260b57cec5SDimitry Andric 4270b57cec5SDimitry Andric m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl); 4280b57cec5SDimitry Andric } 4290b57cec5SDimitry Andric } 4300b57cec5SDimitry Andric 431480093f4SDimitry Andric if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original.decl)) { 432480093f4SDimitry Andric ExternalASTSource *external_source = original.ctx->getExternalSource(); 4330b57cec5SDimitry Andric 4340b57cec5SDimitry Andric if (external_source) 4350b57cec5SDimitry Andric external_source->CompleteType(original_tag_decl); 4360b57cec5SDimitry Andric } 4370b57cec5SDimitry Andric 4380b57cec5SDimitry Andric const DeclContext *original_decl_context = 439480093f4SDimitry Andric dyn_cast<DeclContext>(original.decl); 4400b57cec5SDimitry Andric 4410b57cec5SDimitry Andric if (!original_decl_context) 4420b57cec5SDimitry Andric return; 4430b57cec5SDimitry Andric 4440b57cec5SDimitry Andric // Indicates whether we skipped any Decls of the original DeclContext. 4450b57cec5SDimitry Andric bool SkippedDecls = false; 4465ffd83dbSDimitry Andric for (Decl *decl : original_decl_context->decls()) { 4470b57cec5SDimitry Andric // The predicate function returns true if the passed declaration kind is 4480b57cec5SDimitry Andric // the one we are looking for. 4490b57cec5SDimitry Andric // See clang::ExternalASTSource::FindExternalLexicalDecls() 4500b57cec5SDimitry Andric if (predicate(decl->getKind())) { 4510b57cec5SDimitry Andric if (log) { 452480093f4SDimitry Andric std::string ast_dump = ClangUtil::DumpDecl(decl); 4530b57cec5SDimitry Andric if (const NamedDecl *context_named_decl = 4540b57cec5SDimitry Andric dyn_cast<NamedDecl>(context_decl)) 4555ffd83dbSDimitry Andric LLDB_LOG(log, " FELD Adding [to {0}Decl {1}] lexical {2}Decl {3}", 4565ffd83dbSDimitry Andric context_named_decl->getDeclKindName(), 4575ffd83dbSDimitry Andric context_named_decl->getName(), decl->getDeclKindName(), 4585ffd83dbSDimitry Andric ast_dump); 4590b57cec5SDimitry Andric else 4605ffd83dbSDimitry Andric LLDB_LOG(log, " FELD Adding lexical {0}Decl {1}", 4615ffd83dbSDimitry Andric decl->getDeclKindName(), ast_dump); 4620b57cec5SDimitry Andric } 4630b57cec5SDimitry Andric 464349cc55cSDimitry Andric Decl *copied_decl = CopyDecl(decl); 465349cc55cSDimitry Andric 466349cc55cSDimitry Andric if (!copied_decl) 467349cc55cSDimitry Andric continue; 4680b57cec5SDimitry Andric 469e8d8bef9SDimitry Andric // FIXME: We should add the copied decl to the 'decls' list. This would 470e8d8bef9SDimitry Andric // add the copied Decl into the DeclContext and make sure that we 471e8d8bef9SDimitry Andric // correctly propagate that we added some Decls back to Clang. 472e8d8bef9SDimitry Andric // By leaving 'decls' empty we incorrectly return false from 473e8d8bef9SDimitry Andric // DeclContext::LoadLexicalDeclsFromExternalStorage which might cause 474e8d8bef9SDimitry Andric // lookup issues later on. 475e8d8bef9SDimitry Andric // We can't just add them for now as the ASTImporter already added the 476e8d8bef9SDimitry Andric // decl into the DeclContext and this would add it twice. 477349cc55cSDimitry Andric 478349cc55cSDimitry Andric if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) { 479349cc55cSDimitry Andric QualType copied_field_type = copied_field->getType(); 480349cc55cSDimitry Andric 481349cc55cSDimitry Andric m_ast_importer_sp->RequireCompleteType(copied_field_type); 482349cc55cSDimitry Andric } 4830b57cec5SDimitry Andric } else { 4840b57cec5SDimitry Andric SkippedDecls = true; 4850b57cec5SDimitry Andric } 4860b57cec5SDimitry Andric } 4870b57cec5SDimitry Andric 4880b57cec5SDimitry Andric // CopyDecl may build a lookup table which may set up ExternalLexicalStorage 4890b57cec5SDimitry Andric // to false. However, since we skipped some of the external Decls we must 4900b57cec5SDimitry Andric // set it back! 4910b57cec5SDimitry Andric if (SkippedDecls) { 4920b57cec5SDimitry Andric decl_context->setHasExternalLexicalStorage(true); 4930b57cec5SDimitry Andric // This sets HasLazyExternalLexicalLookups to true. By setting this bit we 4940b57cec5SDimitry Andric // ensure that the lookup table is rebuilt, which means the external source 4950b57cec5SDimitry Andric // is consulted again when a clang::DeclContext::lookup is called. 4960b57cec5SDimitry Andric const_cast<DeclContext *>(decl_context)->setMustBuildLookupTable(); 4970b57cec5SDimitry Andric } 4980b57cec5SDimitry Andric } 4990b57cec5SDimitry Andric 5000b57cec5SDimitry Andric void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) { 5010b57cec5SDimitry Andric assert(m_ast_context); 5020b57cec5SDimitry Andric 5030b57cec5SDimitry Andric const ConstString name(context.m_decl_name.getAsString().c_str()); 5040b57cec5SDimitry Andric 50581ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 5060b57cec5SDimitry Andric 5070b57cec5SDimitry Andric if (log) { 5080b57cec5SDimitry Andric if (!context.m_decl_context) 5095ffd83dbSDimitry Andric LLDB_LOG(log, 5105ffd83dbSDimitry Andric "ClangASTSource::FindExternalVisibleDecls on " 511*0fca6ea1SDimitry Andric "(ASTContext*){0:x} '{1}' for '{2}' in a NULL DeclContext", 5125ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), name); 5130b57cec5SDimitry Andric else if (const NamedDecl *context_named_decl = 5140b57cec5SDimitry Andric dyn_cast<NamedDecl>(context.m_decl_context)) 5155ffd83dbSDimitry Andric LLDB_LOG(log, 5165ffd83dbSDimitry Andric "ClangASTSource::FindExternalVisibleDecls on " 517*0fca6ea1SDimitry Andric "(ASTContext*){0:x} '{1}' for '{2}' in '{3}'", 5185ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), name, 5195ffd83dbSDimitry Andric context_named_decl->getName()); 5200b57cec5SDimitry Andric else 5215ffd83dbSDimitry Andric LLDB_LOG(log, 5225ffd83dbSDimitry Andric "ClangASTSource::FindExternalVisibleDecls on " 523*0fca6ea1SDimitry Andric "(ASTContext*){0:x} '{1}' for '{2}' in a '{3}'", 5245ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), name, 5255ffd83dbSDimitry Andric context.m_decl_context->getDeclKindName()); 5260b57cec5SDimitry Andric } 5270b57cec5SDimitry Andric 5285ffd83dbSDimitry Andric if (isa<NamespaceDecl>(context.m_decl_context)) { 5295ffd83dbSDimitry Andric LookupInNamespace(context); 530480093f4SDimitry Andric } else if (isa<ObjCInterfaceDecl>(context.m_decl_context)) { 5310b57cec5SDimitry Andric FindObjCPropertyAndIvarDecls(context); 5320b57cec5SDimitry Andric } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) { 5330b57cec5SDimitry Andric // we shouldn't be getting FindExternalVisibleDecls calls for these 5340b57cec5SDimitry Andric return; 5350b57cec5SDimitry Andric } else { 5360b57cec5SDimitry Andric CompilerDeclContext namespace_decl; 5370b57cec5SDimitry Andric 5385ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Searching the root namespace"); 5390b57cec5SDimitry Andric 5405ffd83dbSDimitry Andric FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl); 5410b57cec5SDimitry Andric } 5420b57cec5SDimitry Andric 5430b57cec5SDimitry Andric if (!context.m_namespace_map->empty()) { 5440b57cec5SDimitry Andric if (log && log->GetVerbose()) 545*0fca6ea1SDimitry Andric LLDB_LOG(log, " CAS::FEVD Registering namespace map {0:x} ({1} entries)", 5465ffd83dbSDimitry Andric context.m_namespace_map.get(), context.m_namespace_map->size()); 5470b57cec5SDimitry Andric 5480b57cec5SDimitry Andric NamespaceDecl *clang_namespace_decl = 5490b57cec5SDimitry Andric AddNamespace(context, context.m_namespace_map); 5500b57cec5SDimitry Andric 5510b57cec5SDimitry Andric if (clang_namespace_decl) 5520b57cec5SDimitry Andric clang_namespace_decl->setHasExternalVisibleStorage(); 5530b57cec5SDimitry Andric } 5540b57cec5SDimitry Andric } 5550b57cec5SDimitry Andric 5560b57cec5SDimitry Andric clang::Sema *ClangASTSource::getSema() { 557480093f4SDimitry Andric return m_clang_ast_context->getSema(); 5580b57cec5SDimitry Andric } 5590b57cec5SDimitry Andric 5600b57cec5SDimitry Andric bool ClangASTSource::IgnoreName(const ConstString name, 5610b57cec5SDimitry Andric bool ignore_all_dollar_names) { 5620b57cec5SDimitry Andric static const ConstString id_name("id"); 5630b57cec5SDimitry Andric static const ConstString Class_name("Class"); 5640b57cec5SDimitry Andric 5650b57cec5SDimitry Andric if (m_ast_context->getLangOpts().ObjC) 5660b57cec5SDimitry Andric if (name == id_name || name == Class_name) 5670b57cec5SDimitry Andric return true; 5680b57cec5SDimitry Andric 5690b57cec5SDimitry Andric StringRef name_string_ref = name.GetStringRef(); 5700b57cec5SDimitry Andric 5710b57cec5SDimitry Andric // The ClangASTSource is not responsible for finding $-names. 5720b57cec5SDimitry Andric return name_string_ref.empty() || 5735f757f3fSDimitry Andric (ignore_all_dollar_names && name_string_ref.starts_with("$")) || 5745f757f3fSDimitry Andric name_string_ref.starts_with("_$"); 5750b57cec5SDimitry Andric } 5760b57cec5SDimitry Andric 5770b57cec5SDimitry Andric void ClangASTSource::FindExternalVisibleDecls( 5780b57cec5SDimitry Andric NameSearchContext &context, lldb::ModuleSP module_sp, 5795ffd83dbSDimitry Andric CompilerDeclContext &namespace_decl) { 5800b57cec5SDimitry Andric assert(m_ast_context); 5810b57cec5SDimitry Andric 58281ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 5830b57cec5SDimitry Andric 5840b57cec5SDimitry Andric SymbolContextList sc_list; 5850b57cec5SDimitry Andric 5860b57cec5SDimitry Andric const ConstString name(context.m_decl_name.getAsString().c_str()); 5870b57cec5SDimitry Andric if (IgnoreName(name, true)) 5880b57cec5SDimitry Andric return; 5890b57cec5SDimitry Andric 590480093f4SDimitry Andric if (!m_target) 591480093f4SDimitry Andric return; 592480093f4SDimitry Andric 5935ffd83dbSDimitry Andric FillNamespaceMap(context, module_sp, namespace_decl); 5945ffd83dbSDimitry Andric 5955ffd83dbSDimitry Andric if (context.m_found_type) 5965ffd83dbSDimitry Andric return; 5975ffd83dbSDimitry Andric 5985f757f3fSDimitry Andric lldb::TypeSP type_sp; 5995f757f3fSDimitry Andric TypeResults results; 6005f757f3fSDimitry Andric if (module_sp && namespace_decl) { 6015f757f3fSDimitry Andric // Match the name in the specified decl context. 6025f757f3fSDimitry Andric TypeQuery query(namespace_decl, name, TypeQueryOptions::e_find_one); 6035f757f3fSDimitry Andric module_sp->FindTypes(query, results); 6045f757f3fSDimitry Andric type_sp = results.GetFirstType(); 6055f757f3fSDimitry Andric } else { 6065f757f3fSDimitry Andric // Match the exact name of the type at the root level. 6075f757f3fSDimitry Andric TypeQuery query(name.GetStringRef(), TypeQueryOptions::e_exact_match | 6085f757f3fSDimitry Andric TypeQueryOptions::e_find_one); 6095f757f3fSDimitry Andric m_target->GetImages().FindTypes(nullptr, query, results); 6105f757f3fSDimitry Andric type_sp = results.GetFirstType(); 6115ffd83dbSDimitry Andric } 6125ffd83dbSDimitry Andric 6135f757f3fSDimitry Andric if (type_sp) { 6145ffd83dbSDimitry Andric if (log) { 6155ffd83dbSDimitry Andric const char *name_string = type_sp->GetName().GetCString(); 6165ffd83dbSDimitry Andric 6175ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\": {1}", name, 6185ffd83dbSDimitry Andric (name_string ? name_string : "<anonymous>")); 6195ffd83dbSDimitry Andric } 6205ffd83dbSDimitry Andric 6215ffd83dbSDimitry Andric CompilerType full_type = type_sp->GetFullCompilerType(); 6225ffd83dbSDimitry Andric 6235ffd83dbSDimitry Andric CompilerType copied_clang_type(GuardedCopyType(full_type)); 6245ffd83dbSDimitry Andric 6255ffd83dbSDimitry Andric if (!copied_clang_type) { 6265ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD - Couldn't export a type"); 6275f757f3fSDimitry Andric } else { 6285ffd83dbSDimitry Andric 6295ffd83dbSDimitry Andric context.AddTypeDecl(copied_clang_type); 6305ffd83dbSDimitry Andric 6315ffd83dbSDimitry Andric context.m_found_type = true; 6325ffd83dbSDimitry Andric } 6335ffd83dbSDimitry Andric } 6345ffd83dbSDimitry Andric 6355ffd83dbSDimitry Andric if (!context.m_found_type) { 6365ffd83dbSDimitry Andric // Try the modules next. 6375ffd83dbSDimitry Andric FindDeclInModules(context, name); 6385ffd83dbSDimitry Andric } 6395ffd83dbSDimitry Andric 640*0fca6ea1SDimitry Andric if (!context.m_found_type && m_ast_context->getLangOpts().ObjC) { 6415ffd83dbSDimitry Andric FindDeclInObjCRuntime(context, name); 6425ffd83dbSDimitry Andric } 6435ffd83dbSDimitry Andric } 6445ffd83dbSDimitry Andric 6455ffd83dbSDimitry Andric void ClangASTSource::FillNamespaceMap( 6465ffd83dbSDimitry Andric NameSearchContext &context, lldb::ModuleSP module_sp, 6475ffd83dbSDimitry Andric const CompilerDeclContext &namespace_decl) { 6485ffd83dbSDimitry Andric const ConstString name(context.m_decl_name.getAsString().c_str()); 6495ffd83dbSDimitry Andric if (IgnoreName(name, true)) 6505ffd83dbSDimitry Andric return; 6515ffd83dbSDimitry Andric 65281ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 6535ffd83dbSDimitry Andric 6540b57cec5SDimitry Andric if (module_sp && namespace_decl) { 6550b57cec5SDimitry Andric CompilerDeclContext found_namespace_decl; 6560b57cec5SDimitry Andric 6579dba64beSDimitry Andric if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) { 6585ffd83dbSDimitry Andric found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl); 6590b57cec5SDimitry Andric 6600b57cec5SDimitry Andric if (found_namespace_decl) { 6610b57cec5SDimitry Andric context.m_namespace_map->push_back( 6620b57cec5SDimitry Andric std::pair<lldb::ModuleSP, CompilerDeclContext>( 6630b57cec5SDimitry Andric module_sp, found_namespace_decl)); 6640b57cec5SDimitry Andric 6655ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name, 6665ffd83dbSDimitry Andric module_sp->GetFileSpec().GetFilename()); 6670b57cec5SDimitry Andric } 6680b57cec5SDimitry Andric } 6695ffd83dbSDimitry Andric return; 6705ffd83dbSDimitry Andric } 6715ffd83dbSDimitry Andric 672e8d8bef9SDimitry Andric for (lldb::ModuleSP image : m_target->GetImages().Modules()) { 6730b57cec5SDimitry Andric if (!image) 6740b57cec5SDimitry Andric continue; 6750b57cec5SDimitry Andric 6760b57cec5SDimitry Andric CompilerDeclContext found_namespace_decl; 6770b57cec5SDimitry Andric 6789dba64beSDimitry Andric SymbolFile *symbol_file = image->GetSymbolFile(); 6790b57cec5SDimitry Andric 6809dba64beSDimitry Andric if (!symbol_file) 6810b57cec5SDimitry Andric continue; 6820b57cec5SDimitry Andric 68306c3fb27SDimitry Andric // If namespace_decl is not valid, 'FindNamespace' would look for 68406c3fb27SDimitry Andric // any namespace called 'name' (ignoring parent contexts) and return 68506c3fb27SDimitry Andric // the first one it finds. Thus if we're doing a qualified lookup only 68606c3fb27SDimitry Andric // consider root namespaces. E.g., in an expression ::A::B::Foo, the 68706c3fb27SDimitry Andric // lookup of ::A will result in a qualified lookup. Note, namespace 68806c3fb27SDimitry Andric // disambiguation for function calls are handled separately in 68906c3fb27SDimitry Andric // SearchFunctionsInSymbolContexts. 69006c3fb27SDimitry Andric const bool find_root_namespaces = 69106c3fb27SDimitry Andric context.m_decl_context && 69206c3fb27SDimitry Andric context.m_decl_context->shouldUseQualifiedLookup(); 69306c3fb27SDimitry Andric found_namespace_decl = symbol_file->FindNamespace( 69406c3fb27SDimitry Andric name, namespace_decl, /* only root namespaces */ find_root_namespaces); 6950b57cec5SDimitry Andric 6960b57cec5SDimitry Andric if (found_namespace_decl) { 6970b57cec5SDimitry Andric context.m_namespace_map->push_back( 6985ffd83dbSDimitry Andric std::pair<lldb::ModuleSP, CompilerDeclContext>(image, 6995ffd83dbSDimitry Andric found_namespace_decl)); 7000b57cec5SDimitry Andric 7015ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name, 7025ffd83dbSDimitry Andric image->GetFileSpec().GetFilename()); 7030b57cec5SDimitry Andric } 7040b57cec5SDimitry Andric } 7050b57cec5SDimitry Andric } 7060b57cec5SDimitry Andric 7070b57cec5SDimitry Andric bool ClangASTSource::FindObjCMethodDeclsWithOrigin( 7085ffd83dbSDimitry Andric NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl, 7095ffd83dbSDimitry Andric const char *log_info) { 7100b57cec5SDimitry Andric const DeclarationName &decl_name(context.m_decl_name); 7110b57cec5SDimitry Andric clang::ASTContext *original_ctx = &original_interface_decl->getASTContext(); 7120b57cec5SDimitry Andric 7130b57cec5SDimitry Andric Selector original_selector; 7140b57cec5SDimitry Andric 7150b57cec5SDimitry Andric if (decl_name.isObjCZeroArgSelector()) { 716*0fca6ea1SDimitry Andric const IdentifierInfo *ident = 717*0fca6ea1SDimitry Andric &original_ctx->Idents.get(decl_name.getAsString()); 7180b57cec5SDimitry Andric original_selector = original_ctx->Selectors.getSelector(0, &ident); 7190b57cec5SDimitry Andric } else if (decl_name.isObjCOneArgSelector()) { 7200b57cec5SDimitry Andric const std::string &decl_name_string = decl_name.getAsString(); 7210b57cec5SDimitry Andric std::string decl_name_string_without_colon(decl_name_string.c_str(), 7220b57cec5SDimitry Andric decl_name_string.length() - 1); 723*0fca6ea1SDimitry Andric const IdentifierInfo *ident = 7240b57cec5SDimitry Andric &original_ctx->Idents.get(decl_name_string_without_colon); 7250b57cec5SDimitry Andric original_selector = original_ctx->Selectors.getSelector(1, &ident); 7260b57cec5SDimitry Andric } else { 727*0fca6ea1SDimitry Andric SmallVector<const IdentifierInfo *, 4> idents; 7280b57cec5SDimitry Andric 7290b57cec5SDimitry Andric clang::Selector sel = decl_name.getObjCSelector(); 7300b57cec5SDimitry Andric 7310b57cec5SDimitry Andric unsigned num_args = sel.getNumArgs(); 7320b57cec5SDimitry Andric 7330b57cec5SDimitry Andric for (unsigned i = 0; i != num_args; ++i) { 7340b57cec5SDimitry Andric idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i))); 7350b57cec5SDimitry Andric } 7360b57cec5SDimitry Andric 7370b57cec5SDimitry Andric original_selector = 7380b57cec5SDimitry Andric original_ctx->Selectors.getSelector(num_args, idents.data()); 7390b57cec5SDimitry Andric } 7400b57cec5SDimitry Andric 7410b57cec5SDimitry Andric DeclarationName original_decl_name(original_selector); 7420b57cec5SDimitry Andric 7430b57cec5SDimitry Andric llvm::SmallVector<NamedDecl *, 1> methods; 7440b57cec5SDimitry Andric 7455ffd83dbSDimitry Andric TypeSystemClang::GetCompleteDecl(original_ctx, original_interface_decl); 7460b57cec5SDimitry Andric 7470b57cec5SDimitry Andric if (ObjCMethodDecl *instance_method_decl = 7480b57cec5SDimitry Andric original_interface_decl->lookupInstanceMethod(original_selector)) { 7490b57cec5SDimitry Andric methods.push_back(instance_method_decl); 7500b57cec5SDimitry Andric } else if (ObjCMethodDecl *class_method_decl = 7510b57cec5SDimitry Andric original_interface_decl->lookupClassMethod( 7520b57cec5SDimitry Andric original_selector)) { 7530b57cec5SDimitry Andric methods.push_back(class_method_decl); 7540b57cec5SDimitry Andric } 7550b57cec5SDimitry Andric 7560b57cec5SDimitry Andric if (methods.empty()) { 7570b57cec5SDimitry Andric return false; 7580b57cec5SDimitry Andric } 7590b57cec5SDimitry Andric 7600b57cec5SDimitry Andric for (NamedDecl *named_decl : methods) { 7610b57cec5SDimitry Andric if (!named_decl) 7620b57cec5SDimitry Andric continue; 7630b57cec5SDimitry Andric 7640b57cec5SDimitry Andric ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(named_decl); 7650b57cec5SDimitry Andric 7660b57cec5SDimitry Andric if (!result_method) 7670b57cec5SDimitry Andric continue; 7680b57cec5SDimitry Andric 7690b57cec5SDimitry Andric Decl *copied_decl = CopyDecl(result_method); 7700b57cec5SDimitry Andric 7710b57cec5SDimitry Andric if (!copied_decl) 7720b57cec5SDimitry Andric continue; 7730b57cec5SDimitry Andric 7740b57cec5SDimitry Andric ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl); 7750b57cec5SDimitry Andric 7760b57cec5SDimitry Andric if (!copied_method_decl) 7770b57cec5SDimitry Andric continue; 7780b57cec5SDimitry Andric 77981ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 7800b57cec5SDimitry Andric 7815ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FOMD found ({0}) {1}", log_info, 782480093f4SDimitry Andric ClangUtil::DumpDecl(copied_method_decl)); 7830b57cec5SDimitry Andric 7840b57cec5SDimitry Andric context.AddNamedDecl(copied_method_decl); 7850b57cec5SDimitry Andric } 7860b57cec5SDimitry Andric 7870b57cec5SDimitry Andric return true; 7880b57cec5SDimitry Andric } 7890b57cec5SDimitry Andric 7905ffd83dbSDimitry Andric void ClangASTSource::FindDeclInModules(NameSearchContext &context, 7915ffd83dbSDimitry Andric ConstString name) { 79281ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 7930b57cec5SDimitry Andric 794fe6060f1SDimitry Andric std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor = 795fe6060f1SDimitry Andric GetClangModulesDeclVendor(); 7965ffd83dbSDimitry Andric if (!modules_decl_vendor) 7975ffd83dbSDimitry Andric return; 7985ffd83dbSDimitry Andric 7995ffd83dbSDimitry Andric bool append = false; 8005ffd83dbSDimitry Andric uint32_t max_matches = 1; 8015ffd83dbSDimitry Andric std::vector<clang::NamedDecl *> decls; 8025ffd83dbSDimitry Andric 8035ffd83dbSDimitry Andric if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls)) 8045ffd83dbSDimitry Andric return; 8055ffd83dbSDimitry Andric 8065ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Matching entity found for \"{0}\" in the modules", 8075ffd83dbSDimitry Andric name); 8085ffd83dbSDimitry Andric 8095ffd83dbSDimitry Andric clang::NamedDecl *const decl_from_modules = decls[0]; 8105ffd83dbSDimitry Andric 8115ffd83dbSDimitry Andric if (llvm::isa<clang::TypeDecl>(decl_from_modules) || 8125ffd83dbSDimitry Andric llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) || 8135ffd83dbSDimitry Andric llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) { 8145ffd83dbSDimitry Andric clang::Decl *copied_decl = CopyDecl(decl_from_modules); 8155ffd83dbSDimitry Andric clang::NamedDecl *copied_named_decl = 8165ffd83dbSDimitry Andric copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr; 8175ffd83dbSDimitry Andric 8185ffd83dbSDimitry Andric if (!copied_named_decl) { 8195ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the modules"); 8205ffd83dbSDimitry Andric 8215ffd83dbSDimitry Andric return; 8225ffd83dbSDimitry Andric } 8235ffd83dbSDimitry Andric 8245ffd83dbSDimitry Andric context.AddNamedDecl(copied_named_decl); 8255ffd83dbSDimitry Andric 8265ffd83dbSDimitry Andric context.m_found_type = true; 8275ffd83dbSDimitry Andric } 8285ffd83dbSDimitry Andric } 8295ffd83dbSDimitry Andric 8305ffd83dbSDimitry Andric void ClangASTSource::FindDeclInObjCRuntime(NameSearchContext &context, 8315ffd83dbSDimitry Andric ConstString name) { 83281ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 8335ffd83dbSDimitry Andric 8345ffd83dbSDimitry Andric lldb::ProcessSP process(m_target->GetProcessSP()); 8355ffd83dbSDimitry Andric 8365ffd83dbSDimitry Andric if (!process) 8375ffd83dbSDimitry Andric return; 8385ffd83dbSDimitry Andric 8395ffd83dbSDimitry Andric ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 8405ffd83dbSDimitry Andric 8415ffd83dbSDimitry Andric if (!language_runtime) 8425ffd83dbSDimitry Andric return; 8435ffd83dbSDimitry Andric 8445ffd83dbSDimitry Andric DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 8455ffd83dbSDimitry Andric 8465ffd83dbSDimitry Andric if (!decl_vendor) 8475ffd83dbSDimitry Andric return; 8485ffd83dbSDimitry Andric 8495ffd83dbSDimitry Andric bool append = false; 8505ffd83dbSDimitry Andric uint32_t max_matches = 1; 8515ffd83dbSDimitry Andric std::vector<clang::NamedDecl *> decls; 8525ffd83dbSDimitry Andric 8535ffd83dbSDimitry Andric auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor); 8545ffd83dbSDimitry Andric if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls)) 8555ffd83dbSDimitry Andric return; 8565ffd83dbSDimitry Andric 8575ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\" in the runtime", 8585ffd83dbSDimitry Andric name); 8595ffd83dbSDimitry Andric 8605ffd83dbSDimitry Andric clang::Decl *copied_decl = CopyDecl(decls[0]); 8615ffd83dbSDimitry Andric clang::NamedDecl *copied_named_decl = 8625ffd83dbSDimitry Andric copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr; 8635ffd83dbSDimitry Andric 8645ffd83dbSDimitry Andric if (!copied_named_decl) { 8655ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the runtime"); 8665ffd83dbSDimitry Andric 8675ffd83dbSDimitry Andric return; 8685ffd83dbSDimitry Andric } 8695ffd83dbSDimitry Andric 8705ffd83dbSDimitry Andric context.AddNamedDecl(copied_named_decl); 8715ffd83dbSDimitry Andric } 8725ffd83dbSDimitry Andric 8735ffd83dbSDimitry Andric void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) { 87481ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 8750b57cec5SDimitry Andric 8760b57cec5SDimitry Andric const DeclarationName &decl_name(context.m_decl_name); 8770b57cec5SDimitry Andric const DeclContext *decl_ctx(context.m_decl_context); 8780b57cec5SDimitry Andric 8790b57cec5SDimitry Andric const ObjCInterfaceDecl *interface_decl = 8800b57cec5SDimitry Andric dyn_cast<ObjCInterfaceDecl>(decl_ctx); 8810b57cec5SDimitry Andric 8820b57cec5SDimitry Andric if (!interface_decl) 8830b57cec5SDimitry Andric return; 8840b57cec5SDimitry Andric 8850b57cec5SDimitry Andric do { 886480093f4SDimitry Andric ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl); 8870b57cec5SDimitry Andric 888480093f4SDimitry Andric if (!original.Valid()) 8890b57cec5SDimitry Andric break; 8900b57cec5SDimitry Andric 8910b57cec5SDimitry Andric ObjCInterfaceDecl *original_interface_decl = 892480093f4SDimitry Andric dyn_cast<ObjCInterfaceDecl>(original.decl); 8930b57cec5SDimitry Andric 8945ffd83dbSDimitry Andric if (FindObjCMethodDeclsWithOrigin(context, original_interface_decl, 8955ffd83dbSDimitry Andric "at origin")) 8960b57cec5SDimitry Andric return; // found it, no need to look any further 8970b57cec5SDimitry Andric } while (false); 8980b57cec5SDimitry Andric 8990b57cec5SDimitry Andric StreamString ss; 9000b57cec5SDimitry Andric 9010b57cec5SDimitry Andric if (decl_name.isObjCZeroArgSelector()) { 9020b57cec5SDimitry Andric ss.Printf("%s", decl_name.getAsString().c_str()); 9030b57cec5SDimitry Andric } else if (decl_name.isObjCOneArgSelector()) { 9040b57cec5SDimitry Andric ss.Printf("%s", decl_name.getAsString().c_str()); 9050b57cec5SDimitry Andric } else { 9060b57cec5SDimitry Andric clang::Selector sel = decl_name.getObjCSelector(); 9070b57cec5SDimitry Andric 9080b57cec5SDimitry Andric for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) { 9090b57cec5SDimitry Andric llvm::StringRef r = sel.getNameForSlot(i); 9100b57cec5SDimitry Andric ss.Printf("%s:", r.str().c_str()); 9110b57cec5SDimitry Andric } 9120b57cec5SDimitry Andric } 9130b57cec5SDimitry Andric ss.Flush(); 9140b57cec5SDimitry Andric 9150b57cec5SDimitry Andric if (ss.GetString().contains("$__lldb")) 9160b57cec5SDimitry Andric return; // we don't need any results 9170b57cec5SDimitry Andric 9180b57cec5SDimitry Andric ConstString selector_name(ss.GetString()); 9190b57cec5SDimitry Andric 9205ffd83dbSDimitry Andric LLDB_LOG(log, 921*0fca6ea1SDimitry Andric "ClangASTSource::FindObjCMethodDecls on (ASTContext*){0:x} '{1}' " 9225ffd83dbSDimitry Andric "for selector [{2} {3}]", 9235ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), 9245ffd83dbSDimitry Andric interface_decl->getName(), selector_name); 9250b57cec5SDimitry Andric SymbolContextList sc_list; 9260b57cec5SDimitry Andric 927349cc55cSDimitry Andric ModuleFunctionSearchOptions function_options; 928349cc55cSDimitry Andric function_options.include_symbols = false; 929349cc55cSDimitry Andric function_options.include_inlines = false; 9300b57cec5SDimitry Andric 9310b57cec5SDimitry Andric std::string interface_name = interface_decl->getNameAsString(); 9320b57cec5SDimitry Andric 9330b57cec5SDimitry Andric do { 9340b57cec5SDimitry Andric StreamString ms; 9350b57cec5SDimitry Andric ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString()); 9360b57cec5SDimitry Andric ms.Flush(); 9370b57cec5SDimitry Andric ConstString instance_method_name(ms.GetString()); 9380b57cec5SDimitry Andric 9399dba64beSDimitry Andric sc_list.Clear(); 940349cc55cSDimitry Andric m_target->GetImages().FindFunctions(instance_method_name, 941349cc55cSDimitry Andric lldb::eFunctionNameTypeFull, 942349cc55cSDimitry Andric function_options, sc_list); 9430b57cec5SDimitry Andric 9440b57cec5SDimitry Andric if (sc_list.GetSize()) 9450b57cec5SDimitry Andric break; 9460b57cec5SDimitry Andric 9470b57cec5SDimitry Andric ms.Clear(); 9480b57cec5SDimitry Andric ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString()); 9490b57cec5SDimitry Andric ms.Flush(); 9500b57cec5SDimitry Andric ConstString class_method_name(ms.GetString()); 9510b57cec5SDimitry Andric 9529dba64beSDimitry Andric sc_list.Clear(); 953349cc55cSDimitry Andric m_target->GetImages().FindFunctions(class_method_name, 954349cc55cSDimitry Andric lldb::eFunctionNameTypeFull, 955349cc55cSDimitry Andric function_options, sc_list); 9560b57cec5SDimitry Andric 9570b57cec5SDimitry Andric if (sc_list.GetSize()) 9580b57cec5SDimitry Andric break; 9590b57cec5SDimitry Andric 9600b57cec5SDimitry Andric // Fall back and check for methods in categories. If we find methods this 9610b57cec5SDimitry Andric // way, we need to check that they're actually in categories on the desired 9620b57cec5SDimitry Andric // class. 9630b57cec5SDimitry Andric 9640b57cec5SDimitry Andric SymbolContextList candidate_sc_list; 9650b57cec5SDimitry Andric 966349cc55cSDimitry Andric m_target->GetImages().FindFunctions(selector_name, 967349cc55cSDimitry Andric lldb::eFunctionNameTypeSelector, 968349cc55cSDimitry Andric function_options, candidate_sc_list); 9690b57cec5SDimitry Andric 97006c3fb27SDimitry Andric for (const SymbolContext &candidate_sc : candidate_sc_list) { 9710b57cec5SDimitry Andric if (!candidate_sc.function) 9720b57cec5SDimitry Andric continue; 9730b57cec5SDimitry Andric 9740b57cec5SDimitry Andric const char *candidate_name = candidate_sc.function->GetName().AsCString(); 9750b57cec5SDimitry Andric 9760b57cec5SDimitry Andric const char *cursor = candidate_name; 9770b57cec5SDimitry Andric 9780b57cec5SDimitry Andric if (*cursor != '+' && *cursor != '-') 9790b57cec5SDimitry Andric continue; 9800b57cec5SDimitry Andric 9810b57cec5SDimitry Andric ++cursor; 9820b57cec5SDimitry Andric 9830b57cec5SDimitry Andric if (*cursor != '[') 9840b57cec5SDimitry Andric continue; 9850b57cec5SDimitry Andric 9860b57cec5SDimitry Andric ++cursor; 9870b57cec5SDimitry Andric 9880b57cec5SDimitry Andric size_t interface_len = interface_name.length(); 9890b57cec5SDimitry Andric 9900b57cec5SDimitry Andric if (strncmp(cursor, interface_name.c_str(), interface_len)) 9910b57cec5SDimitry Andric continue; 9920b57cec5SDimitry Andric 9930b57cec5SDimitry Andric cursor += interface_len; 9940b57cec5SDimitry Andric 9950b57cec5SDimitry Andric if (*cursor == ' ' || *cursor == '(') 9960b57cec5SDimitry Andric sc_list.Append(candidate_sc); 9970b57cec5SDimitry Andric } 9980b57cec5SDimitry Andric } while (false); 9990b57cec5SDimitry Andric 10000b57cec5SDimitry Andric if (sc_list.GetSize()) { 10010b57cec5SDimitry Andric // We found a good function symbol. Use that. 10020b57cec5SDimitry Andric 100306c3fb27SDimitry Andric for (const SymbolContext &sc : sc_list) { 10040b57cec5SDimitry Andric if (!sc.function) 10050b57cec5SDimitry Andric continue; 10060b57cec5SDimitry Andric 10070b57cec5SDimitry Andric CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext(); 10080b57cec5SDimitry Andric if (!function_decl_ctx) 10090b57cec5SDimitry Andric continue; 10100b57cec5SDimitry Andric 10110b57cec5SDimitry Andric ObjCMethodDecl *method_decl = 10125ffd83dbSDimitry Andric TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx); 10130b57cec5SDimitry Andric 10140b57cec5SDimitry Andric if (!method_decl) 10150b57cec5SDimitry Andric continue; 10160b57cec5SDimitry Andric 10170b57cec5SDimitry Andric ObjCInterfaceDecl *found_interface_decl = 10180b57cec5SDimitry Andric method_decl->getClassInterface(); 10190b57cec5SDimitry Andric 10200b57cec5SDimitry Andric if (!found_interface_decl) 10210b57cec5SDimitry Andric continue; 10220b57cec5SDimitry Andric 10230b57cec5SDimitry Andric if (found_interface_decl->getName() == interface_decl->getName()) { 10240b57cec5SDimitry Andric Decl *copied_decl = CopyDecl(method_decl); 10250b57cec5SDimitry Andric 10260b57cec5SDimitry Andric if (!copied_decl) 10270b57cec5SDimitry Andric continue; 10280b57cec5SDimitry Andric 10290b57cec5SDimitry Andric ObjCMethodDecl *copied_method_decl = 10300b57cec5SDimitry Andric dyn_cast<ObjCMethodDecl>(copied_decl); 10310b57cec5SDimitry Andric 10320b57cec5SDimitry Andric if (!copied_method_decl) 10330b57cec5SDimitry Andric continue; 10340b57cec5SDimitry Andric 10355ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FOMD found (in symbols)\n{0}", 1036480093f4SDimitry Andric ClangUtil::DumpDecl(copied_method_decl)); 10370b57cec5SDimitry Andric 10380b57cec5SDimitry Andric context.AddNamedDecl(copied_method_decl); 10390b57cec5SDimitry Andric } 10400b57cec5SDimitry Andric } 10410b57cec5SDimitry Andric 10420b57cec5SDimitry Andric return; 10430b57cec5SDimitry Andric } 10440b57cec5SDimitry Andric 10450b57cec5SDimitry Andric // Try the debug information. 10460b57cec5SDimitry Andric 10470b57cec5SDimitry Andric do { 10480b57cec5SDimitry Andric ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( 10490b57cec5SDimitry Andric const_cast<ObjCInterfaceDecl *>(interface_decl)); 10500b57cec5SDimitry Andric 10510b57cec5SDimitry Andric if (!complete_interface_decl) 10520b57cec5SDimitry Andric break; 10530b57cec5SDimitry Andric 10540b57cec5SDimitry Andric // We found the complete interface. The runtime never needs to be queried 10550b57cec5SDimitry Andric // in this scenario. 10560b57cec5SDimitry Andric 10570b57cec5SDimitry Andric DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl( 10580b57cec5SDimitry Andric complete_interface_decl); 10590b57cec5SDimitry Andric 10600b57cec5SDimitry Andric if (complete_interface_decl == interface_decl) 10610b57cec5SDimitry Andric break; // already checked this one 10620b57cec5SDimitry Andric 10635ffd83dbSDimitry Andric LLDB_LOG(log, 10645ffd83dbSDimitry Andric "CAS::FOPD trying origin " 1065*0fca6ea1SDimitry Andric "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...", 10665ffd83dbSDimitry Andric complete_interface_decl, &complete_iface_decl->getASTContext()); 10670b57cec5SDimitry Andric 10685ffd83dbSDimitry Andric FindObjCMethodDeclsWithOrigin(context, complete_interface_decl, 10690b57cec5SDimitry Andric "in debug info"); 10700b57cec5SDimitry Andric 10710b57cec5SDimitry Andric return; 10720b57cec5SDimitry Andric } while (false); 10730b57cec5SDimitry Andric 10740b57cec5SDimitry Andric do { 10750b57cec5SDimitry Andric // Check the modules only if the debug information didn't have a complete 10760b57cec5SDimitry Andric // interface. 10770b57cec5SDimitry Andric 1078fe6060f1SDimitry Andric if (std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor = 1079fe6060f1SDimitry Andric GetClangModulesDeclVendor()) { 10800b57cec5SDimitry Andric ConstString interface_name(interface_decl->getNameAsString().c_str()); 10810b57cec5SDimitry Andric bool append = false; 10820b57cec5SDimitry Andric uint32_t max_matches = 1; 10830b57cec5SDimitry Andric std::vector<clang::NamedDecl *> decls; 10840b57cec5SDimitry Andric 10850b57cec5SDimitry Andric if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches, 10860b57cec5SDimitry Andric decls)) 10870b57cec5SDimitry Andric break; 10880b57cec5SDimitry Andric 10890b57cec5SDimitry Andric ObjCInterfaceDecl *interface_decl_from_modules = 10900b57cec5SDimitry Andric dyn_cast<ObjCInterfaceDecl>(decls[0]); 10910b57cec5SDimitry Andric 10920b57cec5SDimitry Andric if (!interface_decl_from_modules) 10930b57cec5SDimitry Andric break; 10940b57cec5SDimitry Andric 10955ffd83dbSDimitry Andric if (FindObjCMethodDeclsWithOrigin(context, interface_decl_from_modules, 10965ffd83dbSDimitry Andric "in modules")) 10970b57cec5SDimitry Andric return; 10980b57cec5SDimitry Andric } 10990b57cec5SDimitry Andric } while (false); 11000b57cec5SDimitry Andric 11010b57cec5SDimitry Andric do { 11020b57cec5SDimitry Andric // Check the runtime only if the debug information didn't have a complete 11030b57cec5SDimitry Andric // interface and the modules don't get us anywhere. 11040b57cec5SDimitry Andric 11050b57cec5SDimitry Andric lldb::ProcessSP process(m_target->GetProcessSP()); 11060b57cec5SDimitry Andric 11070b57cec5SDimitry Andric if (!process) 11080b57cec5SDimitry Andric break; 11090b57cec5SDimitry Andric 11100b57cec5SDimitry Andric ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 11110b57cec5SDimitry Andric 11120b57cec5SDimitry Andric if (!language_runtime) 11130b57cec5SDimitry Andric break; 11140b57cec5SDimitry Andric 11150b57cec5SDimitry Andric DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 11160b57cec5SDimitry Andric 11170b57cec5SDimitry Andric if (!decl_vendor) 11180b57cec5SDimitry Andric break; 11190b57cec5SDimitry Andric 11200b57cec5SDimitry Andric ConstString interface_name(interface_decl->getNameAsString().c_str()); 11210b57cec5SDimitry Andric bool append = false; 11220b57cec5SDimitry Andric uint32_t max_matches = 1; 11230b57cec5SDimitry Andric std::vector<clang::NamedDecl *> decls; 11240b57cec5SDimitry Andric 11259dba64beSDimitry Andric auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor); 11269dba64beSDimitry Andric if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches, 11279dba64beSDimitry Andric decls)) 11280b57cec5SDimitry Andric break; 11290b57cec5SDimitry Andric 11300b57cec5SDimitry Andric ObjCInterfaceDecl *runtime_interface_decl = 11310b57cec5SDimitry Andric dyn_cast<ObjCInterfaceDecl>(decls[0]); 11320b57cec5SDimitry Andric 11330b57cec5SDimitry Andric if (!runtime_interface_decl) 11340b57cec5SDimitry Andric break; 11350b57cec5SDimitry Andric 11365ffd83dbSDimitry Andric FindObjCMethodDeclsWithOrigin(context, runtime_interface_decl, 11370b57cec5SDimitry Andric "in runtime"); 11380b57cec5SDimitry Andric } while (false); 11390b57cec5SDimitry Andric } 11400b57cec5SDimitry Andric 1141*0fca6ea1SDimitry Andric bool ClangASTSource::FindObjCPropertyAndIvarDeclsWithOrigin( 1142*0fca6ea1SDimitry Andric NameSearchContext &context, 11430b57cec5SDimitry Andric DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) { 114481ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 11450b57cec5SDimitry Andric 11460b57cec5SDimitry Andric if (origin_iface_decl.IsInvalid()) 11470b57cec5SDimitry Andric return false; 11480b57cec5SDimitry Andric 11490b57cec5SDimitry Andric std::string name_str = context.m_decl_name.getAsString(); 11500b57cec5SDimitry Andric StringRef name(name_str); 11510b57cec5SDimitry Andric IdentifierInfo &name_identifier( 11520b57cec5SDimitry Andric origin_iface_decl->getASTContext().Idents.get(name)); 11530b57cec5SDimitry Andric 11540b57cec5SDimitry Andric DeclFromUser<ObjCPropertyDecl> origin_property_decl( 11550b57cec5SDimitry Andric origin_iface_decl->FindPropertyDeclaration( 11560b57cec5SDimitry Andric &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance)); 11570b57cec5SDimitry Andric 11580b57cec5SDimitry Andric bool found = false; 11590b57cec5SDimitry Andric 11600b57cec5SDimitry Andric if (origin_property_decl.IsValid()) { 11610b57cec5SDimitry Andric DeclFromParser<ObjCPropertyDecl> parser_property_decl( 1162*0fca6ea1SDimitry Andric origin_property_decl.Import(m_ast_context, *m_ast_importer_sp)); 11630b57cec5SDimitry Andric if (parser_property_decl.IsValid()) { 11645ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FOPD found\n{0}", 1165480093f4SDimitry Andric ClangUtil::DumpDecl(parser_property_decl.decl)); 11660b57cec5SDimitry Andric 11670b57cec5SDimitry Andric context.AddNamedDecl(parser_property_decl.decl); 11680b57cec5SDimitry Andric found = true; 11690b57cec5SDimitry Andric } 11700b57cec5SDimitry Andric } 11710b57cec5SDimitry Andric 11720b57cec5SDimitry Andric DeclFromUser<ObjCIvarDecl> origin_ivar_decl( 11730b57cec5SDimitry Andric origin_iface_decl->getIvarDecl(&name_identifier)); 11740b57cec5SDimitry Andric 11750b57cec5SDimitry Andric if (origin_ivar_decl.IsValid()) { 11760b57cec5SDimitry Andric DeclFromParser<ObjCIvarDecl> parser_ivar_decl( 1177*0fca6ea1SDimitry Andric origin_ivar_decl.Import(m_ast_context, *m_ast_importer_sp)); 11780b57cec5SDimitry Andric if (parser_ivar_decl.IsValid()) { 11795ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FOPD found\n{0}", 1180480093f4SDimitry Andric ClangUtil::DumpDecl(parser_ivar_decl.decl)); 11810b57cec5SDimitry Andric 11820b57cec5SDimitry Andric context.AddNamedDecl(parser_ivar_decl.decl); 11830b57cec5SDimitry Andric found = true; 11840b57cec5SDimitry Andric } 11850b57cec5SDimitry Andric } 11860b57cec5SDimitry Andric 11870b57cec5SDimitry Andric return found; 11880b57cec5SDimitry Andric } 11890b57cec5SDimitry Andric 11900b57cec5SDimitry Andric void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) { 119181ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 11920b57cec5SDimitry Andric 11930b57cec5SDimitry Andric DeclFromParser<const ObjCInterfaceDecl> parser_iface_decl( 11940b57cec5SDimitry Andric cast<ObjCInterfaceDecl>(context.m_decl_context)); 11950b57cec5SDimitry Andric DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl( 1196*0fca6ea1SDimitry Andric parser_iface_decl.GetOrigin(*m_ast_importer_sp)); 11970b57cec5SDimitry Andric 11980b57cec5SDimitry Andric ConstString class_name(parser_iface_decl->getNameAsString().c_str()); 11990b57cec5SDimitry Andric 12005ffd83dbSDimitry Andric LLDB_LOG(log, 12015ffd83dbSDimitry Andric "ClangASTSource::FindObjCPropertyAndIvarDecls on " 1202*0fca6ea1SDimitry Andric "(ASTContext*){0:x} '{1}' for '{2}.{3}'", 12035ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), 12045ffd83dbSDimitry Andric parser_iface_decl->getName(), context.m_decl_name.getAsString()); 12050b57cec5SDimitry Andric 1206*0fca6ea1SDimitry Andric if (FindObjCPropertyAndIvarDeclsWithOrigin(context, origin_iface_decl)) 12070b57cec5SDimitry Andric return; 12080b57cec5SDimitry Andric 12095ffd83dbSDimitry Andric LLDB_LOG(log, 12105ffd83dbSDimitry Andric "CAS::FOPD couldn't find the property on origin " 1211*0fca6ea1SDimitry Andric "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}, searching " 12120b57cec5SDimitry Andric "elsewhere...", 12135ffd83dbSDimitry Andric origin_iface_decl.decl, &origin_iface_decl->getASTContext()); 12140b57cec5SDimitry Andric 12150b57cec5SDimitry Andric SymbolContext null_sc; 12160b57cec5SDimitry Andric TypeList type_list; 12170b57cec5SDimitry Andric 12180b57cec5SDimitry Andric do { 12190b57cec5SDimitry Andric ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( 12200b57cec5SDimitry Andric const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl)); 12210b57cec5SDimitry Andric 12220b57cec5SDimitry Andric if (!complete_interface_decl) 12230b57cec5SDimitry Andric break; 12240b57cec5SDimitry Andric 12250b57cec5SDimitry Andric // We found the complete interface. The runtime never needs to be queried 12260b57cec5SDimitry Andric // in this scenario. 12270b57cec5SDimitry Andric 12280b57cec5SDimitry Andric DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl( 12290b57cec5SDimitry Andric complete_interface_decl); 12300b57cec5SDimitry Andric 12310b57cec5SDimitry Andric if (complete_iface_decl.decl == origin_iface_decl.decl) 12320b57cec5SDimitry Andric break; // already checked this one 12330b57cec5SDimitry Andric 12345ffd83dbSDimitry Andric LLDB_LOG(log, 12355ffd83dbSDimitry Andric "CAS::FOPD trying origin " 1236*0fca6ea1SDimitry Andric "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...", 12375ffd83dbSDimitry Andric complete_iface_decl.decl, &complete_iface_decl->getASTContext()); 12380b57cec5SDimitry Andric 1239*0fca6ea1SDimitry Andric FindObjCPropertyAndIvarDeclsWithOrigin(context, complete_iface_decl); 12400b57cec5SDimitry Andric 12410b57cec5SDimitry Andric return; 12420b57cec5SDimitry Andric } while (false); 12430b57cec5SDimitry Andric 12440b57cec5SDimitry Andric do { 12450b57cec5SDimitry Andric // Check the modules only if the debug information didn't have a complete 12460b57cec5SDimitry Andric // interface. 12470b57cec5SDimitry Andric 1248fe6060f1SDimitry Andric std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor = 1249fe6060f1SDimitry Andric GetClangModulesDeclVendor(); 12500b57cec5SDimitry Andric 12510b57cec5SDimitry Andric if (!modules_decl_vendor) 12520b57cec5SDimitry Andric break; 12530b57cec5SDimitry Andric 12540b57cec5SDimitry Andric bool append = false; 12550b57cec5SDimitry Andric uint32_t max_matches = 1; 12560b57cec5SDimitry Andric std::vector<clang::NamedDecl *> decls; 12570b57cec5SDimitry Andric 12580b57cec5SDimitry Andric if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls)) 12590b57cec5SDimitry Andric break; 12600b57cec5SDimitry Andric 12610b57cec5SDimitry Andric DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules( 12620b57cec5SDimitry Andric dyn_cast<ObjCInterfaceDecl>(decls[0])); 12630b57cec5SDimitry Andric 12640b57cec5SDimitry Andric if (!interface_decl_from_modules.IsValid()) 12650b57cec5SDimitry Andric break; 12660b57cec5SDimitry Andric 12675ffd83dbSDimitry Andric LLDB_LOG(log, 1268*0fca6ea1SDimitry Andric "CAS::FOPD[{0:x}] trying module " 1269*0fca6ea1SDimitry Andric "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...", 12705ffd83dbSDimitry Andric interface_decl_from_modules.decl, 12715ffd83dbSDimitry Andric &interface_decl_from_modules->getASTContext()); 12720b57cec5SDimitry Andric 1273*0fca6ea1SDimitry Andric if (FindObjCPropertyAndIvarDeclsWithOrigin(context, 12740b57cec5SDimitry Andric interface_decl_from_modules)) 12750b57cec5SDimitry Andric return; 12760b57cec5SDimitry Andric } while (false); 12770b57cec5SDimitry Andric 12780b57cec5SDimitry Andric do { 12790b57cec5SDimitry Andric // Check the runtime only if the debug information didn't have a complete 12800b57cec5SDimitry Andric // interface and nothing was in the modules. 12810b57cec5SDimitry Andric 12820b57cec5SDimitry Andric lldb::ProcessSP process(m_target->GetProcessSP()); 12830b57cec5SDimitry Andric 12840b57cec5SDimitry Andric if (!process) 12850b57cec5SDimitry Andric return; 12860b57cec5SDimitry Andric 12870b57cec5SDimitry Andric ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 12880b57cec5SDimitry Andric 12890b57cec5SDimitry Andric if (!language_runtime) 12900b57cec5SDimitry Andric return; 12910b57cec5SDimitry Andric 12920b57cec5SDimitry Andric DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 12930b57cec5SDimitry Andric 12940b57cec5SDimitry Andric if (!decl_vendor) 12950b57cec5SDimitry Andric break; 12960b57cec5SDimitry Andric 12970b57cec5SDimitry Andric bool append = false; 12980b57cec5SDimitry Andric uint32_t max_matches = 1; 12990b57cec5SDimitry Andric std::vector<clang::NamedDecl *> decls; 13000b57cec5SDimitry Andric 13019dba64beSDimitry Andric auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor); 13029dba64beSDimitry Andric if (!clang_decl_vendor->FindDecls(class_name, append, max_matches, decls)) 13030b57cec5SDimitry Andric break; 13040b57cec5SDimitry Andric 13050b57cec5SDimitry Andric DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime( 13060b57cec5SDimitry Andric dyn_cast<ObjCInterfaceDecl>(decls[0])); 13070b57cec5SDimitry Andric 13080b57cec5SDimitry Andric if (!interface_decl_from_runtime.IsValid()) 13090b57cec5SDimitry Andric break; 13100b57cec5SDimitry Andric 13115ffd83dbSDimitry Andric LLDB_LOG(log, 1312*0fca6ea1SDimitry Andric "CAS::FOPD[{0:x}] trying runtime " 1313*0fca6ea1SDimitry Andric "(ObjCInterfaceDecl*){0:x}/(ASTContext*){1:x}...", 13145ffd83dbSDimitry Andric interface_decl_from_runtime.decl, 13155ffd83dbSDimitry Andric &interface_decl_from_runtime->getASTContext()); 13160b57cec5SDimitry Andric 1317*0fca6ea1SDimitry Andric if (FindObjCPropertyAndIvarDeclsWithOrigin(context, 13185ffd83dbSDimitry Andric interface_decl_from_runtime)) 13190b57cec5SDimitry Andric return; 13200b57cec5SDimitry Andric } while (false); 13210b57cec5SDimitry Andric } 13220b57cec5SDimitry Andric 13235ffd83dbSDimitry Andric void ClangASTSource::LookupInNamespace(NameSearchContext &context) { 13245ffd83dbSDimitry Andric const NamespaceDecl *namespace_context = 13255ffd83dbSDimitry Andric dyn_cast<NamespaceDecl>(context.m_decl_context); 13265ffd83dbSDimitry Andric 132781ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 13285ffd83dbSDimitry Andric 13295ffd83dbSDimitry Andric ClangASTImporter::NamespaceMapSP namespace_map = 13305ffd83dbSDimitry Andric m_ast_importer_sp->GetNamespaceMap(namespace_context); 13315ffd83dbSDimitry Andric 1332*0fca6ea1SDimitry Andric LLDB_LOGV(log, " CAS::FEVD Inspecting namespace map {0:x} ({1} entries)", 13335ffd83dbSDimitry Andric namespace_map.get(), namespace_map->size()); 13345ffd83dbSDimitry Andric 13355ffd83dbSDimitry Andric if (!namespace_map) 13365ffd83dbSDimitry Andric return; 13375ffd83dbSDimitry Andric 13385ffd83dbSDimitry Andric for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), 13395ffd83dbSDimitry Andric e = namespace_map->end(); 13405ffd83dbSDimitry Andric i != e; ++i) { 13415ffd83dbSDimitry Andric LLDB_LOG(log, " CAS::FEVD Searching namespace {0} in module {1}", 13425ffd83dbSDimitry Andric i->second.GetName(), i->first->GetFileSpec().GetFilename()); 13435ffd83dbSDimitry Andric 13445ffd83dbSDimitry Andric FindExternalVisibleDecls(context, i->first, i->second); 13455ffd83dbSDimitry Andric } 13465ffd83dbSDimitry Andric } 13475ffd83dbSDimitry Andric 1348*0fca6ea1SDimitry Andric bool ClangASTSource::layoutRecordType( 1349*0fca6ea1SDimitry Andric const RecordDecl *record, uint64_t &size, uint64_t &alignment, 1350*0fca6ea1SDimitry Andric llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, 1351*0fca6ea1SDimitry Andric llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> 1352*0fca6ea1SDimitry Andric &base_offsets, 1353*0fca6ea1SDimitry Andric llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> 1354*0fca6ea1SDimitry Andric &virtual_base_offsets) { 1355*0fca6ea1SDimitry Andric return m_ast_importer_sp->importRecordLayoutFromOrigin( 1356*0fca6ea1SDimitry Andric record, size, alignment, field_offsets, base_offsets, 1357*0fca6ea1SDimitry Andric virtual_base_offsets); 13580b57cec5SDimitry Andric } 13590b57cec5SDimitry Andric 13600b57cec5SDimitry Andric void ClangASTSource::CompleteNamespaceMap( 13610b57cec5SDimitry Andric ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name, 13620b57cec5SDimitry Andric ClangASTImporter::NamespaceMapSP &parent_map) const { 13630b57cec5SDimitry Andric 136481ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Expressions); 13650b57cec5SDimitry Andric 13660b57cec5SDimitry Andric if (log) { 13670b57cec5SDimitry Andric if (parent_map && parent_map->size()) 13685ffd83dbSDimitry Andric LLDB_LOG(log, 1369*0fca6ea1SDimitry Andric "CompleteNamespaceMap on (ASTContext*){0:x} '{1}' Searching " 13705ffd83dbSDimitry Andric "for namespace {2} in namespace {3}", 13715ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), name, 13725ffd83dbSDimitry Andric parent_map->begin()->second.GetName()); 13730b57cec5SDimitry Andric else 13745ffd83dbSDimitry Andric LLDB_LOG(log, 13755ffd83dbSDimitry Andric "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching " 13765ffd83dbSDimitry Andric "for namespace {2}", 13775ffd83dbSDimitry Andric m_ast_context, m_clang_ast_context->getDisplayName(), name); 13780b57cec5SDimitry Andric } 13790b57cec5SDimitry Andric 13800b57cec5SDimitry Andric if (parent_map) { 13810b57cec5SDimitry Andric for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(), 13820b57cec5SDimitry Andric e = parent_map->end(); 13830b57cec5SDimitry Andric i != e; ++i) { 13840b57cec5SDimitry Andric CompilerDeclContext found_namespace_decl; 13850b57cec5SDimitry Andric 13860b57cec5SDimitry Andric lldb::ModuleSP module_sp = i->first; 13870b57cec5SDimitry Andric CompilerDeclContext module_parent_namespace_decl = i->second; 13880b57cec5SDimitry Andric 13899dba64beSDimitry Andric SymbolFile *symbol_file = module_sp->GetSymbolFile(); 13900b57cec5SDimitry Andric 13919dba64beSDimitry Andric if (!symbol_file) 13920b57cec5SDimitry Andric continue; 13930b57cec5SDimitry Andric 13940b57cec5SDimitry Andric found_namespace_decl = 13955ffd83dbSDimitry Andric symbol_file->FindNamespace(name, module_parent_namespace_decl); 13960b57cec5SDimitry Andric 13970b57cec5SDimitry Andric if (!found_namespace_decl) 13980b57cec5SDimitry Andric continue; 13990b57cec5SDimitry Andric 14000b57cec5SDimitry Andric namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>( 14010b57cec5SDimitry Andric module_sp, found_namespace_decl)); 14020b57cec5SDimitry Andric 14035ffd83dbSDimitry Andric LLDB_LOG(log, " CMN Found namespace {0} in module {1}", name, 14045ffd83dbSDimitry Andric module_sp->GetFileSpec().GetFilename()); 14050b57cec5SDimitry Andric } 14060b57cec5SDimitry Andric } else { 14070b57cec5SDimitry Andric CompilerDeclContext null_namespace_decl; 1408e8d8bef9SDimitry Andric for (lldb::ModuleSP image : m_target->GetImages().Modules()) { 14090b57cec5SDimitry Andric if (!image) 14100b57cec5SDimitry Andric continue; 14110b57cec5SDimitry Andric 14120b57cec5SDimitry Andric CompilerDeclContext found_namespace_decl; 14130b57cec5SDimitry Andric 14149dba64beSDimitry Andric SymbolFile *symbol_file = image->GetSymbolFile(); 14150b57cec5SDimitry Andric 14169dba64beSDimitry Andric if (!symbol_file) 14170b57cec5SDimitry Andric continue; 14180b57cec5SDimitry Andric 14190b57cec5SDimitry Andric found_namespace_decl = 14205ffd83dbSDimitry Andric symbol_file->FindNamespace(name, null_namespace_decl); 14210b57cec5SDimitry Andric 14220b57cec5SDimitry Andric if (!found_namespace_decl) 14230b57cec5SDimitry Andric continue; 14240b57cec5SDimitry Andric 14250b57cec5SDimitry Andric namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>( 14260b57cec5SDimitry Andric image, found_namespace_decl)); 14270b57cec5SDimitry Andric 14285ffd83dbSDimitry Andric LLDB_LOG(log, " CMN[{0}] Found namespace {0} in module {1}", name, 14295ffd83dbSDimitry Andric image->GetFileSpec().GetFilename()); 14300b57cec5SDimitry Andric } 14310b57cec5SDimitry Andric } 14320b57cec5SDimitry Andric } 14330b57cec5SDimitry Andric 14340b57cec5SDimitry Andric NamespaceDecl *ClangASTSource::AddNamespace( 14350b57cec5SDimitry Andric NameSearchContext &context, 14360b57cec5SDimitry Andric ClangASTImporter::NamespaceMapSP &namespace_decls) { 14370b57cec5SDimitry Andric if (!namespace_decls) 14380b57cec5SDimitry Andric return nullptr; 14390b57cec5SDimitry Andric 14400b57cec5SDimitry Andric const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second; 14410b57cec5SDimitry Andric 14420b57cec5SDimitry Andric clang::ASTContext *src_ast = 14435ffd83dbSDimitry Andric TypeSystemClang::DeclContextGetTypeSystemClang(namespace_decl); 14440b57cec5SDimitry Andric if (!src_ast) 14450b57cec5SDimitry Andric return nullptr; 14460b57cec5SDimitry Andric clang::NamespaceDecl *src_namespace_decl = 14475ffd83dbSDimitry Andric TypeSystemClang::DeclContextGetAsNamespaceDecl(namespace_decl); 14480b57cec5SDimitry Andric 14490b57cec5SDimitry Andric if (!src_namespace_decl) 14500b57cec5SDimitry Andric return nullptr; 14510b57cec5SDimitry Andric 14520b57cec5SDimitry Andric Decl *copied_decl = CopyDecl(src_namespace_decl); 14530b57cec5SDimitry Andric 14540b57cec5SDimitry Andric if (!copied_decl) 14550b57cec5SDimitry Andric return nullptr; 14560b57cec5SDimitry Andric 14570b57cec5SDimitry Andric NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl); 14580b57cec5SDimitry Andric 14590b57cec5SDimitry Andric if (!copied_namespace_decl) 14600b57cec5SDimitry Andric return nullptr; 14610b57cec5SDimitry Andric 14620b57cec5SDimitry Andric context.m_decls.push_back(copied_namespace_decl); 14630b57cec5SDimitry Andric 14640b57cec5SDimitry Andric m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl, 14650b57cec5SDimitry Andric namespace_decls); 14660b57cec5SDimitry Andric 14670b57cec5SDimitry Andric return dyn_cast<NamespaceDecl>(copied_decl); 14680b57cec5SDimitry Andric } 14690b57cec5SDimitry Andric 14700b57cec5SDimitry Andric clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) { 1471480093f4SDimitry Andric return m_ast_importer_sp->CopyDecl(m_ast_context, src_decl); 14720b57cec5SDimitry Andric } 14730b57cec5SDimitry Andric 1474480093f4SDimitry Andric ClangASTImporter::DeclOrigin ClangASTSource::GetDeclOrigin(const clang::Decl *decl) { 1475480093f4SDimitry Andric return m_ast_importer_sp->GetDeclOrigin(decl); 14760b57cec5SDimitry Andric } 14770b57cec5SDimitry Andric 14780b57cec5SDimitry Andric CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) { 1479bdd1243dSDimitry Andric auto ts = src_type.GetTypeSystem(); 1480bdd1243dSDimitry Andric auto src_ast = ts.dyn_cast_or_null<TypeSystemClang>(); 1481bdd1243dSDimitry Andric if (!src_ast) 1482bdd1243dSDimitry Andric return {}; 14830b57cec5SDimitry Andric 14845ffd83dbSDimitry Andric QualType copied_qual_type = ClangUtil::GetQualType( 1485480093f4SDimitry Andric m_ast_importer_sp->CopyType(*m_clang_ast_context, src_type)); 14860b57cec5SDimitry Andric 14870b57cec5SDimitry Andric if (copied_qual_type.getAsOpaquePtr() && 14880b57cec5SDimitry Andric copied_qual_type->getCanonicalTypeInternal().isNull()) 14890b57cec5SDimitry Andric // this shouldn't happen, but we're hardening because the AST importer 14900b57cec5SDimitry Andric // seems to be generating bad types on occasion. 1491bdd1243dSDimitry Andric return {}; 14920b57cec5SDimitry Andric 1493480093f4SDimitry Andric return m_clang_ast_context->GetType(copied_qual_type); 14940b57cec5SDimitry Andric } 1495fe6060f1SDimitry Andric 1496fe6060f1SDimitry Andric std::shared_ptr<ClangModulesDeclVendor> 1497fe6060f1SDimitry Andric ClangASTSource::GetClangModulesDeclVendor() { 1498fe6060f1SDimitry Andric auto persistent_vars = llvm::cast<ClangPersistentVariables>( 1499fe6060f1SDimitry Andric m_target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC)); 1500fe6060f1SDimitry Andric return persistent_vars->GetClangModulesDeclVendor(); 1501fe6060f1SDimitry Andric } 1502