1 //===-- ClangASTSource.cpp ------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "ClangASTSource.h" 10 11 #include "ClangDeclVendor.h" 12 #include "ClangModulesDeclVendor.h" 13 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/ModuleList.h" 16 #include "lldb/Symbol/CompilerDeclContext.h" 17 #include "lldb/Symbol/Function.h" 18 #include "lldb/Symbol/SymbolFile.h" 19 #include "lldb/Symbol/TaggedASTType.h" 20 #include "lldb/Target/Target.h" 21 #include "lldb/Utility/LLDBLog.h" 22 #include "lldb/Utility/Log.h" 23 #include "clang/AST/ASTContext.h" 24 #include "clang/AST/RecordLayout.h" 25 #include "clang/Basic/SourceManager.h" 26 27 #include "Plugins/ExpressionParser/Clang/ClangUtil.h" 28 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h" 29 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 30 31 #include <memory> 32 #include <vector> 33 34 using namespace clang; 35 using namespace lldb_private; 36 37 // Scoped class that will remove an active lexical decl from the set when it 38 // goes out of scope. 39 namespace { 40 class ScopedLexicalDeclEraser { 41 public: 42 ScopedLexicalDeclEraser(std::set<const clang::Decl *> &decls, 43 const clang::Decl *decl) 44 : m_active_lexical_decls(decls), m_decl(decl) {} 45 46 ~ScopedLexicalDeclEraser() { m_active_lexical_decls.erase(m_decl); } 47 48 private: 49 std::set<const clang::Decl *> &m_active_lexical_decls; 50 const clang::Decl *m_decl; 51 }; 52 } 53 54 ClangASTSource::ClangASTSource( 55 const lldb::TargetSP &target, 56 const std::shared_ptr<ClangASTImporter> &importer) 57 : m_lookups_enabled(false), m_target(target), m_ast_context(nullptr), 58 m_ast_importer_sp(importer), m_active_lexical_decls(), 59 m_active_lookups() { 60 assert(m_ast_importer_sp && "No ClangASTImporter passed to ClangASTSource?"); 61 } 62 63 void ClangASTSource::InstallASTContext(TypeSystemClang &clang_ast_context) { 64 m_ast_context = &clang_ast_context.getASTContext(); 65 m_clang_ast_context = &clang_ast_context; 66 m_file_manager = &m_ast_context->getSourceManager().getFileManager(); 67 m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this); 68 } 69 70 ClangASTSource::~ClangASTSource() { 71 m_ast_importer_sp->ForgetDestination(m_ast_context); 72 73 if (!m_target) 74 return; 75 76 // Unregister the current ASTContext as a source for all scratch 77 // ASTContexts in the ClangASTImporter. Without this the scratch AST might 78 // query the deleted ASTContext for additional type information. 79 // We unregister from *all* scratch ASTContexts in case a type got exported 80 // to a scratch AST that isn't the best fitting scratch ASTContext. 81 lldb::TypeSystemClangSP scratch_ts_sp = ScratchTypeSystemClang::GetForTarget( 82 *m_target, ScratchTypeSystemClang::DefaultAST, false); 83 84 if (!scratch_ts_sp) 85 return; 86 87 ScratchTypeSystemClang *default_scratch_ast = 88 llvm::cast<ScratchTypeSystemClang>(scratch_ts_sp.get()); 89 // Unregister from the default scratch AST (and all sub-ASTs). 90 default_scratch_ast->ForgetSource(m_ast_context, *m_ast_importer_sp); 91 } 92 93 void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) { 94 if (!m_ast_context) 95 return; 96 97 m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage(); 98 m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage(); 99 } 100 101 // The core lookup interface. 102 bool ClangASTSource::FindExternalVisibleDeclsByName( 103 const DeclContext *decl_ctx, DeclarationName clang_decl_name) { 104 if (!m_ast_context) { 105 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 106 return false; 107 } 108 109 std::string decl_name(clang_decl_name.getAsString()); 110 111 switch (clang_decl_name.getNameKind()) { 112 // Normal identifiers. 113 case DeclarationName::Identifier: { 114 clang::IdentifierInfo *identifier_info = 115 clang_decl_name.getAsIdentifierInfo(); 116 117 if (!identifier_info || identifier_info->getBuiltinID() != 0) { 118 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 119 return false; 120 } 121 } break; 122 123 // Operator names. 124 case DeclarationName::CXXOperatorName: 125 case DeclarationName::CXXLiteralOperatorName: 126 break; 127 128 // Using directives found in this context. 129 // Tell Sema we didn't find any or we'll end up getting asked a *lot*. 130 case DeclarationName::CXXUsingDirective: 131 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 132 return false; 133 134 case DeclarationName::ObjCZeroArgSelector: 135 case DeclarationName::ObjCOneArgSelector: 136 case DeclarationName::ObjCMultiArgSelector: { 137 llvm::SmallVector<NamedDecl *, 1> method_decls; 138 139 NameSearchContext method_search_context(*m_clang_ast_context, method_decls, 140 clang_decl_name, decl_ctx); 141 142 FindObjCMethodDecls(method_search_context); 143 144 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls); 145 return (method_decls.size() > 0); 146 } 147 // These aren't possible in the global context. 148 case DeclarationName::CXXConstructorName: 149 case DeclarationName::CXXDestructorName: 150 case DeclarationName::CXXConversionFunctionName: 151 case DeclarationName::CXXDeductionGuideName: 152 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 153 return false; 154 } 155 156 if (!GetLookupsEnabled()) { 157 // Wait until we see a '$' at the start of a name before we start doing any 158 // lookups so we can avoid lookup up all of the builtin types. 159 if (!decl_name.empty() && decl_name[0] == '$') { 160 SetLookupsEnabled(true); 161 } else { 162 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 163 return false; 164 } 165 } 166 167 ConstString const_decl_name(decl_name.c_str()); 168 169 const char *uniqued_const_decl_name = const_decl_name.GetCString(); 170 if (m_active_lookups.find(uniqued_const_decl_name) != 171 m_active_lookups.end()) { 172 // We are currently looking up this name... 173 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 174 return false; 175 } 176 m_active_lookups.insert(uniqued_const_decl_name); 177 llvm::SmallVector<NamedDecl *, 4> name_decls; 178 NameSearchContext name_search_context(*m_clang_ast_context, name_decls, 179 clang_decl_name, decl_ctx); 180 FindExternalVisibleDecls(name_search_context); 181 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls); 182 m_active_lookups.erase(uniqued_const_decl_name); 183 return (name_decls.size() != 0); 184 } 185 186 TagDecl *ClangASTSource::FindCompleteType(const TagDecl *decl) { 187 Log *log = GetLog(LLDBLog::Expressions); 188 189 if (const NamespaceDecl *namespace_context = 190 dyn_cast<NamespaceDecl>(decl->getDeclContext())) { 191 ClangASTImporter::NamespaceMapSP namespace_map = 192 m_ast_importer_sp->GetNamespaceMap(namespace_context); 193 194 if (!namespace_map) 195 return nullptr; 196 197 LLDB_LOGV(log, " CTD Inspecting namespace map{0} ({1} entries)", 198 namespace_map.get(), namespace_map->size()); 199 200 for (const ClangASTImporter::NamespaceMapItem &item : *namespace_map) { 201 LLDB_LOG(log, " CTD Searching namespace {0} in module {1}", 202 item.second.GetName(), item.first->GetFileSpec().GetFilename()); 203 204 TypeList types; 205 206 ConstString name(decl->getName()); 207 208 item.first->FindTypesInNamespace(name, item.second, UINT32_MAX, types); 209 210 for (uint32_t ti = 0, te = types.GetSize(); ti != te; ++ti) { 211 lldb::TypeSP type = types.GetTypeAtIndex(ti); 212 213 if (!type) 214 continue; 215 216 CompilerType clang_type(type->GetFullCompilerType()); 217 218 if (!ClangUtil::IsClangType(clang_type)) 219 continue; 220 221 const TagType *tag_type = 222 ClangUtil::GetQualType(clang_type)->getAs<TagType>(); 223 224 if (!tag_type) 225 continue; 226 227 TagDecl *candidate_tag_decl = 228 const_cast<TagDecl *>(tag_type->getDecl()); 229 230 if (TypeSystemClang::GetCompleteDecl( 231 &candidate_tag_decl->getASTContext(), candidate_tag_decl)) 232 return candidate_tag_decl; 233 } 234 } 235 } else { 236 TypeList types; 237 238 ConstString name(decl->getName()); 239 240 const ModuleList &module_list = m_target->GetImages(); 241 242 bool exact_match = false; 243 llvm::DenseSet<SymbolFile *> searched_symbol_files; 244 module_list.FindTypes(nullptr, name, exact_match, UINT32_MAX, 245 searched_symbol_files, types); 246 247 for (uint32_t ti = 0, te = types.GetSize(); ti != te; ++ti) { 248 lldb::TypeSP type = types.GetTypeAtIndex(ti); 249 250 if (!type) 251 continue; 252 253 CompilerType clang_type(type->GetFullCompilerType()); 254 255 if (!ClangUtil::IsClangType(clang_type)) 256 continue; 257 258 const TagType *tag_type = 259 ClangUtil::GetQualType(clang_type)->getAs<TagType>(); 260 261 if (!tag_type) 262 continue; 263 264 TagDecl *candidate_tag_decl = const_cast<TagDecl *>(tag_type->getDecl()); 265 266 // We have found a type by basename and we need to make sure the decl 267 // contexts are the same before we can try to complete this type with 268 // another 269 if (!TypeSystemClang::DeclsAreEquivalent(const_cast<TagDecl *>(decl), 270 candidate_tag_decl)) 271 continue; 272 273 if (TypeSystemClang::GetCompleteDecl(&candidate_tag_decl->getASTContext(), 274 candidate_tag_decl)) 275 return candidate_tag_decl; 276 } 277 } 278 return nullptr; 279 } 280 281 void ClangASTSource::CompleteType(TagDecl *tag_decl) { 282 Log *log = GetLog(LLDBLog::Expressions); 283 284 if (log) { 285 LLDB_LOG(log, 286 " CompleteTagDecl on (ASTContext*){0} Completing " 287 "(TagDecl*){1} named {2}", 288 m_clang_ast_context->getDisplayName(), tag_decl, 289 tag_decl->getName()); 290 291 LLDB_LOG(log, " CTD Before:\n{0}", ClangUtil::DumpDecl(tag_decl)); 292 } 293 294 auto iter = m_active_lexical_decls.find(tag_decl); 295 if (iter != m_active_lexical_decls.end()) 296 return; 297 m_active_lexical_decls.insert(tag_decl); 298 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl); 299 300 if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) { 301 // We couldn't complete the type. Maybe there's a definition somewhere 302 // else that can be completed. 303 if (TagDecl *alternate = FindCompleteType(tag_decl)) 304 m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, alternate); 305 } 306 307 LLDB_LOG(log, " [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl)); 308 } 309 310 void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) { 311 Log *log = GetLog(LLDBLog::Expressions); 312 313 LLDB_LOG(log, 314 " [CompleteObjCInterfaceDecl] on (ASTContext*){0} '{1}' " 315 "Completing an ObjCInterfaceDecl named {1}", 316 m_ast_context, m_clang_ast_context->getDisplayName(), 317 interface_decl->getName()); 318 LLDB_LOG(log, " [COID] Before:\n{0}", 319 ClangUtil::DumpDecl(interface_decl)); 320 321 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl); 322 323 if (original.Valid()) { 324 if (ObjCInterfaceDecl *original_iface_decl = 325 dyn_cast<ObjCInterfaceDecl>(original.decl)) { 326 ObjCInterfaceDecl *complete_iface_decl = 327 GetCompleteObjCInterface(original_iface_decl); 328 329 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { 330 m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl); 331 } 332 } 333 } 334 335 m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl); 336 337 if (interface_decl->getSuperClass() && 338 interface_decl->getSuperClass() != interface_decl) 339 CompleteType(interface_decl->getSuperClass()); 340 341 LLDB_LOG(log, " [COID] After:"); 342 LLDB_LOG(log, " [COID] {0}", ClangUtil::DumpDecl(interface_decl)); 343 } 344 345 clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface( 346 const clang::ObjCInterfaceDecl *interface_decl) { 347 lldb::ProcessSP process(m_target->GetProcessSP()); 348 349 if (!process) 350 return nullptr; 351 352 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 353 354 if (!language_runtime) 355 return nullptr; 356 357 ConstString class_name(interface_decl->getNameAsString().c_str()); 358 359 lldb::TypeSP complete_type_sp( 360 language_runtime->LookupInCompleteClassCache(class_name)); 361 362 if (!complete_type_sp) 363 return nullptr; 364 365 TypeFromUser complete_type = 366 TypeFromUser(complete_type_sp->GetFullCompilerType()); 367 lldb::opaque_compiler_type_t complete_opaque_type = 368 complete_type.GetOpaqueQualType(); 369 370 if (!complete_opaque_type) 371 return nullptr; 372 373 const clang::Type *complete_clang_type = 374 QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr(); 375 const ObjCInterfaceType *complete_interface_type = 376 dyn_cast<ObjCInterfaceType>(complete_clang_type); 377 378 if (!complete_interface_type) 379 return nullptr; 380 381 ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl()); 382 383 return complete_iface_decl; 384 } 385 386 void ClangASTSource::FindExternalLexicalDecls( 387 const DeclContext *decl_context, 388 llvm::function_ref<bool(Decl::Kind)> predicate, 389 llvm::SmallVectorImpl<Decl *> &decls) { 390 391 Log *log = GetLog(LLDBLog::Expressions); 392 393 const Decl *context_decl = dyn_cast<Decl>(decl_context); 394 395 if (!context_decl) 396 return; 397 398 auto iter = m_active_lexical_decls.find(context_decl); 399 if (iter != m_active_lexical_decls.end()) 400 return; 401 m_active_lexical_decls.insert(context_decl); 402 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl); 403 404 if (log) { 405 if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl)) 406 LLDB_LOG(log, 407 "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in " 408 "'{2}' ({3}Decl*){4}", 409 m_ast_context, m_clang_ast_context->getDisplayName(), 410 context_named_decl->getNameAsString().c_str(), 411 context_decl->getDeclKindName(), 412 static_cast<const void *>(context_decl)); 413 else if (context_decl) 414 LLDB_LOG(log, 415 "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in " 416 "({2}Decl*){3}", 417 m_ast_context, m_clang_ast_context->getDisplayName(), 418 context_decl->getDeclKindName(), 419 static_cast<const void *>(context_decl)); 420 else 421 LLDB_LOG(log, 422 "FindExternalLexicalDecls on (ASTContext*){0} '{1}' in a " 423 "NULL context", 424 m_ast_context, m_clang_ast_context->getDisplayName()); 425 } 426 427 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(context_decl); 428 429 if (!original.Valid()) 430 return; 431 432 LLDB_LOG(log, " FELD Original decl {0} (Decl*){1:x}:\n{2}", 433 static_cast<void *>(original.ctx), 434 static_cast<void *>(original.decl), 435 ClangUtil::DumpDecl(original.decl)); 436 437 if (ObjCInterfaceDecl *original_iface_decl = 438 dyn_cast<ObjCInterfaceDecl>(original.decl)) { 439 ObjCInterfaceDecl *complete_iface_decl = 440 GetCompleteObjCInterface(original_iface_decl); 441 442 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { 443 original.decl = complete_iface_decl; 444 original.ctx = &complete_iface_decl->getASTContext(); 445 446 m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl); 447 } 448 } 449 450 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original.decl)) { 451 ExternalASTSource *external_source = original.ctx->getExternalSource(); 452 453 if (external_source) 454 external_source->CompleteType(original_tag_decl); 455 } 456 457 const DeclContext *original_decl_context = 458 dyn_cast<DeclContext>(original.decl); 459 460 if (!original_decl_context) 461 return; 462 463 // Indicates whether we skipped any Decls of the original DeclContext. 464 bool SkippedDecls = false; 465 for (Decl *decl : original_decl_context->decls()) { 466 // The predicate function returns true if the passed declaration kind is 467 // the one we are looking for. 468 // See clang::ExternalASTSource::FindExternalLexicalDecls() 469 if (predicate(decl->getKind())) { 470 if (log) { 471 std::string ast_dump = ClangUtil::DumpDecl(decl); 472 if (const NamedDecl *context_named_decl = 473 dyn_cast<NamedDecl>(context_decl)) 474 LLDB_LOG(log, " FELD Adding [to {0}Decl {1}] lexical {2}Decl {3}", 475 context_named_decl->getDeclKindName(), 476 context_named_decl->getName(), decl->getDeclKindName(), 477 ast_dump); 478 else 479 LLDB_LOG(log, " FELD Adding lexical {0}Decl {1}", 480 decl->getDeclKindName(), ast_dump); 481 } 482 483 Decl *copied_decl = CopyDecl(decl); 484 485 if (!copied_decl) 486 continue; 487 488 // FIXME: We should add the copied decl to the 'decls' list. This would 489 // add the copied Decl into the DeclContext and make sure that we 490 // correctly propagate that we added some Decls back to Clang. 491 // By leaving 'decls' empty we incorrectly return false from 492 // DeclContext::LoadLexicalDeclsFromExternalStorage which might cause 493 // lookup issues later on. 494 // We can't just add them for now as the ASTImporter already added the 495 // decl into the DeclContext and this would add it twice. 496 497 if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) { 498 QualType copied_field_type = copied_field->getType(); 499 500 m_ast_importer_sp->RequireCompleteType(copied_field_type); 501 } 502 } else { 503 SkippedDecls = true; 504 } 505 } 506 507 // CopyDecl may build a lookup table which may set up ExternalLexicalStorage 508 // to false. However, since we skipped some of the external Decls we must 509 // set it back! 510 if (SkippedDecls) { 511 decl_context->setHasExternalLexicalStorage(true); 512 // This sets HasLazyExternalLexicalLookups to true. By setting this bit we 513 // ensure that the lookup table is rebuilt, which means the external source 514 // is consulted again when a clang::DeclContext::lookup is called. 515 const_cast<DeclContext *>(decl_context)->setMustBuildLookupTable(); 516 } 517 } 518 519 void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) { 520 assert(m_ast_context); 521 522 const ConstString name(context.m_decl_name.getAsString().c_str()); 523 524 Log *log = GetLog(LLDBLog::Expressions); 525 526 if (log) { 527 if (!context.m_decl_context) 528 LLDB_LOG(log, 529 "ClangASTSource::FindExternalVisibleDecls on " 530 "(ASTContext*){0} '{1}' for '{2}' in a NULL DeclContext", 531 m_ast_context, m_clang_ast_context->getDisplayName(), name); 532 else if (const NamedDecl *context_named_decl = 533 dyn_cast<NamedDecl>(context.m_decl_context)) 534 LLDB_LOG(log, 535 "ClangASTSource::FindExternalVisibleDecls on " 536 "(ASTContext*){0} '{1}' for '{2}' in '{3}'", 537 m_ast_context, m_clang_ast_context->getDisplayName(), name, 538 context_named_decl->getName()); 539 else 540 LLDB_LOG(log, 541 "ClangASTSource::FindExternalVisibleDecls on " 542 "(ASTContext*){0} '{1}' for '{2}' in a '{3}'", 543 m_ast_context, m_clang_ast_context->getDisplayName(), name, 544 context.m_decl_context->getDeclKindName()); 545 } 546 547 if (isa<NamespaceDecl>(context.m_decl_context)) { 548 LookupInNamespace(context); 549 } else if (isa<ObjCInterfaceDecl>(context.m_decl_context)) { 550 FindObjCPropertyAndIvarDecls(context); 551 } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) { 552 // we shouldn't be getting FindExternalVisibleDecls calls for these 553 return; 554 } else { 555 CompilerDeclContext namespace_decl; 556 557 LLDB_LOG(log, " CAS::FEVD Searching the root namespace"); 558 559 FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl); 560 } 561 562 if (!context.m_namespace_map->empty()) { 563 if (log && log->GetVerbose()) 564 LLDB_LOG(log, " CAS::FEVD Registering namespace map {0} ({1} entries)", 565 context.m_namespace_map.get(), context.m_namespace_map->size()); 566 567 NamespaceDecl *clang_namespace_decl = 568 AddNamespace(context, context.m_namespace_map); 569 570 if (clang_namespace_decl) 571 clang_namespace_decl->setHasExternalVisibleStorage(); 572 } 573 } 574 575 clang::Sema *ClangASTSource::getSema() { 576 return m_clang_ast_context->getSema(); 577 } 578 579 bool ClangASTSource::IgnoreName(const ConstString name, 580 bool ignore_all_dollar_names) { 581 static const ConstString id_name("id"); 582 static const ConstString Class_name("Class"); 583 584 if (m_ast_context->getLangOpts().ObjC) 585 if (name == id_name || name == Class_name) 586 return true; 587 588 StringRef name_string_ref = name.GetStringRef(); 589 590 // The ClangASTSource is not responsible for finding $-names. 591 return name_string_ref.empty() || 592 (ignore_all_dollar_names && name_string_ref.startswith("$")) || 593 name_string_ref.startswith("_$"); 594 } 595 596 void ClangASTSource::FindExternalVisibleDecls( 597 NameSearchContext &context, lldb::ModuleSP module_sp, 598 CompilerDeclContext &namespace_decl) { 599 assert(m_ast_context); 600 601 Log *log = GetLog(LLDBLog::Expressions); 602 603 SymbolContextList sc_list; 604 605 const ConstString name(context.m_decl_name.getAsString().c_str()); 606 if (IgnoreName(name, true)) 607 return; 608 609 if (!m_target) 610 return; 611 612 FillNamespaceMap(context, module_sp, namespace_decl); 613 614 if (context.m_found_type) 615 return; 616 617 TypeList types; 618 const bool exact_match = true; 619 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; 620 if (module_sp && namespace_decl) 621 module_sp->FindTypesInNamespace(name, namespace_decl, 1, types); 622 else { 623 m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1, 624 searched_symbol_files, types); 625 } 626 627 if (size_t num_types = types.GetSize()) { 628 for (size_t ti = 0; ti < num_types; ++ti) { 629 lldb::TypeSP type_sp = types.GetTypeAtIndex(ti); 630 631 if (log) { 632 const char *name_string = type_sp->GetName().GetCString(); 633 634 LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\": {1}", name, 635 (name_string ? name_string : "<anonymous>")); 636 } 637 638 CompilerType full_type = type_sp->GetFullCompilerType(); 639 640 CompilerType copied_clang_type(GuardedCopyType(full_type)); 641 642 if (!copied_clang_type) { 643 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type"); 644 645 continue; 646 } 647 648 context.AddTypeDecl(copied_clang_type); 649 650 context.m_found_type = true; 651 break; 652 } 653 } 654 655 if (!context.m_found_type) { 656 // Try the modules next. 657 FindDeclInModules(context, name); 658 } 659 660 if (!context.m_found_type) { 661 FindDeclInObjCRuntime(context, name); 662 } 663 } 664 665 void ClangASTSource::FillNamespaceMap( 666 NameSearchContext &context, lldb::ModuleSP module_sp, 667 const CompilerDeclContext &namespace_decl) { 668 const ConstString name(context.m_decl_name.getAsString().c_str()); 669 if (IgnoreName(name, true)) 670 return; 671 672 Log *log = GetLog(LLDBLog::Expressions); 673 674 if (module_sp && namespace_decl) { 675 CompilerDeclContext found_namespace_decl; 676 677 if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) { 678 found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl); 679 680 if (found_namespace_decl) { 681 context.m_namespace_map->push_back( 682 std::pair<lldb::ModuleSP, CompilerDeclContext>( 683 module_sp, found_namespace_decl)); 684 685 LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name, 686 module_sp->GetFileSpec().GetFilename()); 687 } 688 } 689 return; 690 } 691 692 for (lldb::ModuleSP image : m_target->GetImages().Modules()) { 693 if (!image) 694 continue; 695 696 CompilerDeclContext found_namespace_decl; 697 698 SymbolFile *symbol_file = image->GetSymbolFile(); 699 700 if (!symbol_file) 701 continue; 702 703 // If namespace_decl is not valid, 'FindNamespace' would look for 704 // any namespace called 'name' (ignoring parent contexts) and return 705 // the first one it finds. Thus if we're doing a qualified lookup only 706 // consider root namespaces. E.g., in an expression ::A::B::Foo, the 707 // lookup of ::A will result in a qualified lookup. Note, namespace 708 // disambiguation for function calls are handled separately in 709 // SearchFunctionsInSymbolContexts. 710 const bool find_root_namespaces = 711 context.m_decl_context && 712 context.m_decl_context->shouldUseQualifiedLookup(); 713 found_namespace_decl = symbol_file->FindNamespace( 714 name, namespace_decl, /* only root namespaces */ find_root_namespaces); 715 716 if (found_namespace_decl) { 717 context.m_namespace_map->push_back( 718 std::pair<lldb::ModuleSP, CompilerDeclContext>(image, 719 found_namespace_decl)); 720 721 LLDB_LOG(log, " CAS::FEVD Found namespace {0} in module {1}", name, 722 image->GetFileSpec().GetFilename()); 723 } 724 } 725 } 726 727 template <class D> class TaggedASTDecl { 728 public: 729 TaggedASTDecl() : decl(nullptr) {} 730 TaggedASTDecl(D *_decl) : decl(_decl) {} 731 bool IsValid() const { return (decl != nullptr); } 732 bool IsInvalid() const { return !IsValid(); } 733 D *operator->() const { return decl; } 734 D *decl; 735 }; 736 737 template <class D2, template <class D> class TD, class D1> 738 TD<D2> DynCast(TD<D1> source) { 739 return TD<D2>(dyn_cast<D2>(source.decl)); 740 } 741 742 template <class D = Decl> class DeclFromParser; 743 template <class D = Decl> class DeclFromUser; 744 745 template <class D> class DeclFromParser : public TaggedASTDecl<D> { 746 public: 747 DeclFromParser() : TaggedASTDecl<D>() {} 748 DeclFromParser(D *_decl) : TaggedASTDecl<D>(_decl) {} 749 750 DeclFromUser<D> GetOrigin(ClangASTSource &source); 751 }; 752 753 template <class D> class DeclFromUser : public TaggedASTDecl<D> { 754 public: 755 DeclFromUser() : TaggedASTDecl<D>() {} 756 DeclFromUser(D *_decl) : TaggedASTDecl<D>(_decl) {} 757 758 DeclFromParser<D> Import(ClangASTSource &source); 759 }; 760 761 template <class D> 762 DeclFromUser<D> DeclFromParser<D>::GetOrigin(ClangASTSource &source) { 763 ClangASTImporter::DeclOrigin origin = source.GetDeclOrigin(this->decl); 764 if (!origin.Valid()) 765 return DeclFromUser<D>(); 766 return DeclFromUser<D>(dyn_cast<D>(origin.decl)); 767 } 768 769 template <class D> 770 DeclFromParser<D> DeclFromUser<D>::Import(ClangASTSource &source) { 771 DeclFromParser<> parser_generic_decl(source.CopyDecl(this->decl)); 772 if (parser_generic_decl.IsInvalid()) 773 return DeclFromParser<D>(); 774 return DeclFromParser<D>(dyn_cast<D>(parser_generic_decl.decl)); 775 } 776 777 bool ClangASTSource::FindObjCMethodDeclsWithOrigin( 778 NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl, 779 const char *log_info) { 780 const DeclarationName &decl_name(context.m_decl_name); 781 clang::ASTContext *original_ctx = &original_interface_decl->getASTContext(); 782 783 Selector original_selector; 784 785 if (decl_name.isObjCZeroArgSelector()) { 786 IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString()); 787 original_selector = original_ctx->Selectors.getSelector(0, &ident); 788 } else if (decl_name.isObjCOneArgSelector()) { 789 const std::string &decl_name_string = decl_name.getAsString(); 790 std::string decl_name_string_without_colon(decl_name_string.c_str(), 791 decl_name_string.length() - 1); 792 IdentifierInfo *ident = 793 &original_ctx->Idents.get(decl_name_string_without_colon); 794 original_selector = original_ctx->Selectors.getSelector(1, &ident); 795 } else { 796 SmallVector<IdentifierInfo *, 4> idents; 797 798 clang::Selector sel = decl_name.getObjCSelector(); 799 800 unsigned num_args = sel.getNumArgs(); 801 802 for (unsigned i = 0; i != num_args; ++i) { 803 idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i))); 804 } 805 806 original_selector = 807 original_ctx->Selectors.getSelector(num_args, idents.data()); 808 } 809 810 DeclarationName original_decl_name(original_selector); 811 812 llvm::SmallVector<NamedDecl *, 1> methods; 813 814 TypeSystemClang::GetCompleteDecl(original_ctx, original_interface_decl); 815 816 if (ObjCMethodDecl *instance_method_decl = 817 original_interface_decl->lookupInstanceMethod(original_selector)) { 818 methods.push_back(instance_method_decl); 819 } else if (ObjCMethodDecl *class_method_decl = 820 original_interface_decl->lookupClassMethod( 821 original_selector)) { 822 methods.push_back(class_method_decl); 823 } 824 825 if (methods.empty()) { 826 return false; 827 } 828 829 for (NamedDecl *named_decl : methods) { 830 if (!named_decl) 831 continue; 832 833 ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(named_decl); 834 835 if (!result_method) 836 continue; 837 838 Decl *copied_decl = CopyDecl(result_method); 839 840 if (!copied_decl) 841 continue; 842 843 ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl); 844 845 if (!copied_method_decl) 846 continue; 847 848 Log *log = GetLog(LLDBLog::Expressions); 849 850 LLDB_LOG(log, " CAS::FOMD found ({0}) {1}", log_info, 851 ClangUtil::DumpDecl(copied_method_decl)); 852 853 context.AddNamedDecl(copied_method_decl); 854 } 855 856 return true; 857 } 858 859 void ClangASTSource::FindDeclInModules(NameSearchContext &context, 860 ConstString name) { 861 Log *log = GetLog(LLDBLog::Expressions); 862 863 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor = 864 GetClangModulesDeclVendor(); 865 if (!modules_decl_vendor) 866 return; 867 868 bool append = false; 869 uint32_t max_matches = 1; 870 std::vector<clang::NamedDecl *> decls; 871 872 if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls)) 873 return; 874 875 LLDB_LOG(log, " CAS::FEVD Matching entity found for \"{0}\" in the modules", 876 name); 877 878 clang::NamedDecl *const decl_from_modules = decls[0]; 879 880 if (llvm::isa<clang::TypeDecl>(decl_from_modules) || 881 llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) || 882 llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) { 883 clang::Decl *copied_decl = CopyDecl(decl_from_modules); 884 clang::NamedDecl *copied_named_decl = 885 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr; 886 887 if (!copied_named_decl) { 888 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the modules"); 889 890 return; 891 } 892 893 context.AddNamedDecl(copied_named_decl); 894 895 context.m_found_type = true; 896 } 897 } 898 899 void ClangASTSource::FindDeclInObjCRuntime(NameSearchContext &context, 900 ConstString name) { 901 Log *log = GetLog(LLDBLog::Expressions); 902 903 lldb::ProcessSP process(m_target->GetProcessSP()); 904 905 if (!process) 906 return; 907 908 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 909 910 if (!language_runtime) 911 return; 912 913 DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 914 915 if (!decl_vendor) 916 return; 917 918 bool append = false; 919 uint32_t max_matches = 1; 920 std::vector<clang::NamedDecl *> decls; 921 922 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor); 923 if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls)) 924 return; 925 926 LLDB_LOG(log, " CAS::FEVD Matching type found for \"{0}\" in the runtime", 927 name); 928 929 clang::Decl *copied_decl = CopyDecl(decls[0]); 930 clang::NamedDecl *copied_named_decl = 931 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr; 932 933 if (!copied_named_decl) { 934 LLDB_LOG(log, " CAS::FEVD - Couldn't export a type from the runtime"); 935 936 return; 937 } 938 939 context.AddNamedDecl(copied_named_decl); 940 } 941 942 void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) { 943 Log *log = GetLog(LLDBLog::Expressions); 944 945 const DeclarationName &decl_name(context.m_decl_name); 946 const DeclContext *decl_ctx(context.m_decl_context); 947 948 const ObjCInterfaceDecl *interface_decl = 949 dyn_cast<ObjCInterfaceDecl>(decl_ctx); 950 951 if (!interface_decl) 952 return; 953 954 do { 955 ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl); 956 957 if (!original.Valid()) 958 break; 959 960 ObjCInterfaceDecl *original_interface_decl = 961 dyn_cast<ObjCInterfaceDecl>(original.decl); 962 963 if (FindObjCMethodDeclsWithOrigin(context, original_interface_decl, 964 "at origin")) 965 return; // found it, no need to look any further 966 } while (false); 967 968 StreamString ss; 969 970 if (decl_name.isObjCZeroArgSelector()) { 971 ss.Printf("%s", decl_name.getAsString().c_str()); 972 } else if (decl_name.isObjCOneArgSelector()) { 973 ss.Printf("%s", decl_name.getAsString().c_str()); 974 } else { 975 clang::Selector sel = decl_name.getObjCSelector(); 976 977 for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) { 978 llvm::StringRef r = sel.getNameForSlot(i); 979 ss.Printf("%s:", r.str().c_str()); 980 } 981 } 982 ss.Flush(); 983 984 if (ss.GetString().contains("$__lldb")) 985 return; // we don't need any results 986 987 ConstString selector_name(ss.GetString()); 988 989 LLDB_LOG(log, 990 "ClangASTSource::FindObjCMethodDecls on (ASTContext*){0} '{1}' " 991 "for selector [{2} {3}]", 992 m_ast_context, m_clang_ast_context->getDisplayName(), 993 interface_decl->getName(), selector_name); 994 SymbolContextList sc_list; 995 996 ModuleFunctionSearchOptions function_options; 997 function_options.include_symbols = false; 998 function_options.include_inlines = false; 999 1000 std::string interface_name = interface_decl->getNameAsString(); 1001 1002 do { 1003 StreamString ms; 1004 ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString()); 1005 ms.Flush(); 1006 ConstString instance_method_name(ms.GetString()); 1007 1008 sc_list.Clear(); 1009 m_target->GetImages().FindFunctions(instance_method_name, 1010 lldb::eFunctionNameTypeFull, 1011 function_options, sc_list); 1012 1013 if (sc_list.GetSize()) 1014 break; 1015 1016 ms.Clear(); 1017 ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString()); 1018 ms.Flush(); 1019 ConstString class_method_name(ms.GetString()); 1020 1021 sc_list.Clear(); 1022 m_target->GetImages().FindFunctions(class_method_name, 1023 lldb::eFunctionNameTypeFull, 1024 function_options, sc_list); 1025 1026 if (sc_list.GetSize()) 1027 break; 1028 1029 // Fall back and check for methods in categories. If we find methods this 1030 // way, we need to check that they're actually in categories on the desired 1031 // class. 1032 1033 SymbolContextList candidate_sc_list; 1034 1035 m_target->GetImages().FindFunctions(selector_name, 1036 lldb::eFunctionNameTypeSelector, 1037 function_options, candidate_sc_list); 1038 1039 for (const SymbolContext &candidate_sc : candidate_sc_list) { 1040 if (!candidate_sc.function) 1041 continue; 1042 1043 const char *candidate_name = candidate_sc.function->GetName().AsCString(); 1044 1045 const char *cursor = candidate_name; 1046 1047 if (*cursor != '+' && *cursor != '-') 1048 continue; 1049 1050 ++cursor; 1051 1052 if (*cursor != '[') 1053 continue; 1054 1055 ++cursor; 1056 1057 size_t interface_len = interface_name.length(); 1058 1059 if (strncmp(cursor, interface_name.c_str(), interface_len)) 1060 continue; 1061 1062 cursor += interface_len; 1063 1064 if (*cursor == ' ' || *cursor == '(') 1065 sc_list.Append(candidate_sc); 1066 } 1067 } while (false); 1068 1069 if (sc_list.GetSize()) { 1070 // We found a good function symbol. Use that. 1071 1072 for (const SymbolContext &sc : sc_list) { 1073 if (!sc.function) 1074 continue; 1075 1076 CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext(); 1077 if (!function_decl_ctx) 1078 continue; 1079 1080 ObjCMethodDecl *method_decl = 1081 TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx); 1082 1083 if (!method_decl) 1084 continue; 1085 1086 ObjCInterfaceDecl *found_interface_decl = 1087 method_decl->getClassInterface(); 1088 1089 if (!found_interface_decl) 1090 continue; 1091 1092 if (found_interface_decl->getName() == interface_decl->getName()) { 1093 Decl *copied_decl = CopyDecl(method_decl); 1094 1095 if (!copied_decl) 1096 continue; 1097 1098 ObjCMethodDecl *copied_method_decl = 1099 dyn_cast<ObjCMethodDecl>(copied_decl); 1100 1101 if (!copied_method_decl) 1102 continue; 1103 1104 LLDB_LOG(log, " CAS::FOMD found (in symbols)\n{0}", 1105 ClangUtil::DumpDecl(copied_method_decl)); 1106 1107 context.AddNamedDecl(copied_method_decl); 1108 } 1109 } 1110 1111 return; 1112 } 1113 1114 // Try the debug information. 1115 1116 do { 1117 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( 1118 const_cast<ObjCInterfaceDecl *>(interface_decl)); 1119 1120 if (!complete_interface_decl) 1121 break; 1122 1123 // We found the complete interface. The runtime never needs to be queried 1124 // in this scenario. 1125 1126 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl( 1127 complete_interface_decl); 1128 1129 if (complete_interface_decl == interface_decl) 1130 break; // already checked this one 1131 1132 LLDB_LOG(log, 1133 "CAS::FOPD trying origin " 1134 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", 1135 complete_interface_decl, &complete_iface_decl->getASTContext()); 1136 1137 FindObjCMethodDeclsWithOrigin(context, complete_interface_decl, 1138 "in debug info"); 1139 1140 return; 1141 } while (false); 1142 1143 do { 1144 // Check the modules only if the debug information didn't have a complete 1145 // interface. 1146 1147 if (std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor = 1148 GetClangModulesDeclVendor()) { 1149 ConstString interface_name(interface_decl->getNameAsString().c_str()); 1150 bool append = false; 1151 uint32_t max_matches = 1; 1152 std::vector<clang::NamedDecl *> decls; 1153 1154 if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches, 1155 decls)) 1156 break; 1157 1158 ObjCInterfaceDecl *interface_decl_from_modules = 1159 dyn_cast<ObjCInterfaceDecl>(decls[0]); 1160 1161 if (!interface_decl_from_modules) 1162 break; 1163 1164 if (FindObjCMethodDeclsWithOrigin(context, interface_decl_from_modules, 1165 "in modules")) 1166 return; 1167 } 1168 } while (false); 1169 1170 do { 1171 // Check the runtime only if the debug information didn't have a complete 1172 // interface and the modules don't get us anywhere. 1173 1174 lldb::ProcessSP process(m_target->GetProcessSP()); 1175 1176 if (!process) 1177 break; 1178 1179 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 1180 1181 if (!language_runtime) 1182 break; 1183 1184 DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 1185 1186 if (!decl_vendor) 1187 break; 1188 1189 ConstString interface_name(interface_decl->getNameAsString().c_str()); 1190 bool append = false; 1191 uint32_t max_matches = 1; 1192 std::vector<clang::NamedDecl *> decls; 1193 1194 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor); 1195 if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches, 1196 decls)) 1197 break; 1198 1199 ObjCInterfaceDecl *runtime_interface_decl = 1200 dyn_cast<ObjCInterfaceDecl>(decls[0]); 1201 1202 if (!runtime_interface_decl) 1203 break; 1204 1205 FindObjCMethodDeclsWithOrigin(context, runtime_interface_decl, 1206 "in runtime"); 1207 } while (false); 1208 } 1209 1210 static bool FindObjCPropertyAndIvarDeclsWithOrigin( 1211 NameSearchContext &context, ClangASTSource &source, 1212 DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) { 1213 Log *log = GetLog(LLDBLog::Expressions); 1214 1215 if (origin_iface_decl.IsInvalid()) 1216 return false; 1217 1218 std::string name_str = context.m_decl_name.getAsString(); 1219 StringRef name(name_str); 1220 IdentifierInfo &name_identifier( 1221 origin_iface_decl->getASTContext().Idents.get(name)); 1222 1223 DeclFromUser<ObjCPropertyDecl> origin_property_decl( 1224 origin_iface_decl->FindPropertyDeclaration( 1225 &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance)); 1226 1227 bool found = false; 1228 1229 if (origin_property_decl.IsValid()) { 1230 DeclFromParser<ObjCPropertyDecl> parser_property_decl( 1231 origin_property_decl.Import(source)); 1232 if (parser_property_decl.IsValid()) { 1233 LLDB_LOG(log, " CAS::FOPD found\n{0}", 1234 ClangUtil::DumpDecl(parser_property_decl.decl)); 1235 1236 context.AddNamedDecl(parser_property_decl.decl); 1237 found = true; 1238 } 1239 } 1240 1241 DeclFromUser<ObjCIvarDecl> origin_ivar_decl( 1242 origin_iface_decl->getIvarDecl(&name_identifier)); 1243 1244 if (origin_ivar_decl.IsValid()) { 1245 DeclFromParser<ObjCIvarDecl> parser_ivar_decl( 1246 origin_ivar_decl.Import(source)); 1247 if (parser_ivar_decl.IsValid()) { 1248 LLDB_LOG(log, " CAS::FOPD found\n{0}", 1249 ClangUtil::DumpDecl(parser_ivar_decl.decl)); 1250 1251 context.AddNamedDecl(parser_ivar_decl.decl); 1252 found = true; 1253 } 1254 } 1255 1256 return found; 1257 } 1258 1259 void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) { 1260 Log *log = GetLog(LLDBLog::Expressions); 1261 1262 DeclFromParser<const ObjCInterfaceDecl> parser_iface_decl( 1263 cast<ObjCInterfaceDecl>(context.m_decl_context)); 1264 DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl( 1265 parser_iface_decl.GetOrigin(*this)); 1266 1267 ConstString class_name(parser_iface_decl->getNameAsString().c_str()); 1268 1269 LLDB_LOG(log, 1270 "ClangASTSource::FindObjCPropertyAndIvarDecls on " 1271 "(ASTContext*){0} '{1}' for '{2}.{3}'", 1272 m_ast_context, m_clang_ast_context->getDisplayName(), 1273 parser_iface_decl->getName(), context.m_decl_name.getAsString()); 1274 1275 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, origin_iface_decl)) 1276 return; 1277 1278 LLDB_LOG(log, 1279 "CAS::FOPD couldn't find the property on origin " 1280 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}, searching " 1281 "elsewhere...", 1282 origin_iface_decl.decl, &origin_iface_decl->getASTContext()); 1283 1284 SymbolContext null_sc; 1285 TypeList type_list; 1286 1287 do { 1288 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( 1289 const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl)); 1290 1291 if (!complete_interface_decl) 1292 break; 1293 1294 // We found the complete interface. The runtime never needs to be queried 1295 // in this scenario. 1296 1297 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl( 1298 complete_interface_decl); 1299 1300 if (complete_iface_decl.decl == origin_iface_decl.decl) 1301 break; // already checked this one 1302 1303 LLDB_LOG(log, 1304 "CAS::FOPD trying origin " 1305 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", 1306 complete_iface_decl.decl, &complete_iface_decl->getASTContext()); 1307 1308 FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, complete_iface_decl); 1309 1310 return; 1311 } while (false); 1312 1313 do { 1314 // Check the modules only if the debug information didn't have a complete 1315 // interface. 1316 1317 std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor = 1318 GetClangModulesDeclVendor(); 1319 1320 if (!modules_decl_vendor) 1321 break; 1322 1323 bool append = false; 1324 uint32_t max_matches = 1; 1325 std::vector<clang::NamedDecl *> decls; 1326 1327 if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls)) 1328 break; 1329 1330 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules( 1331 dyn_cast<ObjCInterfaceDecl>(decls[0])); 1332 1333 if (!interface_decl_from_modules.IsValid()) 1334 break; 1335 1336 LLDB_LOG(log, 1337 "CAS::FOPD[{0}] trying module " 1338 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", 1339 interface_decl_from_modules.decl, 1340 &interface_decl_from_modules->getASTContext()); 1341 1342 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, 1343 interface_decl_from_modules)) 1344 return; 1345 } while (false); 1346 1347 do { 1348 // Check the runtime only if the debug information didn't have a complete 1349 // interface and nothing was in the modules. 1350 1351 lldb::ProcessSP process(m_target->GetProcessSP()); 1352 1353 if (!process) 1354 return; 1355 1356 ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process)); 1357 1358 if (!language_runtime) 1359 return; 1360 1361 DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 1362 1363 if (!decl_vendor) 1364 break; 1365 1366 bool append = false; 1367 uint32_t max_matches = 1; 1368 std::vector<clang::NamedDecl *> decls; 1369 1370 auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor); 1371 if (!clang_decl_vendor->FindDecls(class_name, append, max_matches, decls)) 1372 break; 1373 1374 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime( 1375 dyn_cast<ObjCInterfaceDecl>(decls[0])); 1376 1377 if (!interface_decl_from_runtime.IsValid()) 1378 break; 1379 1380 LLDB_LOG(log, 1381 "CAS::FOPD[{0}] trying runtime " 1382 "(ObjCInterfaceDecl*){0}/(ASTContext*){1}...", 1383 interface_decl_from_runtime.decl, 1384 &interface_decl_from_runtime->getASTContext()); 1385 1386 if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, 1387 interface_decl_from_runtime)) 1388 return; 1389 } while (false); 1390 } 1391 1392 void ClangASTSource::LookupInNamespace(NameSearchContext &context) { 1393 const NamespaceDecl *namespace_context = 1394 dyn_cast<NamespaceDecl>(context.m_decl_context); 1395 1396 Log *log = GetLog(LLDBLog::Expressions); 1397 1398 ClangASTImporter::NamespaceMapSP namespace_map = 1399 m_ast_importer_sp->GetNamespaceMap(namespace_context); 1400 1401 LLDB_LOGV(log, " CAS::FEVD Inspecting namespace map {0} ({1} entries)", 1402 namespace_map.get(), namespace_map->size()); 1403 1404 if (!namespace_map) 1405 return; 1406 1407 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), 1408 e = namespace_map->end(); 1409 i != e; ++i) { 1410 LLDB_LOG(log, " CAS::FEVD Searching namespace {0} in module {1}", 1411 i->second.GetName(), i->first->GetFileSpec().GetFilename()); 1412 1413 FindExternalVisibleDecls(context, i->first, i->second); 1414 } 1415 } 1416 1417 typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap; 1418 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap; 1419 1420 template <class D, class O> 1421 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map, 1422 llvm::DenseMap<const D *, O> &source_map, 1423 ClangASTSource &source) { 1424 // When importing fields into a new record, clang has a hard requirement that 1425 // fields be imported in field offset order. Since they are stored in a 1426 // DenseMap with a pointer as the key type, this means we cannot simply 1427 // iterate over the map, as the order will be non-deterministic. Instead we 1428 // have to sort by the offset and then insert in sorted order. 1429 typedef llvm::DenseMap<const D *, O> MapType; 1430 typedef typename MapType::value_type PairType; 1431 std::vector<PairType> sorted_items; 1432 sorted_items.reserve(source_map.size()); 1433 sorted_items.assign(source_map.begin(), source_map.end()); 1434 llvm::sort(sorted_items, llvm::less_second()); 1435 1436 for (const auto &item : sorted_items) { 1437 DeclFromUser<D> user_decl(const_cast<D *>(item.first)); 1438 DeclFromParser<D> parser_decl(user_decl.Import(source)); 1439 if (parser_decl.IsInvalid()) 1440 return false; 1441 destination_map.insert( 1442 std::pair<const D *, O>(parser_decl.decl, item.second)); 1443 } 1444 1445 return true; 1446 } 1447 1448 template <bool IsVirtual> 1449 bool ExtractBaseOffsets(const ASTRecordLayout &record_layout, 1450 DeclFromUser<const CXXRecordDecl> &record, 1451 BaseOffsetMap &base_offsets) { 1452 for (CXXRecordDecl::base_class_const_iterator 1453 bi = (IsVirtual ? record->vbases_begin() : record->bases_begin()), 1454 be = (IsVirtual ? record->vbases_end() : record->bases_end()); 1455 bi != be; ++bi) { 1456 if (!IsVirtual && bi->isVirtual()) 1457 continue; 1458 1459 const clang::Type *origin_base_type = bi->getType().getTypePtr(); 1460 const clang::RecordType *origin_base_record_type = 1461 origin_base_type->getAs<RecordType>(); 1462 1463 if (!origin_base_record_type) 1464 return false; 1465 1466 DeclFromUser<RecordDecl> origin_base_record( 1467 origin_base_record_type->getDecl()); 1468 1469 if (origin_base_record.IsInvalid()) 1470 return false; 1471 1472 DeclFromUser<CXXRecordDecl> origin_base_cxx_record( 1473 DynCast<CXXRecordDecl>(origin_base_record)); 1474 1475 if (origin_base_cxx_record.IsInvalid()) 1476 return false; 1477 1478 CharUnits base_offset; 1479 1480 if (IsVirtual) 1481 base_offset = 1482 record_layout.getVBaseClassOffset(origin_base_cxx_record.decl); 1483 else 1484 base_offset = 1485 record_layout.getBaseClassOffset(origin_base_cxx_record.decl); 1486 1487 base_offsets.insert(std::pair<const CXXRecordDecl *, CharUnits>( 1488 origin_base_cxx_record.decl, base_offset)); 1489 } 1490 1491 return true; 1492 } 1493 1494 bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size, 1495 uint64_t &alignment, 1496 FieldOffsetMap &field_offsets, 1497 BaseOffsetMap &base_offsets, 1498 BaseOffsetMap &virtual_base_offsets) { 1499 1500 Log *log = GetLog(LLDBLog::Expressions); 1501 1502 LLDB_LOG(log, 1503 "LayoutRecordType on (ASTContext*){0} '{1}' for (RecordDecl*)" 1504 "{2} [name = '{3}']", 1505 m_ast_context, m_clang_ast_context->getDisplayName(), record, 1506 record->getName()); 1507 1508 DeclFromParser<const RecordDecl> parser_record(record); 1509 DeclFromUser<const RecordDecl> origin_record( 1510 parser_record.GetOrigin(*this)); 1511 1512 if (origin_record.IsInvalid()) 1513 return false; 1514 1515 FieldOffsetMap origin_field_offsets; 1516 BaseOffsetMap origin_base_offsets; 1517 BaseOffsetMap origin_virtual_base_offsets; 1518 1519 TypeSystemClang::GetCompleteDecl( 1520 &origin_record->getASTContext(), 1521 const_cast<RecordDecl *>(origin_record.decl)); 1522 1523 clang::RecordDecl *definition = origin_record.decl->getDefinition(); 1524 if (!definition || !definition->isCompleteDefinition()) 1525 return false; 1526 1527 const ASTRecordLayout &record_layout( 1528 origin_record->getASTContext().getASTRecordLayout(origin_record.decl)); 1529 1530 int field_idx = 0, field_count = record_layout.getFieldCount(); 1531 1532 for (RecordDecl::field_iterator fi = origin_record->field_begin(), 1533 fe = origin_record->field_end(); 1534 fi != fe; ++fi) { 1535 if (field_idx >= field_count) 1536 return false; // Layout didn't go well. Bail out. 1537 1538 uint64_t field_offset = record_layout.getFieldOffset(field_idx); 1539 1540 origin_field_offsets.insert( 1541 std::pair<const FieldDecl *, uint64_t>(*fi, field_offset)); 1542 1543 field_idx++; 1544 } 1545 1546 lldbassert(&record->getASTContext() == m_ast_context); 1547 1548 DeclFromUser<const CXXRecordDecl> origin_cxx_record( 1549 DynCast<const CXXRecordDecl>(origin_record)); 1550 1551 if (origin_cxx_record.IsValid()) { 1552 if (!ExtractBaseOffsets<false>(record_layout, origin_cxx_record, 1553 origin_base_offsets) || 1554 !ExtractBaseOffsets<true>(record_layout, origin_cxx_record, 1555 origin_virtual_base_offsets)) 1556 return false; 1557 } 1558 1559 if (!ImportOffsetMap(field_offsets, origin_field_offsets, *this) || 1560 !ImportOffsetMap(base_offsets, origin_base_offsets, *this) || 1561 !ImportOffsetMap(virtual_base_offsets, origin_virtual_base_offsets, 1562 *this)) 1563 return false; 1564 1565 size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth(); 1566 alignment = record_layout.getAlignment().getQuantity() * 1567 m_ast_context->getCharWidth(); 1568 1569 if (log) { 1570 LLDB_LOG(log, "LRT returned:"); 1571 LLDB_LOG(log, "LRT Original = (RecordDecl*){0}", 1572 static_cast<const void *>(origin_record.decl)); 1573 LLDB_LOG(log, "LRT Size = {0}", size); 1574 LLDB_LOG(log, "LRT Alignment = {0}", alignment); 1575 LLDB_LOG(log, "LRT Fields:"); 1576 for (RecordDecl::field_iterator fi = record->field_begin(), 1577 fe = record->field_end(); 1578 fi != fe; ++fi) { 1579 LLDB_LOG(log, 1580 "LRT (FieldDecl*){0}, Name = '{1}', Type = '{2}', Offset = " 1581 "{3} bits", 1582 *fi, fi->getName(), fi->getType().getAsString(), 1583 field_offsets[*fi]); 1584 } 1585 DeclFromParser<const CXXRecordDecl> parser_cxx_record = 1586 DynCast<const CXXRecordDecl>(parser_record); 1587 if (parser_cxx_record.IsValid()) { 1588 LLDB_LOG(log, "LRT Bases:"); 1589 for (CXXRecordDecl::base_class_const_iterator 1590 bi = parser_cxx_record->bases_begin(), 1591 be = parser_cxx_record->bases_end(); 1592 bi != be; ++bi) { 1593 bool is_virtual = bi->isVirtual(); 1594 1595 QualType base_type = bi->getType(); 1596 const RecordType *base_record_type = base_type->getAs<RecordType>(); 1597 DeclFromParser<RecordDecl> base_record(base_record_type->getDecl()); 1598 DeclFromParser<CXXRecordDecl> base_cxx_record = 1599 DynCast<CXXRecordDecl>(base_record); 1600 1601 LLDB_LOG(log, 1602 "LRT {0}(CXXRecordDecl*){1}, Name = '{2}', Offset = " 1603 "{3} chars", 1604 (is_virtual ? "Virtual " : ""), base_cxx_record.decl, 1605 base_cxx_record.decl->getName(), 1606 (is_virtual 1607 ? virtual_base_offsets[base_cxx_record.decl].getQuantity() 1608 : base_offsets[base_cxx_record.decl].getQuantity())); 1609 } 1610 } else { 1611 LLDB_LOG(log, "LRD Not a CXXRecord, so no bases"); 1612 } 1613 } 1614 1615 return true; 1616 } 1617 1618 void ClangASTSource::CompleteNamespaceMap( 1619 ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name, 1620 ClangASTImporter::NamespaceMapSP &parent_map) const { 1621 1622 Log *log = GetLog(LLDBLog::Expressions); 1623 1624 if (log) { 1625 if (parent_map && parent_map->size()) 1626 LLDB_LOG(log, 1627 "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching " 1628 "for namespace {2} in namespace {3}", 1629 m_ast_context, m_clang_ast_context->getDisplayName(), name, 1630 parent_map->begin()->second.GetName()); 1631 else 1632 LLDB_LOG(log, 1633 "CompleteNamespaceMap on (ASTContext*){0} '{1}' Searching " 1634 "for namespace {2}", 1635 m_ast_context, m_clang_ast_context->getDisplayName(), name); 1636 } 1637 1638 if (parent_map) { 1639 for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(), 1640 e = parent_map->end(); 1641 i != e; ++i) { 1642 CompilerDeclContext found_namespace_decl; 1643 1644 lldb::ModuleSP module_sp = i->first; 1645 CompilerDeclContext module_parent_namespace_decl = i->second; 1646 1647 SymbolFile *symbol_file = module_sp->GetSymbolFile(); 1648 1649 if (!symbol_file) 1650 continue; 1651 1652 found_namespace_decl = 1653 symbol_file->FindNamespace(name, module_parent_namespace_decl); 1654 1655 if (!found_namespace_decl) 1656 continue; 1657 1658 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>( 1659 module_sp, found_namespace_decl)); 1660 1661 LLDB_LOG(log, " CMN Found namespace {0} in module {1}", name, 1662 module_sp->GetFileSpec().GetFilename()); 1663 } 1664 } else { 1665 CompilerDeclContext null_namespace_decl; 1666 for (lldb::ModuleSP image : m_target->GetImages().Modules()) { 1667 if (!image) 1668 continue; 1669 1670 CompilerDeclContext found_namespace_decl; 1671 1672 SymbolFile *symbol_file = image->GetSymbolFile(); 1673 1674 if (!symbol_file) 1675 continue; 1676 1677 found_namespace_decl = 1678 symbol_file->FindNamespace(name, null_namespace_decl); 1679 1680 if (!found_namespace_decl) 1681 continue; 1682 1683 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>( 1684 image, found_namespace_decl)); 1685 1686 LLDB_LOG(log, " CMN[{0}] Found namespace {0} in module {1}", name, 1687 image->GetFileSpec().GetFilename()); 1688 } 1689 } 1690 } 1691 1692 NamespaceDecl *ClangASTSource::AddNamespace( 1693 NameSearchContext &context, 1694 ClangASTImporter::NamespaceMapSP &namespace_decls) { 1695 if (!namespace_decls) 1696 return nullptr; 1697 1698 const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second; 1699 1700 clang::ASTContext *src_ast = 1701 TypeSystemClang::DeclContextGetTypeSystemClang(namespace_decl); 1702 if (!src_ast) 1703 return nullptr; 1704 clang::NamespaceDecl *src_namespace_decl = 1705 TypeSystemClang::DeclContextGetAsNamespaceDecl(namespace_decl); 1706 1707 if (!src_namespace_decl) 1708 return nullptr; 1709 1710 Decl *copied_decl = CopyDecl(src_namespace_decl); 1711 1712 if (!copied_decl) 1713 return nullptr; 1714 1715 NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl); 1716 1717 if (!copied_namespace_decl) 1718 return nullptr; 1719 1720 context.m_decls.push_back(copied_namespace_decl); 1721 1722 m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl, 1723 namespace_decls); 1724 1725 return dyn_cast<NamespaceDecl>(copied_decl); 1726 } 1727 1728 clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) { 1729 return m_ast_importer_sp->CopyDecl(m_ast_context, src_decl); 1730 } 1731 1732 ClangASTImporter::DeclOrigin ClangASTSource::GetDeclOrigin(const clang::Decl *decl) { 1733 return m_ast_importer_sp->GetDeclOrigin(decl); 1734 } 1735 1736 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) { 1737 auto ts = src_type.GetTypeSystem(); 1738 auto src_ast = ts.dyn_cast_or_null<TypeSystemClang>(); 1739 if (!src_ast) 1740 return {}; 1741 1742 QualType copied_qual_type = ClangUtil::GetQualType( 1743 m_ast_importer_sp->CopyType(*m_clang_ast_context, src_type)); 1744 1745 if (copied_qual_type.getAsOpaquePtr() && 1746 copied_qual_type->getCanonicalTypeInternal().isNull()) 1747 // this shouldn't happen, but we're hardening because the AST importer 1748 // seems to be generating bad types on occasion. 1749 return {}; 1750 1751 return m_clang_ast_context->GetType(copied_qual_type); 1752 } 1753 1754 std::shared_ptr<ClangModulesDeclVendor> 1755 ClangASTSource::GetClangModulesDeclVendor() { 1756 auto persistent_vars = llvm::cast<ClangPersistentVariables>( 1757 m_target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC)); 1758 return persistent_vars->GetClangModulesDeclVendor(); 1759 } 1760