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