1 //===-- ClangASTSource.cpp ---------------------------------------*- C++-*-===// 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 "ASTDumper.h" 12 #include "ClangModulesDeclVendor.h" 13 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/ModuleList.h" 16 #include "lldb/Symbol/ClangASTContext.h" 17 #include "lldb/Symbol/ClangUtil.h" 18 #include "lldb/Symbol/CompilerDeclContext.h" 19 #include "lldb/Symbol/Function.h" 20 #include "lldb/Symbol/SymbolFile.h" 21 #include "lldb/Symbol/SymbolVendor.h" 22 #include "lldb/Symbol/TaggedASTType.h" 23 #include "lldb/Target/ObjCLanguageRuntime.h" 24 #include "lldb/Target/Target.h" 25 #include "lldb/Utility/Log.h" 26 #include "clang/AST/ASTContext.h" 27 #include "clang/AST/RecordLayout.h" 28 29 #include <memory> 30 #include <vector> 31 32 using namespace clang; 33 using namespace lldb_private; 34 35 //------------------------------------------------------------------ 36 // Scoped class that will remove an active lexical decl from the set when it 37 // goes out of scope. 38 //------------------------------------------------------------------ 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(const lldb::TargetSP &target) 55 : m_import_in_progress(false), m_lookups_enabled(false), m_target(target), 56 m_ast_context(NULL), m_active_lexical_decls(), m_active_lookups() { 57 if (!target->GetUseModernTypeLookup()) { 58 m_ast_importer_sp = m_target->GetClangASTImporter(); 59 } 60 } 61 62 void ClangASTSource::InstallASTContext(clang::ASTContext &ast_context, 63 clang::FileManager &file_manager, 64 bool is_shared_context) { 65 m_ast_context = &ast_context; 66 m_file_manager = &file_manager; 67 if (m_target->GetUseModernTypeLookup()) { 68 // Configure the ExternalASTMerger. The merger needs to be able to import 69 // types from any source that we would do lookups in, which includes the 70 // persistent AST context as well as the modules and Objective-C runtime 71 // AST contexts. 72 73 lldbassert(!m_merger_up); 74 clang::ExternalASTMerger::ImporterTarget target = {ast_context, 75 file_manager}; 76 std::vector<clang::ExternalASTMerger::ImporterSource> sources; 77 for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) { 78 if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>( 79 module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC))) { 80 lldbassert(module_ast_ctx->getASTContext()); 81 lldbassert(module_ast_ctx->getFileManager()); 82 sources.push_back({*module_ast_ctx->getASTContext(), 83 *module_ast_ctx->getFileManager(), 84 module_ast_ctx->GetOriginMap() 85 }); 86 } 87 } 88 89 do { 90 lldb::ProcessSP process(m_target->GetProcessSP()); 91 92 if (!process) 93 break; 94 95 ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime()); 96 97 if (!language_runtime) 98 break; 99 100 DeclVendor *runtime_decl_vendor = language_runtime->GetDeclVendor(); 101 102 if (!runtime_decl_vendor) 103 break; 104 105 sources.push_back(runtime_decl_vendor->GetImporterSource()); 106 } while (0); 107 108 do { 109 DeclVendor *modules_decl_vendor = 110 m_target->GetClangModulesDeclVendor(); 111 112 if (!modules_decl_vendor) 113 break; 114 115 sources.push_back(modules_decl_vendor->GetImporterSource()); 116 } while (0); 117 118 if (!is_shared_context) { 119 // Update the scratch AST context's merger to reflect any new sources we 120 // might have come across since the last time an expression was parsed. 121 122 auto scratch_ast_context = static_cast<ClangASTContextForExpressions*>( 123 m_target->GetScratchClangASTContext()); 124 125 scratch_ast_context->GetMergerUnchecked().AddSources(sources); 126 127 sources.push_back({*scratch_ast_context->getASTContext(), 128 *scratch_ast_context->getFileManager(), 129 scratch_ast_context->GetOriginMap()}); 130 } while (0); 131 132 m_merger_up = 133 llvm::make_unique<clang::ExternalASTMerger>(target, sources); 134 } else { 135 m_ast_importer_sp->InstallMapCompleter(&ast_context, *this); 136 } 137 } 138 139 ClangASTSource::~ClangASTSource() { 140 if (m_ast_importer_sp) 141 m_ast_importer_sp->ForgetDestination(m_ast_context); 142 143 // We are in the process of destruction, don't create clang ast context on 144 // demand by passing false to 145 // Target::GetScratchClangASTContext(create_on_demand). 146 ClangASTContext *scratch_clang_ast_context = 147 m_target->GetScratchClangASTContext(false); 148 149 if (!scratch_clang_ast_context) 150 return; 151 152 clang::ASTContext *scratch_ast_context = 153 scratch_clang_ast_context->getASTContext(); 154 155 if (!scratch_ast_context) 156 return; 157 158 if (m_ast_context != scratch_ast_context && m_ast_importer_sp) 159 m_ast_importer_sp->ForgetSource(scratch_ast_context, m_ast_context); 160 } 161 162 void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) { 163 if (!m_ast_context) 164 return; 165 166 m_ast_context->getTranslationUnitDecl()->setHasExternalVisibleStorage(); 167 m_ast_context->getTranslationUnitDecl()->setHasExternalLexicalStorage(); 168 } 169 170 // The core lookup interface. 171 bool ClangASTSource::FindExternalVisibleDeclsByName( 172 const DeclContext *decl_ctx, DeclarationName clang_decl_name) { 173 if (!m_ast_context) { 174 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 175 return false; 176 } 177 178 if (GetImportInProgress()) { 179 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 180 return false; 181 } 182 183 std::string decl_name(clang_decl_name.getAsString()); 184 185 // if (m_decl_map.DoingASTImport ()) 186 // return DeclContext::lookup_result(); 187 // 188 switch (clang_decl_name.getNameKind()) { 189 // Normal identifiers. 190 case DeclarationName::Identifier: { 191 clang::IdentifierInfo *identifier_info = 192 clang_decl_name.getAsIdentifierInfo(); 193 194 if (!identifier_info || identifier_info->getBuiltinID() != 0) { 195 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 196 return false; 197 } 198 } break; 199 200 // Operator names. 201 case DeclarationName::CXXOperatorName: 202 case DeclarationName::CXXLiteralOperatorName: 203 break; 204 205 // Using directives found in this context. 206 // Tell Sema we didn't find any or we'll end up getting asked a *lot*. 207 case DeclarationName::CXXUsingDirective: 208 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 209 return false; 210 211 case DeclarationName::ObjCZeroArgSelector: 212 case DeclarationName::ObjCOneArgSelector: 213 case DeclarationName::ObjCMultiArgSelector: { 214 llvm::SmallVector<NamedDecl *, 1> method_decls; 215 216 NameSearchContext method_search_context(*this, method_decls, 217 clang_decl_name, decl_ctx); 218 219 FindObjCMethodDecls(method_search_context); 220 221 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, method_decls); 222 return (method_decls.size() > 0); 223 } 224 // These aren't possible in the global context. 225 case DeclarationName::CXXConstructorName: 226 case DeclarationName::CXXDestructorName: 227 case DeclarationName::CXXConversionFunctionName: 228 case DeclarationName::CXXDeductionGuideName: 229 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 230 return false; 231 } 232 233 if (!GetLookupsEnabled()) { 234 // Wait until we see a '$' at the start of a name before we start doing any 235 // lookups so we can avoid lookup up all of the builtin types. 236 if (!decl_name.empty() && decl_name[0] == '$') { 237 SetLookupsEnabled(true); 238 } else { 239 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 240 return false; 241 } 242 } 243 244 ConstString const_decl_name(decl_name.c_str()); 245 246 const char *uniqued_const_decl_name = const_decl_name.GetCString(); 247 if (m_active_lookups.find(uniqued_const_decl_name) != 248 m_active_lookups.end()) { 249 // We are currently looking up this name... 250 SetNoExternalVisibleDeclsForName(decl_ctx, clang_decl_name); 251 return false; 252 } 253 m_active_lookups.insert(uniqued_const_decl_name); 254 // static uint32_t g_depth = 0; 255 // ++g_depth; 256 // printf("[%5u] FindExternalVisibleDeclsByName() \"%s\"\n", g_depth, 257 // uniqued_const_decl_name); 258 llvm::SmallVector<NamedDecl *, 4> name_decls; 259 NameSearchContext name_search_context(*this, name_decls, clang_decl_name, 260 decl_ctx); 261 FindExternalVisibleDecls(name_search_context); 262 SetExternalVisibleDeclsForName(decl_ctx, clang_decl_name, name_decls); 263 // --g_depth; 264 m_active_lookups.erase(uniqued_const_decl_name); 265 return (name_decls.size() != 0); 266 } 267 268 void ClangASTSource::CompleteType(TagDecl *tag_decl) { 269 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 270 271 static unsigned int invocation_id = 0; 272 unsigned int current_id = invocation_id++; 273 274 if (log) { 275 log->Printf(" CompleteTagDecl[%u] on (ASTContext*)%p Completing " 276 "(TagDecl*)%p named %s", 277 current_id, static_cast<void *>(m_ast_context), 278 static_cast<void *>(tag_decl), 279 tag_decl->getName().str().c_str()); 280 281 log->Printf(" CTD[%u] Before:", current_id); 282 ASTDumper dumper((Decl *)tag_decl); 283 dumper.ToLog(log, " [CTD] "); 284 } 285 286 auto iter = m_active_lexical_decls.find(tag_decl); 287 if (iter != m_active_lexical_decls.end()) 288 return; 289 m_active_lexical_decls.insert(tag_decl); 290 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl); 291 292 if (!m_ast_importer_sp) { 293 if (HasMerger()) { 294 GetMergerUnchecked().CompleteType(tag_decl); 295 } 296 return; 297 } 298 299 if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) { 300 // We couldn't complete the type. Maybe there's a definition somewhere 301 // else that can be completed. 302 303 if (log) 304 log->Printf(" CTD[%u] Type could not be completed in the module in " 305 "which it was first found.", 306 current_id); 307 308 bool found = false; 309 310 DeclContext *decl_ctx = tag_decl->getDeclContext(); 311 312 if (const NamespaceDecl *namespace_context = 313 dyn_cast<NamespaceDecl>(decl_ctx)) { 314 ClangASTImporter::NamespaceMapSP namespace_map = 315 m_ast_importer_sp->GetNamespaceMap(namespace_context); 316 317 if (log && log->GetVerbose()) 318 log->Printf(" CTD[%u] Inspecting namespace map %p (%d entries)", 319 current_id, static_cast<void *>(namespace_map.get()), 320 static_cast<int>(namespace_map->size())); 321 322 if (!namespace_map) 323 return; 324 325 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), 326 e = namespace_map->end(); 327 i != e && !found; ++i) { 328 if (log) 329 log->Printf(" CTD[%u] Searching namespace %s in module %s", 330 current_id, i->second.GetName().AsCString(), 331 i->first->GetFileSpec().GetFilename().GetCString()); 332 333 TypeList types; 334 335 ConstString name(tag_decl->getName().str().c_str()); 336 337 i->first->FindTypesInNamespace(name, &i->second, UINT32_MAX, types); 338 339 for (uint32_t ti = 0, te = types.GetSize(); ti != te && !found; ++ti) { 340 lldb::TypeSP type = types.GetTypeAtIndex(ti); 341 342 if (!type) 343 continue; 344 345 CompilerType clang_type(type->GetFullCompilerType()); 346 347 if (!ClangUtil::IsClangType(clang_type)) 348 continue; 349 350 const TagType *tag_type = 351 ClangUtil::GetQualType(clang_type)->getAs<TagType>(); 352 353 if (!tag_type) 354 continue; 355 356 TagDecl *candidate_tag_decl = 357 const_cast<TagDecl *>(tag_type->getDecl()); 358 359 if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, 360 candidate_tag_decl)) 361 found = true; 362 } 363 } 364 } else { 365 TypeList types; 366 367 ConstString name(tag_decl->getName().str().c_str()); 368 CompilerDeclContext namespace_decl; 369 370 const ModuleList &module_list = m_target->GetImages(); 371 372 bool exact_match = false; 373 llvm::DenseSet<SymbolFile *> searched_symbol_files; 374 module_list.FindTypes(nullptr, name, exact_match, UINT32_MAX, 375 searched_symbol_files, types); 376 377 for (uint32_t ti = 0, te = types.GetSize(); ti != te && !found; ++ti) { 378 lldb::TypeSP type = types.GetTypeAtIndex(ti); 379 380 if (!type) 381 continue; 382 383 CompilerType clang_type(type->GetFullCompilerType()); 384 385 if (!ClangUtil::IsClangType(clang_type)) 386 continue; 387 388 const TagType *tag_type = 389 ClangUtil::GetQualType(clang_type)->getAs<TagType>(); 390 391 if (!tag_type) 392 continue; 393 394 TagDecl *candidate_tag_decl = 395 const_cast<TagDecl *>(tag_type->getDecl()); 396 397 // We have found a type by basename and we need to make sure the decl 398 // contexts are the same before we can try to complete this type with 399 // another 400 if (!ClangASTContext::DeclsAreEquivalent(tag_decl, candidate_tag_decl)) 401 continue; 402 403 if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl, 404 candidate_tag_decl)) 405 found = true; 406 } 407 } 408 } 409 410 if (log) { 411 log->Printf(" [CTD] After:"); 412 ASTDumper dumper((Decl *)tag_decl); 413 dumper.ToLog(log, " [CTD] "); 414 } 415 } 416 417 void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) { 418 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 419 420 if (log) { 421 log->Printf(" [CompleteObjCInterfaceDecl] on (ASTContext*)%p Completing " 422 "an ObjCInterfaceDecl named %s", 423 static_cast<void *>(m_ast_context), 424 interface_decl->getName().str().c_str()); 425 log->Printf(" [COID] Before:"); 426 ASTDumper dumper((Decl *)interface_decl); 427 dumper.ToLog(log, " [COID] "); 428 } 429 430 if (!m_ast_importer_sp) { 431 if (HasMerger()) { 432 ObjCInterfaceDecl *complete_iface_decl = 433 GetCompleteObjCInterface(interface_decl); 434 435 if (complete_iface_decl && (complete_iface_decl != interface_decl)) { 436 m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()}); 437 } 438 439 GetMergerUnchecked().CompleteType(interface_decl); 440 } else { 441 lldbassert(0 && "No mechanism for completing a type!"); 442 } 443 return; 444 } 445 446 Decl *original_decl = NULL; 447 ASTContext *original_ctx = NULL; 448 449 if (m_ast_importer_sp->ResolveDeclOrigin(interface_decl, &original_decl, 450 &original_ctx)) { 451 if (ObjCInterfaceDecl *original_iface_decl = 452 dyn_cast<ObjCInterfaceDecl>(original_decl)) { 453 ObjCInterfaceDecl *complete_iface_decl = 454 GetCompleteObjCInterface(original_iface_decl); 455 456 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { 457 m_ast_importer_sp->SetDeclOrigin(interface_decl, complete_iface_decl); 458 } 459 } 460 } 461 462 m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl); 463 464 if (interface_decl->getSuperClass() && 465 interface_decl->getSuperClass() != interface_decl) 466 CompleteType(interface_decl->getSuperClass()); 467 468 if (log) { 469 log->Printf(" [COID] After:"); 470 ASTDumper dumper((Decl *)interface_decl); 471 dumper.ToLog(log, " [COID] "); 472 } 473 } 474 475 clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface( 476 const clang::ObjCInterfaceDecl *interface_decl) { 477 lldb::ProcessSP process(m_target->GetProcessSP()); 478 479 if (!process) 480 return NULL; 481 482 ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime()); 483 484 if (!language_runtime) 485 return NULL; 486 487 ConstString class_name(interface_decl->getNameAsString().c_str()); 488 489 lldb::TypeSP complete_type_sp( 490 language_runtime->LookupInCompleteClassCache(class_name)); 491 492 if (!complete_type_sp) 493 return NULL; 494 495 TypeFromUser complete_type = 496 TypeFromUser(complete_type_sp->GetFullCompilerType()); 497 lldb::opaque_compiler_type_t complete_opaque_type = 498 complete_type.GetOpaqueQualType(); 499 500 if (!complete_opaque_type) 501 return NULL; 502 503 const clang::Type *complete_clang_type = 504 QualType::getFromOpaquePtr(complete_opaque_type).getTypePtr(); 505 const ObjCInterfaceType *complete_interface_type = 506 dyn_cast<ObjCInterfaceType>(complete_clang_type); 507 508 if (!complete_interface_type) 509 return NULL; 510 511 ObjCInterfaceDecl *complete_iface_decl(complete_interface_type->getDecl()); 512 513 return complete_iface_decl; 514 } 515 516 void ClangASTSource::FindExternalLexicalDecls( 517 const DeclContext *decl_context, 518 llvm::function_ref<bool(Decl::Kind)> predicate, 519 llvm::SmallVectorImpl<Decl *> &decls) { 520 521 if (HasMerger()) { 522 if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl_context)) { 523 ObjCInterfaceDecl *complete_iface_decl = 524 GetCompleteObjCInterface(interface_decl); 525 526 if (complete_iface_decl && (complete_iface_decl != interface_decl)) { 527 m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()}); 528 } 529 } 530 return GetMergerUnchecked().FindExternalLexicalDecls(decl_context, 531 predicate, 532 decls); 533 } else if (!m_ast_importer_sp) 534 return; 535 536 ClangASTMetrics::RegisterLexicalQuery(); 537 538 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 539 540 const Decl *context_decl = dyn_cast<Decl>(decl_context); 541 542 if (!context_decl) 543 return; 544 545 auto iter = m_active_lexical_decls.find(context_decl); 546 if (iter != m_active_lexical_decls.end()) 547 return; 548 m_active_lexical_decls.insert(context_decl); 549 ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl); 550 551 static unsigned int invocation_id = 0; 552 unsigned int current_id = invocation_id++; 553 554 if (log) { 555 if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl)) 556 log->Printf( 557 "FindExternalLexicalDecls[%u] on (ASTContext*)%p in '%s' (%sDecl*)%p", 558 current_id, static_cast<void *>(m_ast_context), 559 context_named_decl->getNameAsString().c_str(), 560 context_decl->getDeclKindName(), 561 static_cast<const void *>(context_decl)); 562 else if (context_decl) 563 log->Printf( 564 "FindExternalLexicalDecls[%u] on (ASTContext*)%p in (%sDecl*)%p", 565 current_id, static_cast<void *>(m_ast_context), 566 context_decl->getDeclKindName(), 567 static_cast<const void *>(context_decl)); 568 else 569 log->Printf( 570 "FindExternalLexicalDecls[%u] on (ASTContext*)%p in a NULL context", 571 current_id, static_cast<const void *>(m_ast_context)); 572 } 573 574 Decl *original_decl = NULL; 575 ASTContext *original_ctx = NULL; 576 577 if (!m_ast_importer_sp->ResolveDeclOrigin(context_decl, &original_decl, 578 &original_ctx)) 579 return; 580 581 if (log) { 582 log->Printf(" FELD[%u] Original decl (ASTContext*)%p (Decl*)%p:", 583 current_id, static_cast<void *>(original_ctx), 584 static_cast<void *>(original_decl)); 585 ASTDumper(original_decl).ToLog(log, " "); 586 } 587 588 if (ObjCInterfaceDecl *original_iface_decl = 589 dyn_cast<ObjCInterfaceDecl>(original_decl)) { 590 ObjCInterfaceDecl *complete_iface_decl = 591 GetCompleteObjCInterface(original_iface_decl); 592 593 if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) { 594 original_decl = complete_iface_decl; 595 original_ctx = &complete_iface_decl->getASTContext(); 596 597 m_ast_importer_sp->SetDeclOrigin(context_decl, complete_iface_decl); 598 } 599 } 600 601 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl)) { 602 ExternalASTSource *external_source = original_ctx->getExternalSource(); 603 604 if (external_source) 605 external_source->CompleteType(original_tag_decl); 606 } 607 608 const DeclContext *original_decl_context = 609 dyn_cast<DeclContext>(original_decl); 610 611 if (!original_decl_context) 612 return; 613 614 for (TagDecl::decl_iterator iter = original_decl_context->decls_begin(); 615 iter != original_decl_context->decls_end(); ++iter) { 616 Decl *decl = *iter; 617 618 if (predicate(decl->getKind())) { 619 if (log) { 620 ASTDumper ast_dumper(decl); 621 if (const NamedDecl *context_named_decl = 622 dyn_cast<NamedDecl>(context_decl)) 623 log->Printf(" FELD[%d] Adding [to %sDecl %s] lexical %sDecl %s", 624 current_id, context_named_decl->getDeclKindName(), 625 context_named_decl->getNameAsString().c_str(), 626 decl->getDeclKindName(), ast_dumper.GetCString()); 627 else 628 log->Printf(" FELD[%d] Adding lexical %sDecl %s", current_id, 629 decl->getDeclKindName(), ast_dumper.GetCString()); 630 } 631 632 Decl *copied_decl = CopyDecl(decl); 633 634 if (!copied_decl) 635 continue; 636 637 if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) { 638 QualType copied_field_type = copied_field->getType(); 639 640 m_ast_importer_sp->RequireCompleteType(copied_field_type); 641 } 642 643 DeclContext *decl_context_non_const = 644 const_cast<DeclContext *>(decl_context); 645 646 if (copied_decl->getDeclContext() != decl_context) { 647 if (copied_decl->getDeclContext()->containsDecl(copied_decl)) 648 copied_decl->getDeclContext()->removeDecl(copied_decl); 649 copied_decl->setDeclContext(decl_context_non_const); 650 } 651 652 if (!decl_context_non_const->containsDecl(copied_decl)) 653 decl_context_non_const->addDeclInternal(copied_decl); 654 } 655 } 656 657 return; 658 } 659 660 void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) { 661 assert(m_ast_context); 662 663 ClangASTMetrics::RegisterVisibleQuery(); 664 665 const ConstString name(context.m_decl_name.getAsString().c_str()); 666 667 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 668 669 static unsigned int invocation_id = 0; 670 unsigned int current_id = invocation_id++; 671 672 if (log) { 673 if (!context.m_decl_context) 674 log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on " 675 "(ASTContext*)%p for '%s' in a NULL DeclContext", 676 current_id, static_cast<void *>(m_ast_context), 677 name.GetCString()); 678 else if (const NamedDecl *context_named_decl = 679 dyn_cast<NamedDecl>(context.m_decl_context)) 680 log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on " 681 "(ASTContext*)%p for '%s' in '%s'", 682 current_id, static_cast<void *>(m_ast_context), 683 name.GetCString(), 684 context_named_decl->getNameAsString().c_str()); 685 else 686 log->Printf("ClangASTSource::FindExternalVisibleDecls[%u] on " 687 "(ASTContext*)%p for '%s' in a '%s'", 688 current_id, static_cast<void *>(m_ast_context), 689 name.GetCString(), context.m_decl_context->getDeclKindName()); 690 } 691 692 if (HasMerger() && !isa<TranslationUnitDecl>(context.m_decl_context) 693 /* possibly handle NamespaceDecls here? */) { 694 if (auto *interface_decl = 695 dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) { 696 ObjCInterfaceDecl *complete_iface_decl = 697 GetCompleteObjCInterface(interface_decl); 698 699 if (complete_iface_decl && (complete_iface_decl != interface_decl)) { 700 GetMergerUnchecked().ForceRecordOrigin( 701 interface_decl, 702 {complete_iface_decl, &complete_iface_decl->getASTContext()}); 703 } 704 } 705 706 GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context, 707 context.m_decl_name); 708 return; // otherwise we may need to fall back 709 } 710 711 context.m_namespace_map = std::make_shared<ClangASTImporter::NamespaceMap>(); 712 713 if (const NamespaceDecl *namespace_context = 714 dyn_cast<NamespaceDecl>(context.m_decl_context)) { 715 ClangASTImporter::NamespaceMapSP namespace_map = m_ast_importer_sp ? 716 m_ast_importer_sp->GetNamespaceMap(namespace_context) : nullptr; 717 718 if (log && log->GetVerbose()) 719 log->Printf(" CAS::FEVD[%u] Inspecting namespace map %p (%d entries)", 720 current_id, static_cast<void *>(namespace_map.get()), 721 static_cast<int>(namespace_map->size())); 722 723 if (!namespace_map) 724 return; 725 726 for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(), 727 e = namespace_map->end(); 728 i != e; ++i) { 729 if (log) 730 log->Printf(" CAS::FEVD[%u] Searching namespace %s in module %s", 731 current_id, i->second.GetName().AsCString(), 732 i->first->GetFileSpec().GetFilename().GetCString()); 733 734 FindExternalVisibleDecls(context, i->first, i->second, current_id); 735 } 736 } else if (isa<ObjCInterfaceDecl>(context.m_decl_context) && !HasMerger()) { 737 FindObjCPropertyAndIvarDecls(context); 738 } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) { 739 // we shouldn't be getting FindExternalVisibleDecls calls for these 740 return; 741 } else { 742 CompilerDeclContext namespace_decl; 743 744 if (log) 745 log->Printf(" CAS::FEVD[%u] Searching the root namespace", current_id); 746 747 FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl, 748 current_id); 749 } 750 751 if (!context.m_namespace_map->empty()) { 752 if (log && log->GetVerbose()) 753 log->Printf(" CAS::FEVD[%u] Registering namespace map %p (%d entries)", 754 current_id, 755 static_cast<void *>(context.m_namespace_map.get()), 756 static_cast<int>(context.m_namespace_map->size())); 757 758 NamespaceDecl *clang_namespace_decl = 759 AddNamespace(context, context.m_namespace_map); 760 761 if (clang_namespace_decl) 762 clang_namespace_decl->setHasExternalVisibleStorage(); 763 } 764 } 765 766 bool ClangASTSource::IgnoreName(const ConstString name, 767 bool ignore_all_dollar_names) { 768 static const ConstString id_name("id"); 769 static const ConstString Class_name("Class"); 770 771 if (m_ast_context->getLangOpts().ObjC) 772 if (name == id_name || name == Class_name) 773 return true; 774 775 StringRef name_string_ref = name.GetStringRef(); 776 777 // The ClangASTSource is not responsible for finding $-names. 778 return name_string_ref.empty() || 779 (ignore_all_dollar_names && name_string_ref.startswith("$")) || 780 name_string_ref.startswith("_$"); 781 } 782 783 void ClangASTSource::FindExternalVisibleDecls( 784 NameSearchContext &context, lldb::ModuleSP module_sp, 785 CompilerDeclContext &namespace_decl, unsigned int current_id) { 786 assert(m_ast_context); 787 788 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 789 790 SymbolContextList sc_list; 791 792 const ConstString name(context.m_decl_name.getAsString().c_str()); 793 if (IgnoreName(name, true)) 794 return; 795 796 if (module_sp && namespace_decl) { 797 CompilerDeclContext found_namespace_decl; 798 799 SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor(); 800 801 if (symbol_vendor) { 802 found_namespace_decl = 803 symbol_vendor->FindNamespace(name, &namespace_decl); 804 805 if (found_namespace_decl) { 806 context.m_namespace_map->push_back( 807 std::pair<lldb::ModuleSP, CompilerDeclContext>( 808 module_sp, found_namespace_decl)); 809 810 if (log) 811 log->Printf(" CAS::FEVD[%u] Found namespace %s in module %s", 812 current_id, name.GetCString(), 813 module_sp->GetFileSpec().GetFilename().GetCString()); 814 } 815 } 816 } else if (!HasMerger()) { 817 const ModuleList &target_images = m_target->GetImages(); 818 std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex()); 819 820 for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) { 821 lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i); 822 823 if (!image) 824 continue; 825 826 CompilerDeclContext found_namespace_decl; 827 828 SymbolVendor *symbol_vendor = image->GetSymbolVendor(); 829 830 if (!symbol_vendor) 831 continue; 832 833 found_namespace_decl = 834 symbol_vendor->FindNamespace(name, &namespace_decl); 835 836 if (found_namespace_decl) { 837 context.m_namespace_map->push_back( 838 std::pair<lldb::ModuleSP, CompilerDeclContext>( 839 image, found_namespace_decl)); 840 841 if (log) 842 log->Printf(" CAS::FEVD[%u] Found namespace %s in module %s", 843 current_id, name.GetCString(), 844 image->GetFileSpec().GetFilename().GetCString()); 845 } 846 } 847 } 848 849 do { 850 if (context.m_found.type) 851 break; 852 853 TypeList types; 854 const bool exact_match = true; 855 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; 856 if (module_sp && namespace_decl) 857 module_sp->FindTypesInNamespace(name, &namespace_decl, 1, types); 858 else { 859 m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1, 860 searched_symbol_files, types); 861 } 862 863 if (size_t num_types = types.GetSize()) { 864 for (size_t ti = 0; ti < num_types; ++ti) { 865 lldb::TypeSP type_sp = types.GetTypeAtIndex(ti); 866 867 if (log) { 868 const char *name_string = type_sp->GetName().GetCString(); 869 870 log->Printf(" CAS::FEVD[%u] Matching type found for \"%s\": %s", 871 current_id, name.GetCString(), 872 (name_string ? name_string : "<anonymous>")); 873 } 874 875 CompilerType full_type = type_sp->GetFullCompilerType(); 876 877 CompilerType copied_clang_type(GuardedCopyType(full_type)); 878 879 if (!copied_clang_type) { 880 if (log) 881 log->Printf(" CAS::FEVD[%u] - Couldn't export a type", current_id); 882 883 continue; 884 } 885 886 context.AddTypeDecl(copied_clang_type); 887 888 context.m_found.type = true; 889 break; 890 } 891 } 892 893 if (!context.m_found.type) { 894 // Try the modules next. 895 896 do { 897 if (ClangModulesDeclVendor *modules_decl_vendor = 898 m_target->GetClangModulesDeclVendor()) { 899 bool append = false; 900 uint32_t max_matches = 1; 901 std::vector<clang::NamedDecl *> decls; 902 903 if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls)) 904 break; 905 906 if (log) { 907 log->Printf(" CAS::FEVD[%u] Matching entity found for \"%s\" in " 908 "the modules", 909 current_id, name.GetCString()); 910 } 911 912 clang::NamedDecl *const decl_from_modules = decls[0]; 913 914 if (llvm::isa<clang::TypeDecl>(decl_from_modules) || 915 llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) || 916 llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) { 917 clang::Decl *copied_decl = CopyDecl(decl_from_modules); 918 clang::NamedDecl *copied_named_decl = 919 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr; 920 921 if (!copied_named_decl) { 922 if (log) 923 log->Printf( 924 " CAS::FEVD[%u] - Couldn't export a type from the modules", 925 current_id); 926 927 break; 928 } 929 930 context.AddNamedDecl(copied_named_decl); 931 932 context.m_found.type = true; 933 } 934 } 935 } while (0); 936 } 937 938 if (!context.m_found.type) { 939 do { 940 // Couldn't find any types elsewhere. Try the Objective-C runtime if 941 // one exists. 942 943 lldb::ProcessSP process(m_target->GetProcessSP()); 944 945 if (!process) 946 break; 947 948 ObjCLanguageRuntime *language_runtime( 949 process->GetObjCLanguageRuntime()); 950 951 if (!language_runtime) 952 break; 953 954 DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 955 956 if (!decl_vendor) 957 break; 958 959 bool append = false; 960 uint32_t max_matches = 1; 961 std::vector<clang::NamedDecl *> decls; 962 963 if (!decl_vendor->FindDecls(name, append, max_matches, decls)) 964 break; 965 966 if (log) { 967 log->Printf( 968 " CAS::FEVD[%u] Matching type found for \"%s\" in the runtime", 969 current_id, name.GetCString()); 970 } 971 972 clang::Decl *copied_decl = CopyDecl(decls[0]); 973 clang::NamedDecl *copied_named_decl = 974 copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr; 975 976 if (!copied_named_decl) { 977 if (log) 978 log->Printf( 979 " CAS::FEVD[%u] - Couldn't export a type from the runtime", 980 current_id); 981 982 break; 983 } 984 985 context.AddNamedDecl(copied_named_decl); 986 } while (0); 987 } 988 989 } while (0); 990 } 991 992 template <class D> class TaggedASTDecl { 993 public: 994 TaggedASTDecl() : decl(NULL) {} 995 TaggedASTDecl(D *_decl) : decl(_decl) {} 996 bool IsValid() const { return (decl != NULL); } 997 bool IsInvalid() const { return !IsValid(); } 998 D *operator->() const { return decl; } 999 D *decl; 1000 }; 1001 1002 template <class D2, template <class D> class TD, class D1> 1003 TD<D2> DynCast(TD<D1> source) { 1004 return TD<D2>(dyn_cast<D2>(source.decl)); 1005 } 1006 1007 template <class D = Decl> class DeclFromParser; 1008 template <class D = Decl> class DeclFromUser; 1009 1010 template <class D> class DeclFromParser : public TaggedASTDecl<D> { 1011 public: 1012 DeclFromParser() : TaggedASTDecl<D>() {} 1013 DeclFromParser(D *_decl) : TaggedASTDecl<D>(_decl) {} 1014 1015 DeclFromUser<D> GetOrigin(ClangASTSource &source); 1016 }; 1017 1018 template <class D> class DeclFromUser : public TaggedASTDecl<D> { 1019 public: 1020 DeclFromUser() : TaggedASTDecl<D>() {} 1021 DeclFromUser(D *_decl) : TaggedASTDecl<D>(_decl) {} 1022 1023 DeclFromParser<D> Import(ClangASTSource &source); 1024 }; 1025 1026 template <class D> 1027 DeclFromUser<D> DeclFromParser<D>::GetOrigin(ClangASTSource &source) { 1028 DeclFromUser<> origin_decl; 1029 source.ResolveDeclOrigin(this->decl, &origin_decl.decl, NULL); 1030 if (origin_decl.IsInvalid()) 1031 return DeclFromUser<D>(); 1032 return DeclFromUser<D>(dyn_cast<D>(origin_decl.decl)); 1033 } 1034 1035 template <class D> 1036 DeclFromParser<D> DeclFromUser<D>::Import(ClangASTSource &source) { 1037 DeclFromParser<> parser_generic_decl(source.CopyDecl(this->decl)); 1038 if (parser_generic_decl.IsInvalid()) 1039 return DeclFromParser<D>(); 1040 return DeclFromParser<D>(dyn_cast<D>(parser_generic_decl.decl)); 1041 } 1042 1043 bool ClangASTSource::FindObjCMethodDeclsWithOrigin( 1044 unsigned int current_id, NameSearchContext &context, 1045 ObjCInterfaceDecl *original_interface_decl, const char *log_info) { 1046 const DeclarationName &decl_name(context.m_decl_name); 1047 clang::ASTContext *original_ctx = &original_interface_decl->getASTContext(); 1048 1049 Selector original_selector; 1050 1051 if (decl_name.isObjCZeroArgSelector()) { 1052 IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString()); 1053 original_selector = original_ctx->Selectors.getSelector(0, &ident); 1054 } else if (decl_name.isObjCOneArgSelector()) { 1055 const std::string &decl_name_string = decl_name.getAsString(); 1056 std::string decl_name_string_without_colon(decl_name_string.c_str(), 1057 decl_name_string.length() - 1); 1058 IdentifierInfo *ident = 1059 &original_ctx->Idents.get(decl_name_string_without_colon); 1060 original_selector = original_ctx->Selectors.getSelector(1, &ident); 1061 } else { 1062 SmallVector<IdentifierInfo *, 4> idents; 1063 1064 clang::Selector sel = decl_name.getObjCSelector(); 1065 1066 unsigned num_args = sel.getNumArgs(); 1067 1068 for (unsigned i = 0; i != num_args; ++i) { 1069 idents.push_back(&original_ctx->Idents.get(sel.getNameForSlot(i))); 1070 } 1071 1072 original_selector = 1073 original_ctx->Selectors.getSelector(num_args, idents.data()); 1074 } 1075 1076 DeclarationName original_decl_name(original_selector); 1077 1078 llvm::SmallVector<NamedDecl *, 1> methods; 1079 1080 ClangASTContext::GetCompleteDecl(original_ctx, original_interface_decl); 1081 1082 if (ObjCMethodDecl *instance_method_decl = 1083 original_interface_decl->lookupInstanceMethod(original_selector)) { 1084 methods.push_back(instance_method_decl); 1085 } else if (ObjCMethodDecl *class_method_decl = 1086 original_interface_decl->lookupClassMethod( 1087 original_selector)) { 1088 methods.push_back(class_method_decl); 1089 } 1090 1091 if (methods.empty()) { 1092 return false; 1093 } 1094 1095 for (NamedDecl *named_decl : methods) { 1096 if (!named_decl) 1097 continue; 1098 1099 ObjCMethodDecl *result_method = dyn_cast<ObjCMethodDecl>(named_decl); 1100 1101 if (!result_method) 1102 continue; 1103 1104 Decl *copied_decl = CopyDecl(result_method); 1105 1106 if (!copied_decl) 1107 continue; 1108 1109 ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl); 1110 1111 if (!copied_method_decl) 1112 continue; 1113 1114 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1115 1116 if (log) { 1117 ASTDumper dumper((Decl *)copied_method_decl); 1118 log->Printf(" CAS::FOMD[%d] found (%s) %s", current_id, log_info, 1119 dumper.GetCString()); 1120 } 1121 1122 context.AddNamedDecl(copied_method_decl); 1123 } 1124 1125 return true; 1126 } 1127 1128 void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) { 1129 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1130 1131 if (HasMerger()) { 1132 if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) { 1133 ObjCInterfaceDecl *complete_iface_decl = 1134 GetCompleteObjCInterface(interface_decl); 1135 1136 if (complete_iface_decl && (complete_iface_decl != context.m_decl_context)) { 1137 m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()}); 1138 } 1139 } 1140 1141 GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context, 1142 context.m_decl_name); 1143 return; 1144 } 1145 1146 static unsigned int invocation_id = 0; 1147 unsigned int current_id = invocation_id++; 1148 1149 const DeclarationName &decl_name(context.m_decl_name); 1150 const DeclContext *decl_ctx(context.m_decl_context); 1151 1152 const ObjCInterfaceDecl *interface_decl = 1153 dyn_cast<ObjCInterfaceDecl>(decl_ctx); 1154 1155 if (!interface_decl) 1156 return; 1157 1158 do { 1159 Decl *original_decl = NULL; 1160 ASTContext *original_ctx = NULL; 1161 1162 m_ast_importer_sp->ResolveDeclOrigin(interface_decl, &original_decl, 1163 &original_ctx); 1164 1165 if (!original_decl) 1166 break; 1167 1168 ObjCInterfaceDecl *original_interface_decl = 1169 dyn_cast<ObjCInterfaceDecl>(original_decl); 1170 1171 if (FindObjCMethodDeclsWithOrigin(current_id, context, 1172 original_interface_decl, "at origin")) 1173 return; // found it, no need to look any further 1174 } while (0); 1175 1176 StreamString ss; 1177 1178 if (decl_name.isObjCZeroArgSelector()) { 1179 ss.Printf("%s", decl_name.getAsString().c_str()); 1180 } else if (decl_name.isObjCOneArgSelector()) { 1181 ss.Printf("%s", decl_name.getAsString().c_str()); 1182 } else { 1183 clang::Selector sel = decl_name.getObjCSelector(); 1184 1185 for (unsigned i = 0, e = sel.getNumArgs(); i != e; ++i) { 1186 llvm::StringRef r = sel.getNameForSlot(i); 1187 ss.Printf("%s:", r.str().c_str()); 1188 } 1189 } 1190 ss.Flush(); 1191 1192 if (ss.GetString().contains("$__lldb")) 1193 return; // we don't need any results 1194 1195 ConstString selector_name(ss.GetString()); 1196 1197 if (log) 1198 log->Printf("ClangASTSource::FindObjCMethodDecls[%d] on (ASTContext*)%p " 1199 "for selector [%s %s]", 1200 current_id, static_cast<void *>(m_ast_context), 1201 interface_decl->getNameAsString().c_str(), 1202 selector_name.AsCString()); 1203 SymbolContextList sc_list; 1204 1205 const bool include_symbols = false; 1206 const bool include_inlines = false; 1207 const bool append = false; 1208 1209 std::string interface_name = interface_decl->getNameAsString(); 1210 1211 do { 1212 StreamString ms; 1213 ms.Printf("-[%s %s]", interface_name.c_str(), selector_name.AsCString()); 1214 ms.Flush(); 1215 ConstString instance_method_name(ms.GetString()); 1216 1217 m_target->GetImages().FindFunctions( 1218 instance_method_name, lldb::eFunctionNameTypeFull, include_symbols, 1219 include_inlines, append, sc_list); 1220 1221 if (sc_list.GetSize()) 1222 break; 1223 1224 ms.Clear(); 1225 ms.Printf("+[%s %s]", interface_name.c_str(), selector_name.AsCString()); 1226 ms.Flush(); 1227 ConstString class_method_name(ms.GetString()); 1228 1229 m_target->GetImages().FindFunctions( 1230 class_method_name, lldb::eFunctionNameTypeFull, include_symbols, 1231 include_inlines, append, sc_list); 1232 1233 if (sc_list.GetSize()) 1234 break; 1235 1236 // Fall back and check for methods in categories. If we find methods this 1237 // way, we need to check that they're actually in categories on the desired 1238 // class. 1239 1240 SymbolContextList candidate_sc_list; 1241 1242 m_target->GetImages().FindFunctions( 1243 selector_name, lldb::eFunctionNameTypeSelector, include_symbols, 1244 include_inlines, append, candidate_sc_list); 1245 1246 for (uint32_t ci = 0, ce = candidate_sc_list.GetSize(); ci != ce; ++ci) { 1247 SymbolContext candidate_sc; 1248 1249 if (!candidate_sc_list.GetContextAtIndex(ci, candidate_sc)) 1250 continue; 1251 1252 if (!candidate_sc.function) 1253 continue; 1254 1255 const char *candidate_name = candidate_sc.function->GetName().AsCString(); 1256 1257 const char *cursor = candidate_name; 1258 1259 if (*cursor != '+' && *cursor != '-') 1260 continue; 1261 1262 ++cursor; 1263 1264 if (*cursor != '[') 1265 continue; 1266 1267 ++cursor; 1268 1269 size_t interface_len = interface_name.length(); 1270 1271 if (strncmp(cursor, interface_name.c_str(), interface_len)) 1272 continue; 1273 1274 cursor += interface_len; 1275 1276 if (*cursor == ' ' || *cursor == '(') 1277 sc_list.Append(candidate_sc); 1278 } 1279 } while (0); 1280 1281 if (sc_list.GetSize()) { 1282 // We found a good function symbol. Use that. 1283 1284 for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) { 1285 SymbolContext sc; 1286 1287 if (!sc_list.GetContextAtIndex(i, sc)) 1288 continue; 1289 1290 if (!sc.function) 1291 continue; 1292 1293 CompilerDeclContext function_decl_ctx = sc.function->GetDeclContext(); 1294 if (!function_decl_ctx) 1295 continue; 1296 1297 ObjCMethodDecl *method_decl = 1298 ClangASTContext::DeclContextGetAsObjCMethodDecl(function_decl_ctx); 1299 1300 if (!method_decl) 1301 continue; 1302 1303 ObjCInterfaceDecl *found_interface_decl = 1304 method_decl->getClassInterface(); 1305 1306 if (!found_interface_decl) 1307 continue; 1308 1309 if (found_interface_decl->getName() == interface_decl->getName()) { 1310 Decl *copied_decl = CopyDecl(method_decl); 1311 1312 if (!copied_decl) 1313 continue; 1314 1315 ObjCMethodDecl *copied_method_decl = 1316 dyn_cast<ObjCMethodDecl>(copied_decl); 1317 1318 if (!copied_method_decl) 1319 continue; 1320 1321 if (log) { 1322 ASTDumper dumper((Decl *)copied_method_decl); 1323 log->Printf(" CAS::FOMD[%d] found (in symbols) %s", current_id, 1324 dumper.GetCString()); 1325 } 1326 1327 context.AddNamedDecl(copied_method_decl); 1328 } 1329 } 1330 1331 return; 1332 } 1333 1334 // Try the debug information. 1335 1336 do { 1337 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( 1338 const_cast<ObjCInterfaceDecl *>(interface_decl)); 1339 1340 if (!complete_interface_decl) 1341 break; 1342 1343 // We found the complete interface. The runtime never needs to be queried 1344 // in this scenario. 1345 1346 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl( 1347 complete_interface_decl); 1348 1349 if (complete_interface_decl == interface_decl) 1350 break; // already checked this one 1351 1352 if (log) 1353 log->Printf("CAS::FOPD[%d] trying origin " 1354 "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...", 1355 current_id, static_cast<void *>(complete_interface_decl), 1356 static_cast<void *>(&complete_iface_decl->getASTContext())); 1357 1358 FindObjCMethodDeclsWithOrigin(current_id, context, complete_interface_decl, 1359 "in debug info"); 1360 1361 return; 1362 } while (0); 1363 1364 do { 1365 // Check the modules only if the debug information didn't have a complete 1366 // interface. 1367 1368 if (ClangModulesDeclVendor *modules_decl_vendor = 1369 m_target->GetClangModulesDeclVendor()) { 1370 ConstString interface_name(interface_decl->getNameAsString().c_str()); 1371 bool append = false; 1372 uint32_t max_matches = 1; 1373 std::vector<clang::NamedDecl *> decls; 1374 1375 if (!modules_decl_vendor->FindDecls(interface_name, append, max_matches, 1376 decls)) 1377 break; 1378 1379 ObjCInterfaceDecl *interface_decl_from_modules = 1380 dyn_cast<ObjCInterfaceDecl>(decls[0]); 1381 1382 if (!interface_decl_from_modules) 1383 break; 1384 1385 if (FindObjCMethodDeclsWithOrigin( 1386 current_id, context, interface_decl_from_modules, "in modules")) 1387 return; 1388 } 1389 } while (0); 1390 1391 do { 1392 // Check the runtime only if the debug information didn't have a complete 1393 // interface and the modules don't get us anywhere. 1394 1395 lldb::ProcessSP process(m_target->GetProcessSP()); 1396 1397 if (!process) 1398 break; 1399 1400 ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime()); 1401 1402 if (!language_runtime) 1403 break; 1404 1405 DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 1406 1407 if (!decl_vendor) 1408 break; 1409 1410 ConstString interface_name(interface_decl->getNameAsString().c_str()); 1411 bool append = false; 1412 uint32_t max_matches = 1; 1413 std::vector<clang::NamedDecl *> decls; 1414 1415 if (!decl_vendor->FindDecls(interface_name, append, max_matches, decls)) 1416 break; 1417 1418 ObjCInterfaceDecl *runtime_interface_decl = 1419 dyn_cast<ObjCInterfaceDecl>(decls[0]); 1420 1421 if (!runtime_interface_decl) 1422 break; 1423 1424 FindObjCMethodDeclsWithOrigin(current_id, context, runtime_interface_decl, 1425 "in runtime"); 1426 } while (0); 1427 } 1428 1429 static bool FindObjCPropertyAndIvarDeclsWithOrigin( 1430 unsigned int current_id, NameSearchContext &context, ClangASTSource &source, 1431 DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) { 1432 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1433 1434 if (origin_iface_decl.IsInvalid()) 1435 return false; 1436 1437 std::string name_str = context.m_decl_name.getAsString(); 1438 StringRef name(name_str); 1439 IdentifierInfo &name_identifier( 1440 origin_iface_decl->getASTContext().Idents.get(name)); 1441 1442 DeclFromUser<ObjCPropertyDecl> origin_property_decl( 1443 origin_iface_decl->FindPropertyDeclaration( 1444 &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance)); 1445 1446 bool found = false; 1447 1448 if (origin_property_decl.IsValid()) { 1449 DeclFromParser<ObjCPropertyDecl> parser_property_decl( 1450 origin_property_decl.Import(source)); 1451 if (parser_property_decl.IsValid()) { 1452 if (log) { 1453 ASTDumper dumper((Decl *)parser_property_decl.decl); 1454 log->Printf(" CAS::FOPD[%d] found %s", current_id, 1455 dumper.GetCString()); 1456 } 1457 1458 context.AddNamedDecl(parser_property_decl.decl); 1459 found = true; 1460 } 1461 } 1462 1463 DeclFromUser<ObjCIvarDecl> origin_ivar_decl( 1464 origin_iface_decl->getIvarDecl(&name_identifier)); 1465 1466 if (origin_ivar_decl.IsValid()) { 1467 DeclFromParser<ObjCIvarDecl> parser_ivar_decl( 1468 origin_ivar_decl.Import(source)); 1469 if (parser_ivar_decl.IsValid()) { 1470 if (log) { 1471 ASTDumper dumper((Decl *)parser_ivar_decl.decl); 1472 log->Printf(" CAS::FOPD[%d] found %s", current_id, 1473 dumper.GetCString()); 1474 } 1475 1476 context.AddNamedDecl(parser_ivar_decl.decl); 1477 found = true; 1478 } 1479 } 1480 1481 return found; 1482 } 1483 1484 void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) { 1485 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1486 1487 static unsigned int invocation_id = 0; 1488 unsigned int current_id = invocation_id++; 1489 1490 DeclFromParser<const ObjCInterfaceDecl> parser_iface_decl( 1491 cast<ObjCInterfaceDecl>(context.m_decl_context)); 1492 DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl( 1493 parser_iface_decl.GetOrigin(*this)); 1494 1495 ConstString class_name(parser_iface_decl->getNameAsString().c_str()); 1496 1497 if (log) 1498 log->Printf("ClangASTSource::FindObjCPropertyAndIvarDecls[%d] on " 1499 "(ASTContext*)%p for '%s.%s'", 1500 current_id, static_cast<void *>(m_ast_context), 1501 parser_iface_decl->getNameAsString().c_str(), 1502 context.m_decl_name.getAsString().c_str()); 1503 1504 if (FindObjCPropertyAndIvarDeclsWithOrigin( 1505 current_id, context, *this, origin_iface_decl)) 1506 return; 1507 1508 if (log) 1509 log->Printf("CAS::FOPD[%d] couldn't find the property on origin " 1510 "(ObjCInterfaceDecl*)%p/(ASTContext*)%p, searching " 1511 "elsewhere...", 1512 current_id, static_cast<const void *>(origin_iface_decl.decl), 1513 static_cast<void *>(&origin_iface_decl->getASTContext())); 1514 1515 SymbolContext null_sc; 1516 TypeList type_list; 1517 1518 do { 1519 ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface( 1520 const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl)); 1521 1522 if (!complete_interface_decl) 1523 break; 1524 1525 // We found the complete interface. The runtime never needs to be queried 1526 // in this scenario. 1527 1528 DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl( 1529 complete_interface_decl); 1530 1531 if (complete_iface_decl.decl == origin_iface_decl.decl) 1532 break; // already checked this one 1533 1534 if (log) 1535 log->Printf("CAS::FOPD[%d] trying origin " 1536 "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...", 1537 current_id, 1538 static_cast<const void *>(complete_iface_decl.decl), 1539 static_cast<void *>(&complete_iface_decl->getASTContext())); 1540 1541 FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this, 1542 complete_iface_decl); 1543 1544 return; 1545 } while (0); 1546 1547 do { 1548 // Check the modules only if the debug information didn't have a complete 1549 // interface. 1550 1551 ClangModulesDeclVendor *modules_decl_vendor = 1552 m_target->GetClangModulesDeclVendor(); 1553 1554 if (!modules_decl_vendor) 1555 break; 1556 1557 bool append = false; 1558 uint32_t max_matches = 1; 1559 std::vector<clang::NamedDecl *> decls; 1560 1561 if (!modules_decl_vendor->FindDecls(class_name, append, max_matches, decls)) 1562 break; 1563 1564 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules( 1565 dyn_cast<ObjCInterfaceDecl>(decls[0])); 1566 1567 if (!interface_decl_from_modules.IsValid()) 1568 break; 1569 1570 if (log) 1571 log->Printf( 1572 "CAS::FOPD[%d] trying module " 1573 "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...", 1574 current_id, 1575 static_cast<const void *>(interface_decl_from_modules.decl), 1576 static_cast<void *>(&interface_decl_from_modules->getASTContext())); 1577 1578 if (FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this, 1579 interface_decl_from_modules)) 1580 return; 1581 } while (0); 1582 1583 do { 1584 // Check the runtime only if the debug information didn't have a complete 1585 // interface and nothing was in the modules. 1586 1587 lldb::ProcessSP process(m_target->GetProcessSP()); 1588 1589 if (!process) 1590 return; 1591 1592 ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime()); 1593 1594 if (!language_runtime) 1595 return; 1596 1597 DeclVendor *decl_vendor = language_runtime->GetDeclVendor(); 1598 1599 if (!decl_vendor) 1600 break; 1601 1602 bool append = false; 1603 uint32_t max_matches = 1; 1604 std::vector<clang::NamedDecl *> decls; 1605 1606 if (!decl_vendor->FindDecls(class_name, append, max_matches, decls)) 1607 break; 1608 1609 DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime( 1610 dyn_cast<ObjCInterfaceDecl>(decls[0])); 1611 1612 if (!interface_decl_from_runtime.IsValid()) 1613 break; 1614 1615 if (log) 1616 log->Printf( 1617 "CAS::FOPD[%d] trying runtime " 1618 "(ObjCInterfaceDecl*)%p/(ASTContext*)%p...", 1619 current_id, 1620 static_cast<const void *>(interface_decl_from_runtime.decl), 1621 static_cast<void *>(&interface_decl_from_runtime->getASTContext())); 1622 1623 if (FindObjCPropertyAndIvarDeclsWithOrigin( 1624 current_id, context, *this, interface_decl_from_runtime)) 1625 return; 1626 } while (0); 1627 } 1628 1629 typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap; 1630 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap; 1631 1632 template <class D, class O> 1633 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map, 1634 llvm::DenseMap<const D *, O> &source_map, 1635 ClangASTSource &source) { 1636 // When importing fields into a new record, clang has a hard requirement that 1637 // fields be imported in field offset order. Since they are stored in a 1638 // DenseMap with a pointer as the key type, this means we cannot simply 1639 // iterate over the map, as the order will be non-deterministic. Instead we 1640 // have to sort by the offset and then insert in sorted order. 1641 typedef llvm::DenseMap<const D *, O> MapType; 1642 typedef typename MapType::value_type PairType; 1643 std::vector<PairType> sorted_items; 1644 sorted_items.reserve(source_map.size()); 1645 sorted_items.assign(source_map.begin(), source_map.end()); 1646 llvm::sort(sorted_items.begin(), sorted_items.end(), 1647 [](const PairType &lhs, const PairType &rhs) { 1648 return lhs.second < rhs.second; 1649 }); 1650 1651 for (const auto &item : sorted_items) { 1652 DeclFromUser<D> user_decl(const_cast<D *>(item.first)); 1653 DeclFromParser<D> parser_decl(user_decl.Import(source)); 1654 if (parser_decl.IsInvalid()) 1655 return false; 1656 destination_map.insert( 1657 std::pair<const D *, O>(parser_decl.decl, item.second)); 1658 } 1659 1660 return true; 1661 } 1662 1663 template <bool IsVirtual> 1664 bool ExtractBaseOffsets(const ASTRecordLayout &record_layout, 1665 DeclFromUser<const CXXRecordDecl> &record, 1666 BaseOffsetMap &base_offsets) { 1667 for (CXXRecordDecl::base_class_const_iterator 1668 bi = (IsVirtual ? record->vbases_begin() : record->bases_begin()), 1669 be = (IsVirtual ? record->vbases_end() : record->bases_end()); 1670 bi != be; ++bi) { 1671 if (!IsVirtual && bi->isVirtual()) 1672 continue; 1673 1674 const clang::Type *origin_base_type = bi->getType().getTypePtr(); 1675 const clang::RecordType *origin_base_record_type = 1676 origin_base_type->getAs<RecordType>(); 1677 1678 if (!origin_base_record_type) 1679 return false; 1680 1681 DeclFromUser<RecordDecl> origin_base_record( 1682 origin_base_record_type->getDecl()); 1683 1684 if (origin_base_record.IsInvalid()) 1685 return false; 1686 1687 DeclFromUser<CXXRecordDecl> origin_base_cxx_record( 1688 DynCast<CXXRecordDecl>(origin_base_record)); 1689 1690 if (origin_base_cxx_record.IsInvalid()) 1691 return false; 1692 1693 CharUnits base_offset; 1694 1695 if (IsVirtual) 1696 base_offset = 1697 record_layout.getVBaseClassOffset(origin_base_cxx_record.decl); 1698 else 1699 base_offset = 1700 record_layout.getBaseClassOffset(origin_base_cxx_record.decl); 1701 1702 base_offsets.insert(std::pair<const CXXRecordDecl *, CharUnits>( 1703 origin_base_cxx_record.decl, base_offset)); 1704 } 1705 1706 return true; 1707 } 1708 1709 bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size, 1710 uint64_t &alignment, 1711 FieldOffsetMap &field_offsets, 1712 BaseOffsetMap &base_offsets, 1713 BaseOffsetMap &virtual_base_offsets) { 1714 ClangASTMetrics::RegisterRecordLayout(); 1715 1716 static unsigned int invocation_id = 0; 1717 unsigned int current_id = invocation_id++; 1718 1719 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1720 1721 if (log) 1722 log->Printf("LayoutRecordType[%u] on (ASTContext*)%p for (RecordDecl*)%p " 1723 "[name = '%s']", 1724 current_id, static_cast<void *>(m_ast_context), 1725 static_cast<const void *>(record), 1726 record->getNameAsString().c_str()); 1727 1728 DeclFromParser<const RecordDecl> parser_record(record); 1729 DeclFromUser<const RecordDecl> origin_record( 1730 parser_record.GetOrigin(*this)); 1731 1732 if (origin_record.IsInvalid()) 1733 return false; 1734 1735 FieldOffsetMap origin_field_offsets; 1736 BaseOffsetMap origin_base_offsets; 1737 BaseOffsetMap origin_virtual_base_offsets; 1738 1739 ClangASTContext::GetCompleteDecl( 1740 &origin_record->getASTContext(), 1741 const_cast<RecordDecl *>(origin_record.decl)); 1742 1743 clang::RecordDecl *definition = origin_record.decl->getDefinition(); 1744 if (!definition || !definition->isCompleteDefinition()) 1745 return false; 1746 1747 const ASTRecordLayout &record_layout( 1748 origin_record->getASTContext().getASTRecordLayout(origin_record.decl)); 1749 1750 int field_idx = 0, field_count = record_layout.getFieldCount(); 1751 1752 for (RecordDecl::field_iterator fi = origin_record->field_begin(), 1753 fe = origin_record->field_end(); 1754 fi != fe; ++fi) { 1755 if (field_idx >= field_count) 1756 return false; // Layout didn't go well. Bail out. 1757 1758 uint64_t field_offset = record_layout.getFieldOffset(field_idx); 1759 1760 origin_field_offsets.insert( 1761 std::pair<const FieldDecl *, uint64_t>(*fi, field_offset)); 1762 1763 field_idx++; 1764 } 1765 1766 lldbassert(&record->getASTContext() == m_ast_context); 1767 1768 DeclFromUser<const CXXRecordDecl> origin_cxx_record( 1769 DynCast<const CXXRecordDecl>(origin_record)); 1770 1771 if (origin_cxx_record.IsValid()) { 1772 if (!ExtractBaseOffsets<false>(record_layout, origin_cxx_record, 1773 origin_base_offsets) || 1774 !ExtractBaseOffsets<true>(record_layout, origin_cxx_record, 1775 origin_virtual_base_offsets)) 1776 return false; 1777 } 1778 1779 if (!ImportOffsetMap(field_offsets, origin_field_offsets, *this) || 1780 !ImportOffsetMap(base_offsets, origin_base_offsets, *this) || 1781 !ImportOffsetMap(virtual_base_offsets, origin_virtual_base_offsets, 1782 *this)) 1783 return false; 1784 1785 size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth(); 1786 alignment = record_layout.getAlignment().getQuantity() * 1787 m_ast_context->getCharWidth(); 1788 1789 if (log) { 1790 log->Printf("LRT[%u] returned:", current_id); 1791 log->Printf("LRT[%u] Original = (RecordDecl*)%p", current_id, 1792 static_cast<const void *>(origin_record.decl)); 1793 log->Printf("LRT[%u] Size = %" PRId64, current_id, size); 1794 log->Printf("LRT[%u] Alignment = %" PRId64, current_id, alignment); 1795 log->Printf("LRT[%u] Fields:", current_id); 1796 for (RecordDecl::field_iterator fi = record->field_begin(), 1797 fe = record->field_end(); 1798 fi != fe; ++fi) { 1799 log->Printf("LRT[%u] (FieldDecl*)%p, Name = '%s', Offset = %" PRId64 1800 " bits", 1801 current_id, static_cast<void *>(*fi), 1802 fi->getNameAsString().c_str(), field_offsets[*fi]); 1803 } 1804 DeclFromParser<const CXXRecordDecl> parser_cxx_record = 1805 DynCast<const CXXRecordDecl>(parser_record); 1806 if (parser_cxx_record.IsValid()) { 1807 log->Printf("LRT[%u] Bases:", current_id); 1808 for (CXXRecordDecl::base_class_const_iterator 1809 bi = parser_cxx_record->bases_begin(), 1810 be = parser_cxx_record->bases_end(); 1811 bi != be; ++bi) { 1812 bool is_virtual = bi->isVirtual(); 1813 1814 QualType base_type = bi->getType(); 1815 const RecordType *base_record_type = base_type->getAs<RecordType>(); 1816 DeclFromParser<RecordDecl> base_record(base_record_type->getDecl()); 1817 DeclFromParser<CXXRecordDecl> base_cxx_record = 1818 DynCast<CXXRecordDecl>(base_record); 1819 1820 log->Printf( 1821 "LRT[%u] %s(CXXRecordDecl*)%p, Name = '%s', Offset = %" PRId64 1822 " chars", 1823 current_id, (is_virtual ? "Virtual " : ""), 1824 static_cast<void *>(base_cxx_record.decl), 1825 base_cxx_record.decl->getNameAsString().c_str(), 1826 (is_virtual 1827 ? virtual_base_offsets[base_cxx_record.decl].getQuantity() 1828 : base_offsets[base_cxx_record.decl].getQuantity())); 1829 } 1830 } else { 1831 log->Printf("LRD[%u] Not a CXXRecord, so no bases", current_id); 1832 } 1833 } 1834 1835 return true; 1836 } 1837 1838 void ClangASTSource::CompleteNamespaceMap( 1839 ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name, 1840 ClangASTImporter::NamespaceMapSP &parent_map) const { 1841 static unsigned int invocation_id = 0; 1842 unsigned int current_id = invocation_id++; 1843 1844 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 1845 1846 if (log) { 1847 if (parent_map && parent_map->size()) 1848 log->Printf("CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for " 1849 "namespace %s in namespace %s", 1850 current_id, static_cast<void *>(m_ast_context), 1851 name.GetCString(), 1852 parent_map->begin()->second.GetName().AsCString()); 1853 else 1854 log->Printf("CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for " 1855 "namespace %s", 1856 current_id, static_cast<void *>(m_ast_context), 1857 name.GetCString()); 1858 } 1859 1860 if (parent_map) { 1861 for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(), 1862 e = parent_map->end(); 1863 i != e; ++i) { 1864 CompilerDeclContext found_namespace_decl; 1865 1866 lldb::ModuleSP module_sp = i->first; 1867 CompilerDeclContext module_parent_namespace_decl = i->second; 1868 1869 SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor(); 1870 1871 if (!symbol_vendor) 1872 continue; 1873 1874 found_namespace_decl = 1875 symbol_vendor->FindNamespace(name, &module_parent_namespace_decl); 1876 1877 if (!found_namespace_decl) 1878 continue; 1879 1880 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>( 1881 module_sp, found_namespace_decl)); 1882 1883 if (log) 1884 log->Printf(" CMN[%u] Found namespace %s in module %s", current_id, 1885 name.GetCString(), 1886 module_sp->GetFileSpec().GetFilename().GetCString()); 1887 } 1888 } else { 1889 const ModuleList &target_images = m_target->GetImages(); 1890 std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex()); 1891 1892 CompilerDeclContext null_namespace_decl; 1893 1894 for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) { 1895 lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i); 1896 1897 if (!image) 1898 continue; 1899 1900 CompilerDeclContext found_namespace_decl; 1901 1902 SymbolVendor *symbol_vendor = image->GetSymbolVendor(); 1903 1904 if (!symbol_vendor) 1905 continue; 1906 1907 found_namespace_decl = 1908 symbol_vendor->FindNamespace(name, &null_namespace_decl); 1909 1910 if (!found_namespace_decl) 1911 continue; 1912 1913 namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>( 1914 image, found_namespace_decl)); 1915 1916 if (log) 1917 log->Printf(" CMN[%u] Found namespace %s in module %s", current_id, 1918 name.GetCString(), 1919 image->GetFileSpec().GetFilename().GetCString()); 1920 } 1921 } 1922 } 1923 1924 NamespaceDecl *ClangASTSource::AddNamespace( 1925 NameSearchContext &context, 1926 ClangASTImporter::NamespaceMapSP &namespace_decls) { 1927 if (!namespace_decls) 1928 return nullptr; 1929 1930 const CompilerDeclContext &namespace_decl = namespace_decls->begin()->second; 1931 1932 clang::ASTContext *src_ast = 1933 ClangASTContext::DeclContextGetClangASTContext(namespace_decl); 1934 if (!src_ast) 1935 return nullptr; 1936 clang::NamespaceDecl *src_namespace_decl = 1937 ClangASTContext::DeclContextGetAsNamespaceDecl(namespace_decl); 1938 1939 if (!src_namespace_decl) 1940 return nullptr; 1941 1942 Decl *copied_decl = CopyDecl(src_namespace_decl); 1943 1944 if (!copied_decl) 1945 return nullptr; 1946 1947 NamespaceDecl *copied_namespace_decl = dyn_cast<NamespaceDecl>(copied_decl); 1948 1949 if (!copied_namespace_decl) 1950 return nullptr; 1951 1952 context.m_decls.push_back(copied_namespace_decl); 1953 1954 m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl, 1955 namespace_decls); 1956 1957 return dyn_cast<NamespaceDecl>(copied_decl); 1958 } 1959 1960 clang::QualType ClangASTSource::CopyTypeWithMerger( 1961 clang::ASTContext &from_context, 1962 clang::ExternalASTMerger &merger, 1963 clang::QualType type) { 1964 if (!merger.HasImporterForOrigin(from_context)) { 1965 lldbassert(0 && "Couldn't find the importer for a source context!"); 1966 return QualType(); 1967 } 1968 1969 return merger.ImporterForOrigin(from_context).Import(type); 1970 } 1971 1972 clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) { 1973 clang::ASTContext &from_context = src_decl->getASTContext(); 1974 if (m_ast_importer_sp) { 1975 return m_ast_importer_sp->CopyDecl(m_ast_context, &from_context, src_decl); 1976 } else if (m_merger_up) { 1977 if (!m_merger_up->HasImporterForOrigin(from_context)) { 1978 lldbassert(0 && "Couldn't find the importer for a source context!"); 1979 return nullptr; 1980 } 1981 1982 return m_merger_up->ImporterForOrigin(from_context).Import(src_decl); 1983 } else { 1984 lldbassert(0 && "No mechanism for copying a decl!"); 1985 return nullptr; 1986 } 1987 } 1988 1989 bool ClangASTSource::ResolveDeclOrigin(const clang::Decl *decl, 1990 clang::Decl **original_decl, 1991 clang::ASTContext **original_ctx) { 1992 if (m_ast_importer_sp) { 1993 return m_ast_importer_sp->ResolveDeclOrigin(decl, original_decl, 1994 original_ctx); 1995 } else if (m_merger_up) { 1996 return false; // Implement this correctly in ExternalASTMerger 1997 } else { 1998 // this can happen early enough that no ExternalASTSource is installed. 1999 return false; 2000 } 2001 } 2002 2003 clang::ExternalASTMerger &ClangASTSource::GetMergerUnchecked() { 2004 lldbassert(m_merger_up != nullptr); 2005 return *m_merger_up; 2006 } 2007 2008 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) { 2009 ClangASTContext *src_ast = 2010 llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem()); 2011 if (src_ast == nullptr) 2012 return CompilerType(); 2013 2014 ClangASTMetrics::RegisterLLDBImport(); 2015 2016 SetImportInProgress(true); 2017 2018 QualType copied_qual_type; 2019 2020 if (m_ast_importer_sp) { 2021 copied_qual_type = 2022 m_ast_importer_sp->CopyType(m_ast_context, src_ast->getASTContext(), 2023 ClangUtil::GetQualType(src_type)); 2024 } else if (m_merger_up) { 2025 copied_qual_type = 2026 CopyTypeWithMerger(*src_ast->getASTContext(), *m_merger_up, 2027 ClangUtil::GetQualType(src_type)); 2028 } else { 2029 lldbassert(0 && "No mechanism for copying a type!"); 2030 return CompilerType(); 2031 } 2032 2033 SetImportInProgress(false); 2034 2035 if (copied_qual_type.getAsOpaquePtr() && 2036 copied_qual_type->getCanonicalTypeInternal().isNull()) 2037 // this shouldn't happen, but we're hardening because the AST importer 2038 // seems to be generating bad types on occasion. 2039 return CompilerType(); 2040 2041 return CompilerType(m_ast_context, copied_qual_type); 2042 } 2043 2044 clang::NamedDecl *NameSearchContext::AddVarDecl(const CompilerType &type) { 2045 assert(type && "Type for variable must be valid!"); 2046 2047 if (!type.IsValid()) 2048 return NULL; 2049 2050 ClangASTContext *lldb_ast = 2051 llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); 2052 if (!lldb_ast) 2053 return NULL; 2054 2055 IdentifierInfo *ii = m_decl_name.getAsIdentifierInfo(); 2056 2057 clang::ASTContext *ast = lldb_ast->getASTContext(); 2058 2059 clang::NamedDecl *Decl = VarDecl::Create( 2060 *ast, const_cast<DeclContext *>(m_decl_context), SourceLocation(), 2061 SourceLocation(), ii, ClangUtil::GetQualType(type), 0, SC_Static); 2062 m_decls.push_back(Decl); 2063 2064 return Decl; 2065 } 2066 2067 clang::NamedDecl *NameSearchContext::AddFunDecl(const CompilerType &type, 2068 bool extern_c) { 2069 assert(type && "Type for variable must be valid!"); 2070 2071 if (!type.IsValid()) 2072 return NULL; 2073 2074 if (m_function_types.count(type)) 2075 return NULL; 2076 2077 ClangASTContext *lldb_ast = 2078 llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem()); 2079 if (!lldb_ast) 2080 return NULL; 2081 2082 m_function_types.insert(type); 2083 2084 QualType qual_type(ClangUtil::GetQualType(type)); 2085 2086 clang::ASTContext *ast = lldb_ast->getASTContext(); 2087 2088 const bool isInlineSpecified = false; 2089 const bool hasWrittenPrototype = true; 2090 const bool isConstexprSpecified = false; 2091 2092 clang::DeclContext *context = const_cast<DeclContext *>(m_decl_context); 2093 2094 if (extern_c) { 2095 context = LinkageSpecDecl::Create( 2096 *ast, context, SourceLocation(), SourceLocation(), 2097 clang::LinkageSpecDecl::LanguageIDs::lang_c, false); 2098 } 2099 2100 // Pass the identifier info for functions the decl_name is needed for 2101 // operators 2102 clang::DeclarationName decl_name = 2103 m_decl_name.getNameKind() == DeclarationName::Identifier 2104 ? m_decl_name.getAsIdentifierInfo() 2105 : m_decl_name; 2106 2107 clang::FunctionDecl *func_decl = FunctionDecl::Create( 2108 *ast, context, SourceLocation(), SourceLocation(), decl_name, qual_type, 2109 NULL, SC_Extern, isInlineSpecified, hasWrittenPrototype, 2110 isConstexprSpecified); 2111 2112 // We have to do more than just synthesize the FunctionDecl. We have to 2113 // synthesize ParmVarDecls for all of the FunctionDecl's arguments. To do 2114 // this, we raid the function's FunctionProtoType for types. 2115 2116 const FunctionProtoType *func_proto_type = 2117 qual_type.getTypePtr()->getAs<FunctionProtoType>(); 2118 2119 if (func_proto_type) { 2120 unsigned NumArgs = func_proto_type->getNumParams(); 2121 unsigned ArgIndex; 2122 2123 SmallVector<ParmVarDecl *, 5> parm_var_decls; 2124 2125 for (ArgIndex = 0; ArgIndex < NumArgs; ++ArgIndex) { 2126 QualType arg_qual_type(func_proto_type->getParamType(ArgIndex)); 2127 2128 parm_var_decls.push_back(ParmVarDecl::Create( 2129 *ast, const_cast<DeclContext *>(context), SourceLocation(), 2130 SourceLocation(), NULL, arg_qual_type, NULL, SC_Static, NULL)); 2131 } 2132 2133 func_decl->setParams(ArrayRef<ParmVarDecl *>(parm_var_decls)); 2134 } else { 2135 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 2136 2137 if (log) 2138 log->Printf("Function type wasn't a FunctionProtoType"); 2139 } 2140 2141 // If this is an operator (e.g. operator new or operator==), only insert the 2142 // declaration we inferred from the symbol if we can provide the correct 2143 // number of arguments. We shouldn't really inject random decl(s) for 2144 // functions that are analyzed semantically in a special way, otherwise we 2145 // will crash in clang. 2146 clang::OverloadedOperatorKind op_kind = clang::NUM_OVERLOADED_OPERATORS; 2147 if (func_proto_type && 2148 ClangASTContext::IsOperator(decl_name.getAsString().c_str(), op_kind)) { 2149 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount( 2150 false, op_kind, func_proto_type->getNumParams())) 2151 return NULL; 2152 } 2153 m_decls.push_back(func_decl); 2154 2155 return func_decl; 2156 } 2157 2158 clang::NamedDecl *NameSearchContext::AddGenericFunDecl() { 2159 FunctionProtoType::ExtProtoInfo proto_info; 2160 2161 proto_info.Variadic = true; 2162 2163 QualType generic_function_type(m_ast_source.m_ast_context->getFunctionType( 2164 m_ast_source.m_ast_context->UnknownAnyTy, // result 2165 ArrayRef<QualType>(), // argument types 2166 proto_info)); 2167 2168 return AddFunDecl( 2169 CompilerType(m_ast_source.m_ast_context, generic_function_type), true); 2170 } 2171 2172 clang::NamedDecl * 2173 NameSearchContext::AddTypeDecl(const CompilerType &clang_type) { 2174 if (ClangUtil::IsClangType(clang_type)) { 2175 QualType qual_type = ClangUtil::GetQualType(clang_type); 2176 2177 if (const TypedefType *typedef_type = 2178 llvm::dyn_cast<TypedefType>(qual_type)) { 2179 TypedefNameDecl *typedef_name_decl = typedef_type->getDecl(); 2180 2181 m_decls.push_back(typedef_name_decl); 2182 2183 return (NamedDecl *)typedef_name_decl; 2184 } else if (const TagType *tag_type = qual_type->getAs<TagType>()) { 2185 TagDecl *tag_decl = tag_type->getDecl(); 2186 2187 m_decls.push_back(tag_decl); 2188 2189 return tag_decl; 2190 } else if (const ObjCObjectType *objc_object_type = 2191 qual_type->getAs<ObjCObjectType>()) { 2192 ObjCInterfaceDecl *interface_decl = objc_object_type->getInterface(); 2193 2194 m_decls.push_back((NamedDecl *)interface_decl); 2195 2196 return (NamedDecl *)interface_decl; 2197 } 2198 } 2199 return NULL; 2200 } 2201 2202 void NameSearchContext::AddLookupResult(clang::DeclContextLookupResult result) { 2203 for (clang::NamedDecl *decl : result) 2204 m_decls.push_back(decl); 2205 } 2206 2207 void NameSearchContext::AddNamedDecl(clang::NamedDecl *decl) { 2208 m_decls.push_back(decl); 2209 } 2210