1 //===-- ClangASTImporter.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 "lldb/Symbol/ClangASTImporter.h" 11 #include "lldb/Core/Log.h" 12 #include "lldb/Core/Module.h" 13 #include "lldb/Symbol/ClangASTContext.h" 14 #include "lldb/Symbol/ClangExternalASTSourceCommon.h" 15 #include "lldb/Symbol/ClangUtil.h" 16 #include "lldb/Utility/LLDBAssert.h" 17 #include "clang/AST/Decl.h" 18 #include "clang/AST/DeclCXX.h" 19 #include "clang/AST/DeclObjC.h" 20 #include "llvm/Support/raw_ostream.h" 21 22 using namespace lldb_private; 23 using namespace clang; 24 25 ClangASTMetrics::Counters ClangASTMetrics::global_counters = { 0, 0, 0, 0, 0, 0 }; 26 ClangASTMetrics::Counters ClangASTMetrics::local_counters = { 0, 0, 0, 0, 0, 0 }; 27 28 void ClangASTMetrics::DumpCounters (Log *log, ClangASTMetrics::Counters &counters) 29 { 30 log->Printf(" Number of visible Decl queries by name : %" PRIu64, counters.m_visible_query_count); 31 log->Printf(" Number of lexical Decl queries : %" PRIu64, counters.m_lexical_query_count); 32 log->Printf(" Number of imports initiated by LLDB : %" PRIu64, counters.m_lldb_import_count); 33 log->Printf(" Number of imports conducted by Clang : %" PRIu64, counters.m_clang_import_count); 34 log->Printf(" Number of Decls completed : %" PRIu64, counters.m_decls_completed_count); 35 log->Printf(" Number of records laid out : %" PRIu64, counters.m_record_layout_count); 36 } 37 38 void ClangASTMetrics::DumpCounters (Log *log) 39 { 40 if (!log) 41 return; 42 43 log->Printf("== ClangASTMetrics output =="); 44 log->Printf("-- Global metrics --"); 45 DumpCounters (log, global_counters); 46 log->Printf("-- Local metrics --"); 47 DumpCounters (log, local_counters); 48 } 49 50 clang::QualType 51 ClangASTImporter::CopyType (clang::ASTContext *dst_ast, 52 clang::ASTContext *src_ast, 53 clang::QualType type) 54 { 55 MinionSP minion_sp (GetMinion(dst_ast, src_ast)); 56 57 if (minion_sp) 58 return minion_sp->Import(type); 59 60 return QualType(); 61 } 62 63 lldb::opaque_compiler_type_t 64 ClangASTImporter::CopyType (clang::ASTContext *dst_ast, 65 clang::ASTContext *src_ast, 66 lldb::opaque_compiler_type_t type) 67 { 68 return CopyType (dst_ast, src_ast, QualType::getFromOpaquePtr(type)).getAsOpaquePtr(); 69 } 70 71 CompilerType 72 ClangASTImporter::CopyType (ClangASTContext &dst_ast, 73 const CompilerType &src_type) 74 { 75 clang::ASTContext *dst_clang_ast = dst_ast.getASTContext(); 76 if (dst_clang_ast) 77 { 78 ClangASTContext *src_ast = llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem()); 79 if (src_ast) 80 { 81 clang::ASTContext *src_clang_ast = src_ast->getASTContext(); 82 if (src_clang_ast) 83 { 84 lldb::opaque_compiler_type_t dst_clang_type = CopyType(dst_clang_ast, 85 src_clang_ast, 86 src_type.GetOpaqueQualType()); 87 88 if (dst_clang_type) 89 return CompilerType(&dst_ast, dst_clang_type); 90 } 91 } 92 } 93 return CompilerType(); 94 } 95 96 clang::Decl * 97 ClangASTImporter::CopyDecl (clang::ASTContext *dst_ast, 98 clang::ASTContext *src_ast, 99 clang::Decl *decl) 100 { 101 MinionSP minion_sp; 102 103 minion_sp = GetMinion(dst_ast, src_ast); 104 105 if (minion_sp) 106 { 107 clang::Decl *result = minion_sp->Import(decl); 108 109 if (!result) 110 { 111 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 112 113 if (log) 114 { 115 lldb::user_id_t user_id = LLDB_INVALID_UID; 116 ClangASTMetadata *metadata = GetDeclMetadata(decl); 117 if (metadata) 118 user_id = metadata->GetUserID(); 119 120 if (NamedDecl *named_decl = dyn_cast<NamedDecl>(decl)) 121 log->Printf(" [ClangASTImporter] WARNING: Failed to import a %s '%s', metadata 0x%" PRIx64, 122 decl->getDeclKindName(), 123 named_decl->getNameAsString().c_str(), 124 user_id); 125 else 126 log->Printf(" [ClangASTImporter] WARNING: Failed to import a %s, metadata 0x%" PRIx64, 127 decl->getDeclKindName(), 128 user_id); 129 } 130 } 131 132 return result; 133 } 134 135 return nullptr; 136 } 137 138 class DeclContextOverride 139 { 140 private: 141 struct Backup 142 { 143 clang::DeclContext *decl_context; 144 clang::DeclContext *lexical_decl_context; 145 }; 146 147 std::map<clang::Decl *, Backup> m_backups; 148 149 void OverrideOne(clang::Decl *decl) 150 { 151 if (m_backups.find(decl) != m_backups.end()) 152 { 153 return; 154 } 155 156 m_backups[decl] = { decl->getDeclContext(), decl->getLexicalDeclContext() }; 157 158 decl->setDeclContext(decl->getASTContext().getTranslationUnitDecl()); 159 decl->setLexicalDeclContext(decl->getASTContext().getTranslationUnitDecl()); 160 } 161 162 bool ChainPassesThrough(clang::Decl *decl, 163 clang::DeclContext *base, 164 clang::DeclContext *(clang::Decl::*contextFromDecl)(), 165 clang::DeclContext *(clang::DeclContext::*contextFromContext)()) 166 { 167 for (DeclContext *decl_ctx = (decl->*contextFromDecl)(); 168 decl_ctx; 169 decl_ctx = (decl_ctx->*contextFromContext)()) 170 { 171 if (decl_ctx == base) 172 { 173 return true; 174 } 175 } 176 177 return false; 178 } 179 180 clang::Decl *GetEscapedChild(clang::Decl *decl, clang::DeclContext *base = nullptr) 181 { 182 if (base) 183 { 184 // decl's DeclContext chains must pass through base. 185 186 if (!ChainPassesThrough(decl, base, &clang::Decl::getDeclContext, &clang::DeclContext::getParent) || 187 !ChainPassesThrough(decl, base, &clang::Decl::getLexicalDeclContext, &clang::DeclContext::getLexicalParent)) 188 { 189 return decl; 190 } 191 } 192 else 193 { 194 base = clang::dyn_cast<clang::DeclContext>(decl); 195 196 if (!base) 197 { 198 return nullptr; 199 } 200 } 201 202 if (clang::DeclContext *context = clang::dyn_cast<clang::DeclContext>(decl)) 203 { 204 for (clang::Decl *decl : context->decls()) 205 { 206 if (clang::Decl *escaped_child = GetEscapedChild(decl)) 207 { 208 return escaped_child; 209 } 210 } 211 } 212 213 return nullptr; 214 } 215 216 void Override(clang::Decl *decl) 217 { 218 if (clang::Decl *escaped_child = GetEscapedChild(decl)) 219 { 220 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 221 222 if (log) 223 log->Printf(" [ClangASTImporter] DeclContextOverride couldn't override (%sDecl*)%p - its child (%sDecl*)%p escapes", 224 decl->getDeclKindName(), static_cast<void*>(decl), 225 escaped_child->getDeclKindName(), static_cast<void*>(escaped_child)); 226 lldbassert(0 && "Couldn't override!"); 227 } 228 229 OverrideOne(decl); 230 } 231 232 public: 233 DeclContextOverride() 234 { 235 } 236 237 void OverrideAllDeclsFromContainingFunction(clang::Decl *decl) 238 { 239 for (DeclContext *decl_context = decl->getLexicalDeclContext(); 240 decl_context; 241 decl_context = decl_context->getLexicalParent()) 242 { 243 DeclContext *redecl_context = decl_context->getRedeclContext(); 244 245 if (llvm::isa<FunctionDecl>(redecl_context) && 246 llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent())) 247 { 248 for (clang::Decl *child_decl : decl_context->decls()) 249 { 250 Override(child_decl); 251 } 252 } 253 } 254 } 255 256 ~DeclContextOverride() 257 { 258 for (const std::pair<clang::Decl *, Backup> &backup : m_backups) 259 { 260 backup.first->setDeclContext(backup.second.decl_context); 261 backup.first->setLexicalDeclContext(backup.second.lexical_decl_context); 262 } 263 } 264 }; 265 266 lldb::opaque_compiler_type_t 267 ClangASTImporter::DeportType (clang::ASTContext *dst_ctx, 268 clang::ASTContext *src_ctx, 269 lldb::opaque_compiler_type_t type) 270 { 271 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 272 273 if (log) 274 log->Printf(" [ClangASTImporter] DeportType called on (%sType*)0x%llx from (ASTContext*)%p to (ASTContext*)%p", 275 QualType::getFromOpaquePtr(type)->getTypeClassName(), (unsigned long long)type, 276 static_cast<void*>(src_ctx), 277 static_cast<void*>(dst_ctx)); 278 279 MinionSP minion_sp (GetMinion (dst_ctx, src_ctx)); 280 281 if (!minion_sp) 282 return nullptr; 283 284 std::set<NamedDecl *> decls_to_deport; 285 std::set<NamedDecl *> decls_already_deported; 286 287 DeclContextOverride decl_context_override; 288 289 if (const clang::TagType *tag_type = clang::QualType::getFromOpaquePtr(type)->getAs<TagType>()) 290 { 291 decl_context_override.OverrideAllDeclsFromContainingFunction(tag_type->getDecl()); 292 } 293 294 minion_sp->InitDeportWorkQueues(&decls_to_deport, 295 &decls_already_deported); 296 297 lldb::opaque_compiler_type_t result = CopyType(dst_ctx, src_ctx, type); 298 299 minion_sp->ExecuteDeportWorkQueues(); 300 301 if (!result) 302 return nullptr; 303 304 return result; 305 306 } 307 308 clang::Decl * 309 ClangASTImporter::DeportDecl (clang::ASTContext *dst_ctx, 310 clang::ASTContext *src_ctx, 311 clang::Decl *decl) 312 { 313 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 314 315 if (log) 316 log->Printf(" [ClangASTImporter] DeportDecl called on (%sDecl*)%p from (ASTContext*)%p to (ASTContext*)%p", 317 decl->getDeclKindName(), static_cast<void*>(decl), 318 static_cast<void*>(src_ctx), 319 static_cast<void*>(dst_ctx)); 320 321 MinionSP minion_sp (GetMinion (dst_ctx, src_ctx)); 322 323 if (!minion_sp) 324 return nullptr; 325 326 std::set<NamedDecl *> decls_to_deport; 327 std::set<NamedDecl *> decls_already_deported; 328 329 DeclContextOverride decl_context_override; 330 331 decl_context_override.OverrideAllDeclsFromContainingFunction(decl); 332 333 minion_sp->InitDeportWorkQueues(&decls_to_deport, 334 &decls_already_deported); 335 336 clang::Decl *result = CopyDecl(dst_ctx, src_ctx, decl); 337 338 minion_sp->ExecuteDeportWorkQueues(); 339 340 if (!result) 341 return nullptr; 342 343 if (log) 344 log->Printf(" [ClangASTImporter] DeportDecl deported (%sDecl*)%p to (%sDecl*)%p", 345 decl->getDeclKindName(), static_cast<void*>(decl), 346 result->getDeclKindName(), static_cast<void*>(result)); 347 348 return result; 349 } 350 351 bool 352 ClangASTImporter::CanImport(const CompilerType &type) 353 { 354 if (!ClangUtil::IsClangType(type)) 355 return false; 356 357 // TODO: remove external completion BOOL 358 // CompleteAndFetchChildren should get the Decl out and check for the 359 360 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); 361 362 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 363 switch (type_class) 364 { 365 case clang::Type::Record: 366 { 367 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 368 if (cxx_record_decl) 369 { 370 if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL)) 371 return true; 372 } 373 } 374 break; 375 376 case clang::Type::Enum: 377 { 378 clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl(); 379 if (enum_decl) 380 { 381 if (ResolveDeclOrigin(enum_decl, NULL, NULL)) 382 return true; 383 } 384 } 385 break; 386 387 case clang::Type::ObjCObject: 388 case clang::Type::ObjCInterface: 389 { 390 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); 391 if (objc_class_type) 392 { 393 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 394 // We currently can't complete objective C types through the newly added ASTContext 395 // because it only supports TagDecl objects right now... 396 if (class_interface_decl) 397 { 398 if (ResolveDeclOrigin(class_interface_decl, NULL, NULL)) 399 return true; 400 } 401 } 402 } 403 break; 404 405 case clang::Type::Typedef: 406 return CanImport(CompilerType( 407 type.GetTypeSystem(), 408 llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr())); 409 410 case clang::Type::Auto: 411 return CanImport(CompilerType(type.GetTypeSystem(), 412 llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr())); 413 414 case clang::Type::Elaborated: 415 return CanImport(CompilerType( 416 type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr())); 417 418 case clang::Type::Paren: 419 return CanImport(CompilerType(type.GetTypeSystem(), 420 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); 421 422 default: 423 break; 424 } 425 426 return false; 427 } 428 429 bool 430 ClangASTImporter::Import(const CompilerType &type) 431 { 432 if (!ClangUtil::IsClangType(type)) 433 return false; 434 // TODO: remove external completion BOOL 435 // CompleteAndFetchChildren should get the Decl out and check for the 436 437 clang::QualType qual_type(ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); 438 439 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 440 switch (type_class) 441 { 442 case clang::Type::Record: 443 { 444 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 445 if (cxx_record_decl) 446 { 447 if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL)) 448 return CompleteAndFetchChildren(qual_type); 449 } 450 } 451 break; 452 453 case clang::Type::Enum: 454 { 455 clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl(); 456 if (enum_decl) 457 { 458 if (ResolveDeclOrigin(enum_decl, NULL, NULL)) 459 return CompleteAndFetchChildren(qual_type); 460 } 461 } 462 break; 463 464 case clang::Type::ObjCObject: 465 case clang::Type::ObjCInterface: 466 { 467 const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type); 468 if (objc_class_type) 469 { 470 clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 471 // We currently can't complete objective C types through the newly added ASTContext 472 // because it only supports TagDecl objects right now... 473 if (class_interface_decl) 474 { 475 if (ResolveDeclOrigin(class_interface_decl, NULL, NULL)) 476 return CompleteAndFetchChildren(qual_type); 477 } 478 } 479 } 480 break; 481 482 case clang::Type::Typedef: 483 return Import(CompilerType( 484 type.GetTypeSystem(), 485 llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr())); 486 487 case clang::Type::Auto: 488 return Import(CompilerType(type.GetTypeSystem(), 489 llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr())); 490 491 case clang::Type::Elaborated: 492 return Import(CompilerType(type.GetTypeSystem(), 493 llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr())); 494 495 case clang::Type::Paren: 496 return Import(CompilerType(type.GetTypeSystem(), 497 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); 498 499 default: 500 break; 501 } 502 return false; 503 } 504 505 bool 506 ClangASTImporter::CompleteType(const CompilerType &compiler_type) 507 { 508 if (!CanImport(compiler_type)) 509 return false; 510 511 if (Import(compiler_type)) 512 { 513 ClangASTContext::CompleteTagDeclarationDefinition(compiler_type); 514 return true; 515 } 516 517 ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(), false); 518 return false; 519 } 520 521 bool 522 ClangASTImporter::LayoutRecordType(const clang::RecordDecl *record_decl, uint64_t &bit_size, uint64_t &alignment, 523 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, 524 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets, 525 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets) 526 { 527 RecordDeclToLayoutMap::iterator pos = m_record_decl_to_layout_map.find(record_decl); 528 bool success = false; 529 base_offsets.clear(); 530 vbase_offsets.clear(); 531 if (pos != m_record_decl_to_layout_map.end()) 532 { 533 bit_size = pos->second.bit_size; 534 alignment = pos->second.alignment; 535 field_offsets.swap(pos->second.field_offsets); 536 base_offsets.swap(pos->second.base_offsets); 537 vbase_offsets.swap(pos->second.vbase_offsets); 538 m_record_decl_to_layout_map.erase(pos); 539 success = true; 540 } 541 else 542 { 543 bit_size = 0; 544 alignment = 0; 545 field_offsets.clear(); 546 } 547 return success; 548 } 549 550 void 551 ClangASTImporter::InsertRecordDecl(clang::RecordDecl *decl, const LayoutInfo &layout) 552 { 553 m_record_decl_to_layout_map.insert(std::make_pair(decl, layout)); 554 } 555 556 void 557 ClangASTImporter::CompleteDecl (clang::Decl *decl) 558 { 559 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 560 561 if (log) 562 log->Printf(" [ClangASTImporter] CompleteDecl called on (%sDecl*)%p", 563 decl->getDeclKindName(), static_cast<void*>(decl)); 564 565 if (ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl)) 566 { 567 if (!interface_decl->getDefinition()) 568 { 569 interface_decl->startDefinition(); 570 CompleteObjCInterfaceDecl(interface_decl); 571 } 572 } 573 else if (ObjCProtocolDecl *protocol_decl = dyn_cast<ObjCProtocolDecl>(decl)) 574 { 575 if (!protocol_decl->getDefinition()) 576 protocol_decl->startDefinition(); 577 } 578 else if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl)) 579 { 580 if (!tag_decl->getDefinition() && !tag_decl->isBeingDefined()) 581 { 582 tag_decl->startDefinition(); 583 CompleteTagDecl(tag_decl); 584 tag_decl->setCompleteDefinition(true); 585 } 586 } 587 else 588 { 589 assert (0 && "CompleteDecl called on a Decl that can't be completed"); 590 } 591 } 592 593 bool 594 ClangASTImporter::CompleteTagDecl (clang::TagDecl *decl) 595 { 596 ClangASTMetrics::RegisterDeclCompletion(); 597 598 DeclOrigin decl_origin = GetDeclOrigin(decl); 599 600 if (!decl_origin.Valid()) 601 return false; 602 603 if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl)) 604 return false; 605 606 MinionSP minion_sp (GetMinion(&decl->getASTContext(), decl_origin.ctx)); 607 608 if (minion_sp) 609 minion_sp->ImportDefinitionTo(decl, decl_origin.decl); 610 611 return true; 612 } 613 614 bool 615 ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin_decl) 616 { 617 ClangASTMetrics::RegisterDeclCompletion(); 618 619 clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext(); 620 621 if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl)) 622 return false; 623 624 MinionSP minion_sp (GetMinion(&decl->getASTContext(), origin_ast_ctx)); 625 626 if (minion_sp) 627 minion_sp->ImportDefinitionTo(decl, origin_decl); 628 629 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 630 631 OriginMap &origins = context_md->m_origins; 632 633 origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl); 634 635 return true; 636 } 637 638 bool 639 ClangASTImporter::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl) 640 { 641 ClangASTMetrics::RegisterDeclCompletion(); 642 643 DeclOrigin decl_origin = GetDeclOrigin(interface_decl); 644 645 if (!decl_origin.Valid()) 646 return false; 647 648 if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl)) 649 return false; 650 651 MinionSP minion_sp (GetMinion(&interface_decl->getASTContext(), decl_origin.ctx)); 652 653 if (minion_sp) 654 minion_sp->ImportDefinitionTo(interface_decl, decl_origin.decl); 655 656 if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass()) 657 RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0)); 658 659 return true; 660 } 661 662 bool 663 ClangASTImporter::CompleteAndFetchChildren (clang::QualType type) 664 { 665 if (!RequireCompleteType(type)) 666 return false; 667 668 if (const TagType *tag_type = type->getAs<TagType>()) 669 { 670 TagDecl *tag_decl = tag_type->getDecl(); 671 672 DeclOrigin decl_origin = GetDeclOrigin(tag_decl); 673 674 if (!decl_origin.Valid()) 675 return false; 676 677 MinionSP minion_sp (GetMinion(&tag_decl->getASTContext(), decl_origin.ctx)); 678 679 TagDecl *origin_tag_decl = llvm::dyn_cast<TagDecl>(decl_origin.decl); 680 681 for (Decl *origin_child_decl : origin_tag_decl->decls()) 682 { 683 minion_sp->Import(origin_child_decl); 684 } 685 686 if (RecordDecl *record_decl = dyn_cast<RecordDecl>(origin_tag_decl)) 687 { 688 record_decl->setHasLoadedFieldsFromExternalStorage(true); 689 } 690 691 return true; 692 } 693 694 if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) 695 { 696 if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface()) 697 { 698 DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl); 699 700 if (!decl_origin.Valid()) 701 return false; 702 703 MinionSP minion_sp (GetMinion(&objc_interface_decl->getASTContext(), decl_origin.ctx)); 704 705 ObjCInterfaceDecl *origin_interface_decl = llvm::dyn_cast<ObjCInterfaceDecl>(decl_origin.decl); 706 707 for (Decl *origin_child_decl : origin_interface_decl->decls()) 708 { 709 minion_sp->Import(origin_child_decl); 710 } 711 712 return true; 713 } 714 else 715 { 716 return false; 717 } 718 } 719 720 return true; 721 } 722 723 724 bool 725 ClangASTImporter::RequireCompleteType (clang::QualType type) 726 { 727 if (type.isNull()) 728 return false; 729 730 if (const TagType *tag_type = type->getAs<TagType>()) 731 { 732 TagDecl *tag_decl = tag_type->getDecl(); 733 734 if (tag_decl->getDefinition() || tag_decl->isBeingDefined()) 735 return true; 736 737 return CompleteTagDecl(tag_decl); 738 } 739 if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) 740 { 741 if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface()) 742 return CompleteObjCInterfaceDecl(objc_interface_decl); 743 else 744 return false; 745 } 746 if (const ArrayType *array_type = type->getAsArrayTypeUnsafe()) 747 { 748 return RequireCompleteType(array_type->getElementType()); 749 } 750 if (const AtomicType *atomic_type = type->getAs<AtomicType>()) 751 { 752 return RequireCompleteType(atomic_type->getPointeeType()); 753 } 754 755 return true; 756 } 757 758 ClangASTMetadata * 759 ClangASTImporter::GetDeclMetadata (const clang::Decl *decl) 760 { 761 DeclOrigin decl_origin = GetDeclOrigin(decl); 762 763 if (decl_origin.Valid()) 764 return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl); 765 else 766 return ClangASTContext::GetMetadata(&decl->getASTContext(), decl); 767 } 768 769 ClangASTImporter::DeclOrigin 770 ClangASTImporter::GetDeclOrigin(const clang::Decl *decl) 771 { 772 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 773 774 OriginMap &origins = context_md->m_origins; 775 776 OriginMap::iterator iter = origins.find(decl); 777 778 if (iter != origins.end()) 779 return iter->second; 780 else 781 return DeclOrigin(); 782 } 783 784 void 785 ClangASTImporter::SetDeclOrigin (const clang::Decl *decl, clang::Decl *original_decl) 786 { 787 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 788 789 OriginMap &origins = context_md->m_origins; 790 791 OriginMap::iterator iter = origins.find(decl); 792 793 if (iter != origins.end()) 794 { 795 iter->second.decl = original_decl; 796 iter->second.ctx = &original_decl->getASTContext(); 797 } 798 else 799 { 800 origins[decl] = DeclOrigin(&original_decl->getASTContext(), original_decl); 801 } 802 } 803 804 void 805 ClangASTImporter::RegisterNamespaceMap(const clang::NamespaceDecl *decl, 806 NamespaceMapSP &namespace_map) 807 { 808 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 809 810 context_md->m_namespace_maps[decl] = namespace_map; 811 } 812 813 ClangASTImporter::NamespaceMapSP 814 ClangASTImporter::GetNamespaceMap(const clang::NamespaceDecl *decl) 815 { 816 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 817 818 NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps; 819 820 NamespaceMetaMap::iterator iter = namespace_maps.find(decl); 821 822 if (iter != namespace_maps.end()) 823 return iter->second; 824 else 825 return NamespaceMapSP(); 826 } 827 828 void 829 ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl) 830 { 831 assert (decl); 832 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 833 834 const DeclContext *parent_context = decl->getDeclContext(); 835 const NamespaceDecl *parent_namespace = dyn_cast<NamespaceDecl>(parent_context); 836 NamespaceMapSP parent_map; 837 838 if (parent_namespace) 839 parent_map = GetNamespaceMap(parent_namespace); 840 841 NamespaceMapSP new_map; 842 843 new_map.reset(new NamespaceMap); 844 845 if (context_md->m_map_completer) 846 { 847 std::string namespace_string = decl->getDeclName().getAsString(); 848 849 context_md->m_map_completer->CompleteNamespaceMap (new_map, ConstString(namespace_string.c_str()), parent_map); 850 } 851 852 context_md->m_namespace_maps[decl] = new_map; 853 } 854 855 void 856 ClangASTImporter::ForgetDestination (clang::ASTContext *dst_ast) 857 { 858 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 859 860 if (log) 861 log->Printf(" [ClangASTImporter] Forgetting destination (ASTContext*)%p", 862 static_cast<void*>(dst_ast)); 863 864 m_metadata_map.erase(dst_ast); 865 } 866 867 void 868 ClangASTImporter::ForgetSource (clang::ASTContext *dst_ast, clang::ASTContext *src_ast) 869 { 870 ASTContextMetadataSP md = MaybeGetContextMetadata (dst_ast); 871 872 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 873 874 if (log) 875 log->Printf(" [ClangASTImporter] Forgetting source->dest (ASTContext*)%p->(ASTContext*)%p", 876 static_cast<void*>(src_ast), static_cast<void*>(dst_ast)); 877 878 if (!md) 879 return; 880 881 md->m_minions.erase(src_ast); 882 883 for (OriginMap::iterator iter = md->m_origins.begin(); 884 iter != md->m_origins.end(); 885 ) 886 { 887 if (iter->second.ctx == src_ast) 888 md->m_origins.erase(iter++); 889 else 890 ++iter; 891 } 892 } 893 894 ClangASTImporter::MapCompleter::~MapCompleter () 895 { 896 return; 897 } 898 899 void 900 ClangASTImporter::Minion::InitDeportWorkQueues (std::set<clang::NamedDecl *> *decls_to_deport, 901 std::set<clang::NamedDecl *> *decls_already_deported) 902 { 903 assert(!m_decls_to_deport); 904 assert(!m_decls_already_deported); 905 906 m_decls_to_deport = decls_to_deport; 907 m_decls_already_deported = decls_already_deported; 908 } 909 910 void 911 ClangASTImporter::Minion::ExecuteDeportWorkQueues () 912 { 913 assert(m_decls_to_deport); 914 assert(m_decls_already_deported); 915 916 ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&getToContext()); 917 918 while (!m_decls_to_deport->empty()) 919 { 920 NamedDecl *decl = *m_decls_to_deport->begin(); 921 922 m_decls_already_deported->insert(decl); 923 m_decls_to_deport->erase(decl); 924 925 DeclOrigin &origin = to_context_md->m_origins[decl]; 926 UNUSED_IF_ASSERT_DISABLED(origin); 927 928 assert (origin.ctx == m_source_ctx); // otherwise we should never have added this 929 // because it doesn't need to be deported 930 931 Decl *original_decl = to_context_md->m_origins[decl].decl; 932 933 ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl); 934 935 if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl)) 936 { 937 if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl)) 938 { 939 if (original_tag_decl->isCompleteDefinition()) 940 { 941 ImportDefinitionTo(tag_decl, original_tag_decl); 942 tag_decl->setCompleteDefinition(true); 943 } 944 } 945 946 tag_decl->setHasExternalLexicalStorage(false); 947 tag_decl->setHasExternalVisibleStorage(false); 948 } 949 else if (ObjCContainerDecl *container_decl = dyn_cast<ObjCContainerDecl>(decl)) 950 { 951 container_decl->setHasExternalLexicalStorage(false); 952 container_decl->setHasExternalVisibleStorage(false); 953 } 954 955 to_context_md->m_origins.erase(decl); 956 } 957 958 m_decls_to_deport = nullptr; 959 m_decls_already_deported = nullptr; 960 } 961 962 void 963 ClangASTImporter::Minion::ImportDefinitionTo (clang::Decl *to, clang::Decl *from) 964 { 965 ASTImporter::Imported(from, to); 966 967 /* 968 if (to_objc_interface) 969 to_objc_interface->startDefinition(); 970 971 CXXRecordDecl *to_cxx_record = dyn_cast<CXXRecordDecl>(to); 972 973 if (to_cxx_record) 974 to_cxx_record->startDefinition(); 975 */ 976 977 ImportDefinition(from); 978 979 if (clang::TagDecl *to_tag = dyn_cast<clang::TagDecl>(to)) 980 { 981 if (clang::TagDecl *from_tag = dyn_cast<clang::TagDecl>(from)) 982 { 983 to_tag->setCompleteDefinition(from_tag->isCompleteDefinition()); 984 } 985 } 986 987 // If we're dealing with an Objective-C class, ensure that the inheritance has 988 // been set up correctly. The ASTImporter may not do this correctly if the 989 // class was originally sourced from symbols. 990 991 if (ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to)) 992 { 993 do 994 { 995 ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass(); 996 997 if (to_superclass) 998 break; // we're not going to override it if it's set 999 1000 ObjCInterfaceDecl *from_objc_interface = dyn_cast<ObjCInterfaceDecl>(from); 1001 1002 if (!from_objc_interface) 1003 break; 1004 1005 ObjCInterfaceDecl *from_superclass = from_objc_interface->getSuperClass(); 1006 1007 if (!from_superclass) 1008 break; 1009 1010 Decl *imported_from_superclass_decl = Import(from_superclass); 1011 1012 if (!imported_from_superclass_decl) 1013 break; 1014 1015 ObjCInterfaceDecl *imported_from_superclass = dyn_cast<ObjCInterfaceDecl>(imported_from_superclass_decl); 1016 1017 if (!imported_from_superclass) 1018 break; 1019 1020 if (!to_objc_interface->hasDefinition()) 1021 to_objc_interface->startDefinition(); 1022 1023 to_objc_interface->setSuperClass( 1024 m_source_ctx->getTrivialTypeSourceInfo(m_source_ctx->getObjCInterfaceType(imported_from_superclass))); 1025 } 1026 while (0); 1027 } 1028 } 1029 1030 clang::Decl * 1031 ClangASTImporter::Minion::Imported (clang::Decl *from, clang::Decl *to) 1032 { 1033 ClangASTMetrics::RegisterClangImport(); 1034 1035 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); 1036 1037 lldb::user_id_t user_id = LLDB_INVALID_UID; 1038 ClangASTMetadata *metadata = m_master.GetDeclMetadata(from); 1039 if (metadata) 1040 user_id = metadata->GetUserID(); 1041 1042 if (log) 1043 { 1044 if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from)) 1045 { 1046 std::string name_string; 1047 llvm::raw_string_ostream name_stream(name_string); 1048 from_named_decl->printName(name_stream); 1049 name_stream.flush(); 1050 1051 log->Printf(" [ClangASTImporter] Imported (%sDecl*)%p, named %s (from (Decl*)%p), metadata 0x%" PRIx64, 1052 from->getDeclKindName(), static_cast<void*>(to), 1053 name_string.c_str(), static_cast<void*>(from), 1054 user_id); 1055 } 1056 else 1057 { 1058 log->Printf(" [ClangASTImporter] Imported (%sDecl*)%p (from (Decl*)%p), metadata 0x%" PRIx64, 1059 from->getDeclKindName(), static_cast<void*>(to), 1060 static_cast<void*>(from), user_id); 1061 } 1062 } 1063 1064 ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&to->getASTContext()); 1065 ASTContextMetadataSP from_context_md = m_master.MaybeGetContextMetadata(m_source_ctx); 1066 1067 if (from_context_md) 1068 { 1069 OriginMap &origins = from_context_md->m_origins; 1070 1071 OriginMap::iterator origin_iter = origins.find(from); 1072 1073 if (origin_iter != origins.end()) 1074 { 1075 if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() || 1076 user_id != LLDB_INVALID_UID) 1077 { 1078 if (origin_iter->second.ctx != &to->getASTContext()) 1079 to_context_md->m_origins[to] = origin_iter->second; 1080 } 1081 1082 MinionSP direct_completer = m_master.GetMinion(&to->getASTContext(), origin_iter->second.ctx); 1083 1084 if (direct_completer.get() != this) 1085 direct_completer->ASTImporter::Imported(origin_iter->second.decl, to); 1086 1087 if (log) 1088 log->Printf(" [ClangASTImporter] Propagated origin (Decl*)%p/(ASTContext*)%p from (ASTContext*)%p to (ASTContext*)%p", 1089 static_cast<void*>(origin_iter->second.decl), 1090 static_cast<void*>(origin_iter->second.ctx), 1091 static_cast<void*>(&from->getASTContext()), 1092 static_cast<void*>(&to->getASTContext())); 1093 } 1094 else 1095 { 1096 if (m_decls_to_deport && m_decls_already_deported) 1097 { 1098 if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to)) 1099 { 1100 RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from); 1101 if (from_record_decl == nullptr || from_record_decl->isInjectedClassName() == false) 1102 { 1103 NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to); 1104 1105 if (!m_decls_already_deported->count(to_named_decl)) 1106 m_decls_to_deport->insert(to_named_decl); 1107 } 1108 } 1109 } 1110 1111 if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() || 1112 user_id != LLDB_INVALID_UID) 1113 { 1114 to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from); 1115 } 1116 1117 if (log) 1118 log->Printf(" [ClangASTImporter] Decl has no origin information in (ASTContext*)%p", 1119 static_cast<void*>(&from->getASTContext())); 1120 } 1121 1122 if (clang::NamespaceDecl *to_namespace = dyn_cast<clang::NamespaceDecl>(to)) 1123 { 1124 clang::NamespaceDecl *from_namespace = dyn_cast<clang::NamespaceDecl>(from); 1125 1126 NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps; 1127 1128 NamespaceMetaMap::iterator namespace_map_iter = namespace_maps.find(from_namespace); 1129 1130 if (namespace_map_iter != namespace_maps.end()) 1131 to_context_md->m_namespace_maps[to_namespace] = namespace_map_iter->second; 1132 } 1133 } 1134 else 1135 { 1136 to_context_md->m_origins[to] = DeclOrigin (m_source_ctx, from); 1137 1138 if (log) 1139 log->Printf(" [ClangASTImporter] Sourced origin (Decl*)%p/(ASTContext*)%p into (ASTContext*)%p", 1140 static_cast<void*>(from), 1141 static_cast<void*>(m_source_ctx), 1142 static_cast<void*>(&to->getASTContext())); 1143 } 1144 1145 if (TagDecl *from_tag_decl = dyn_cast<TagDecl>(from)) 1146 { 1147 TagDecl *to_tag_decl = dyn_cast<TagDecl>(to); 1148 1149 to_tag_decl->setHasExternalLexicalStorage(); 1150 to_tag_decl->setMustBuildLookupTable(); 1151 1152 if (log) 1153 log->Printf(" [ClangASTImporter] To is a TagDecl - attributes %s%s [%s->%s]", 1154 (to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""), 1155 (to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""), 1156 (from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"), 1157 (to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete")); 1158 } 1159 1160 if (isa<NamespaceDecl>(from)) 1161 { 1162 NamespaceDecl *to_namespace_decl = dyn_cast<NamespaceDecl>(to); 1163 1164 m_master.BuildNamespaceMap(to_namespace_decl); 1165 1166 to_namespace_decl->setHasExternalVisibleStorage(); 1167 } 1168 1169 if (isa<ObjCContainerDecl>(from)) 1170 { 1171 ObjCContainerDecl *to_container_decl = dyn_cast<ObjCContainerDecl>(to); 1172 1173 to_container_decl->setHasExternalLexicalStorage(); 1174 to_container_decl->setHasExternalVisibleStorage(); 1175 1176 /*to_interface_decl->setExternallyCompleted();*/ 1177 1178 if (log) 1179 { 1180 if (ObjCInterfaceDecl *to_interface_decl = llvm::dyn_cast<ObjCInterfaceDecl>(to_container_decl)) 1181 { 1182 log->Printf(" [ClangASTImporter] To is an ObjCInterfaceDecl - attributes %s%s%s", 1183 (to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""), 1184 (to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""), 1185 (to_interface_decl->hasDefinition() ? " HasDefinition" : "")); 1186 } 1187 else 1188 { 1189 log->Printf(" [ClangASTImporter] To is an %sDecl - attributes %s%s", 1190 ((Decl*)to_container_decl)->getDeclKindName(), 1191 (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""), 1192 (to_container_decl->hasExternalVisibleStorage() ? " Visible" : "")); 1193 } 1194 } 1195 } 1196 1197 return clang::ASTImporter::Imported(from, to); 1198 } 1199 1200 clang::Decl *ClangASTImporter::Minion::GetOriginalDecl (clang::Decl *To) 1201 { 1202 ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&To->getASTContext()); 1203 1204 if (!to_context_md) 1205 return nullptr; 1206 1207 OriginMap::iterator iter = to_context_md->m_origins.find(To); 1208 1209 if (iter == to_context_md->m_origins.end()) 1210 return nullptr; 1211 1212 return const_cast<clang::Decl*>(iter->second.decl); 1213 } 1214