1//===-- ClangASTImporter.cpp ----------------------------------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "lldb/Core/Module.h" 10#include "lldb/Utility/LLDBAssert.h" 11#include "lldb/Utility/LLDBLog.h" 12#include "lldb/Utility/Log.h" 13#include "clang/AST/Decl.h" 14#include "clang/AST/DeclCXX.h" 15#include "clang/AST/DeclObjC.h" 16#include "clang/Sema/Lookup.h" 17#include "clang/Sema/Sema.h" 18#include "llvm/Support/raw_ostream.h" 19 20#include "Plugins/ExpressionParser/Clang/ClangASTImporter.h" 21#include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h" 22#include "Plugins/ExpressionParser/Clang/ClangASTSource.h" 23#include "Plugins/ExpressionParser/Clang/ClangExternalASTSourceCallbacks.h" 24#include "Plugins/ExpressionParser/Clang/ClangUtil.h" 25#include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 26 27#include <memory> 28#include <optional> 29 30using namespace lldb_private; 31using namespace clang; 32 33CompilerType ClangASTImporter::CopyType(TypeSystemClang &dst_ast, 34 const CompilerType &src_type) { 35 clang::ASTContext &dst_clang_ast = dst_ast.getASTContext(); 36 37 auto src_ast = src_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>(); 38 if (!src_ast) 39 return CompilerType(); 40 41 clang::ASTContext &src_clang_ast = src_ast->getASTContext(); 42 43 clang::QualType src_qual_type = ClangUtil::GetQualType(src_type); 44 45 ImporterDelegateSP delegate_sp(GetDelegate(&dst_clang_ast, &src_clang_ast)); 46 if (!delegate_sp) 47 return CompilerType(); 48 49 ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp, &dst_clang_ast); 50 51 llvm::Expected<QualType> ret_or_error = delegate_sp->Import(src_qual_type); 52 if (!ret_or_error) { 53 Log *log = GetLog(LLDBLog::Expressions); 54 LLDB_LOG_ERROR(log, ret_or_error.takeError(), 55 "Couldn't import type: {0}"); 56 return CompilerType(); 57 } 58 59 lldb::opaque_compiler_type_t dst_clang_type = ret_or_error->getAsOpaquePtr(); 60 61 if (dst_clang_type) 62 return CompilerType(dst_ast.weak_from_this(), dst_clang_type); 63 return CompilerType(); 64} 65 66clang::Decl *ClangASTImporter::CopyDecl(clang::ASTContext *dst_ast, 67 clang::Decl *decl) { 68 ImporterDelegateSP delegate_sp; 69 70 clang::ASTContext *src_ast = &decl->getASTContext(); 71 delegate_sp = GetDelegate(dst_ast, src_ast); 72 73 ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp, dst_ast); 74 75 if (!delegate_sp) 76 return nullptr; 77 78 llvm::Expected<clang::Decl *> result = delegate_sp->Import(decl); 79 if (!result) { 80 Log *log = GetLog(LLDBLog::Expressions); 81 LLDB_LOG_ERROR(log, result.takeError(), "Couldn't import decl: {0}"); 82 if (log) { 83 lldb::user_id_t user_id = LLDB_INVALID_UID; 84 ClangASTMetadata *metadata = GetDeclMetadata(decl); 85 if (metadata) 86 user_id = metadata->GetUserID(); 87 88 if (NamedDecl *named_decl = dyn_cast<NamedDecl>(decl)) 89 LLDB_LOG(log, 90 " [ClangASTImporter] WARNING: Failed to import a {0} " 91 "'{1}', metadata {2}", 92 decl->getDeclKindName(), named_decl->getNameAsString(), 93 user_id); 94 else 95 LLDB_LOG(log, 96 " [ClangASTImporter] WARNING: Failed to import a {0}, " 97 "metadata {1}", 98 decl->getDeclKindName(), user_id); 99 } 100 return nullptr; 101 } 102 103 return *result; 104} 105 106class DeclContextOverride { 107private: 108 struct Backup { 109 clang::DeclContext *decl_context; 110 clang::DeclContext *lexical_decl_context; 111 }; 112 113 llvm::DenseMap<clang::Decl *, Backup> m_backups; 114 115 void OverrideOne(clang::Decl *decl) { 116 if (m_backups.contains(decl)) { 117 return; 118 } 119 120 m_backups[decl] = {decl->getDeclContext(), decl->getLexicalDeclContext()}; 121 122 decl->setDeclContext(decl->getASTContext().getTranslationUnitDecl()); 123 decl->setLexicalDeclContext(decl->getASTContext().getTranslationUnitDecl()); 124 } 125 126 bool ChainPassesThrough( 127 clang::Decl *decl, clang::DeclContext *base, 128 clang::DeclContext *(clang::Decl::*contextFromDecl)(), 129 clang::DeclContext *(clang::DeclContext::*contextFromContext)()) { 130 for (DeclContext *decl_ctx = (decl->*contextFromDecl)(); decl_ctx; 131 decl_ctx = (decl_ctx->*contextFromContext)()) { 132 if (decl_ctx == base) { 133 return true; 134 } 135 } 136 137 return false; 138 } 139 140 clang::Decl *GetEscapedChild(clang::Decl *decl, 141 clang::DeclContext *base = nullptr) { 142 if (base) { 143 // decl's DeclContext chains must pass through base. 144 145 if (!ChainPassesThrough(decl, base, &clang::Decl::getDeclContext, 146 &clang::DeclContext::getParent) || 147 !ChainPassesThrough(decl, base, &clang::Decl::getLexicalDeclContext, 148 &clang::DeclContext::getLexicalParent)) { 149 return decl; 150 } 151 } else { 152 base = clang::dyn_cast<clang::DeclContext>(decl); 153 154 if (!base) { 155 return nullptr; 156 } 157 } 158 159 if (clang::DeclContext *context = 160 clang::dyn_cast<clang::DeclContext>(decl)) { 161 for (clang::Decl *decl : context->decls()) { 162 if (clang::Decl *escaped_child = GetEscapedChild(decl)) { 163 return escaped_child; 164 } 165 } 166 } 167 168 return nullptr; 169 } 170 171 void Override(clang::Decl *decl) { 172 if (clang::Decl *escaped_child = GetEscapedChild(decl)) { 173 Log *log = GetLog(LLDBLog::Expressions); 174 175 LLDB_LOG(log, 176 " [ClangASTImporter] DeclContextOverride couldn't " 177 "override ({0}Decl*){1} - its child ({2}Decl*){3} escapes", 178 decl->getDeclKindName(), decl, escaped_child->getDeclKindName(), 179 escaped_child); 180 lldbassert(0 && "Couldn't override!"); 181 } 182 183 OverrideOne(decl); 184 } 185 186public: 187 DeclContextOverride() = default; 188 189 void OverrideAllDeclsFromContainingFunction(clang::Decl *decl) { 190 for (DeclContext *decl_context = decl->getLexicalDeclContext(); 191 decl_context; decl_context = decl_context->getLexicalParent()) { 192 DeclContext *redecl_context = decl_context->getRedeclContext(); 193 194 if (llvm::isa<FunctionDecl>(redecl_context) && 195 llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent())) { 196 for (clang::Decl *child_decl : decl_context->decls()) { 197 Override(child_decl); 198 } 199 } 200 } 201 } 202 203 ~DeclContextOverride() { 204 for (const std::pair<clang::Decl *, Backup> &backup : m_backups) { 205 backup.first->setDeclContext(backup.second.decl_context); 206 backup.first->setLexicalDeclContext(backup.second.lexical_decl_context); 207 } 208 } 209}; 210 211namespace { 212/// Completes all imported TagDecls at the end of the scope. 213/// 214/// While in a CompleteTagDeclsScope, every decl that could be completed will 215/// be completed at the end of the scope (including all Decls that are 216/// imported while completing the original Decls). 217class CompleteTagDeclsScope : public ClangASTImporter::NewDeclListener { 218 ClangASTImporter::ImporterDelegateSP m_delegate; 219 /// List of declarations in the target context that need to be completed. 220 /// Every declaration should only be completed once and therefore should only 221 /// be once in this list. 222 llvm::SetVector<NamedDecl *> m_decls_to_complete; 223 /// Set of declarations that already were successfully completed (not just 224 /// added to m_decls_to_complete). 225 llvm::SmallPtrSet<NamedDecl *, 32> m_decls_already_completed; 226 clang::ASTContext *m_dst_ctx; 227 clang::ASTContext *m_src_ctx; 228 ClangASTImporter &importer; 229 230public: 231 /// Constructs a CompleteTagDeclsScope. 232 /// \param importer The ClangASTImporter that we should observe. 233 /// \param dst_ctx The ASTContext to which Decls are imported. 234 /// \param src_ctx The ASTContext from which Decls are imported. 235 explicit CompleteTagDeclsScope(ClangASTImporter &importer, 236 clang::ASTContext *dst_ctx, 237 clang::ASTContext *src_ctx) 238 : m_delegate(importer.GetDelegate(dst_ctx, src_ctx)), m_dst_ctx(dst_ctx), 239 m_src_ctx(src_ctx), importer(importer) { 240 m_delegate->SetImportListener(this); 241 } 242 243 ~CompleteTagDeclsScope() override { 244 ClangASTImporter::ASTContextMetadataSP to_context_md = 245 importer.GetContextMetadata(m_dst_ctx); 246 247 // Complete all decls we collected until now. 248 while (!m_decls_to_complete.empty()) { 249 NamedDecl *decl = m_decls_to_complete.pop_back_val(); 250 m_decls_already_completed.insert(decl); 251 252 // The decl that should be completed has to be imported into the target 253 // context from some other context. 254 assert(to_context_md->hasOrigin(decl)); 255 // We should only complete decls coming from the source context. 256 assert(to_context_md->getOrigin(decl).ctx == m_src_ctx); 257 258 Decl *original_decl = to_context_md->getOrigin(decl).decl; 259 260 // Complete the decl now. 261 TypeSystemClang::GetCompleteDecl(m_src_ctx, original_decl); 262 if (auto *tag_decl = dyn_cast<TagDecl>(decl)) { 263 if (auto *original_tag_decl = dyn_cast<TagDecl>(original_decl)) { 264 if (original_tag_decl->isCompleteDefinition()) { 265 m_delegate->ImportDefinitionTo(tag_decl, original_tag_decl); 266 tag_decl->setCompleteDefinition(true); 267 } 268 } 269 270 tag_decl->setHasExternalLexicalStorage(false); 271 tag_decl->setHasExternalVisibleStorage(false); 272 } else if (auto *container_decl = dyn_cast<ObjCContainerDecl>(decl)) { 273 container_decl->setHasExternalLexicalStorage(false); 274 container_decl->setHasExternalVisibleStorage(false); 275 } 276 277 to_context_md->removeOrigin(decl); 278 } 279 280 // Stop listening to imported decls. We do this after clearing the 281 // Decls we needed to import to catch all Decls they might have pulled in. 282 m_delegate->RemoveImportListener(); 283 } 284 285 void NewDeclImported(clang::Decl *from, clang::Decl *to) override { 286 // Filter out decls that we can't complete later. 287 if (!isa<TagDecl>(to) && !isa<ObjCInterfaceDecl>(to)) 288 return; 289 RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from); 290 // We don't need to complete injected class name decls. 291 if (from_record_decl && from_record_decl->isInjectedClassName()) 292 return; 293 294 NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to); 295 // Check if we already completed this type. 296 if (m_decls_already_completed.contains(to_named_decl)) 297 return; 298 // Queue this type to be completed. 299 m_decls_to_complete.insert(to_named_decl); 300 } 301}; 302} // namespace 303 304CompilerType ClangASTImporter::DeportType(TypeSystemClang &dst, 305 const CompilerType &src_type) { 306 Log *log = GetLog(LLDBLog::Expressions); 307 308 auto src_ctxt = src_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>(); 309 if (!src_ctxt) 310 return {}; 311 312 LLDB_LOG(log, 313 " [ClangASTImporter] DeportType called on ({0}Type*){1} " 314 "from (ASTContext*){2} to (ASTContext*){3}", 315 src_type.GetTypeName(), src_type.GetOpaqueQualType(), 316 &src_ctxt->getASTContext(), &dst.getASTContext()); 317 318 DeclContextOverride decl_context_override; 319 320 if (auto *t = ClangUtil::GetQualType(src_type)->getAs<TagType>()) 321 decl_context_override.OverrideAllDeclsFromContainingFunction(t->getDecl()); 322 323 CompleteTagDeclsScope complete_scope(*this, &dst.getASTContext(), 324 &src_ctxt->getASTContext()); 325 return CopyType(dst, src_type); 326} 327 328clang::Decl *ClangASTImporter::DeportDecl(clang::ASTContext *dst_ctx, 329 clang::Decl *decl) { 330 Log *log = GetLog(LLDBLog::Expressions); 331 332 clang::ASTContext *src_ctx = &decl->getASTContext(); 333 LLDB_LOG(log, 334 " [ClangASTImporter] DeportDecl called on ({0}Decl*){1} from " 335 "(ASTContext*){2} to (ASTContext*){3}", 336 decl->getDeclKindName(), decl, src_ctx, dst_ctx); 337 338 DeclContextOverride decl_context_override; 339 340 decl_context_override.OverrideAllDeclsFromContainingFunction(decl); 341 342 clang::Decl *result; 343 { 344 CompleteTagDeclsScope complete_scope(*this, dst_ctx, src_ctx); 345 result = CopyDecl(dst_ctx, decl); 346 } 347 348 if (!result) 349 return nullptr; 350 351 LLDB_LOG(log, 352 " [ClangASTImporter] DeportDecl deported ({0}Decl*){1} to " 353 "({2}Decl*){3}", 354 decl->getDeclKindName(), decl, result->getDeclKindName(), result); 355 356 return result; 357} 358 359bool ClangASTImporter::CanImport(const CompilerType &type) { 360 if (!ClangUtil::IsClangType(type)) 361 return false; 362 363 clang::QualType qual_type( 364 ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); 365 366 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 367 switch (type_class) { 368 case clang::Type::Record: { 369 const clang::CXXRecordDecl *cxx_record_decl = 370 qual_type->getAsCXXRecordDecl(); 371 if (cxx_record_decl) { 372 if (GetDeclOrigin(cxx_record_decl).Valid()) 373 return true; 374 } 375 } break; 376 377 case clang::Type::Enum: { 378 clang::EnumDecl *enum_decl = 379 llvm::cast<clang::EnumType>(qual_type)->getDecl(); 380 if (enum_decl) { 381 if (GetDeclOrigin(enum_decl).Valid()) 382 return true; 383 } 384 } break; 385 386 case clang::Type::ObjCObject: 387 case clang::Type::ObjCInterface: { 388 const clang::ObjCObjectType *objc_class_type = 389 llvm::dyn_cast<clang::ObjCObjectType>(qual_type); 390 if (objc_class_type) { 391 clang::ObjCInterfaceDecl *class_interface_decl = 392 objc_class_type->getInterface(); 393 // We currently can't complete objective C types through the newly added 394 // ASTContext because it only supports TagDecl objects right now... 395 if (class_interface_decl) { 396 if (GetDeclOrigin(class_interface_decl).Valid()) 397 return true; 398 } 399 } 400 } break; 401 402 case clang::Type::Typedef: 403 return CanImport(CompilerType(type.GetTypeSystem(), 404 llvm::cast<clang::TypedefType>(qual_type) 405 ->getDecl() 406 ->getUnderlyingType() 407 .getAsOpaquePtr())); 408 409 case clang::Type::Auto: 410 return CanImport(CompilerType(type.GetTypeSystem(), 411 llvm::cast<clang::AutoType>(qual_type) 412 ->getDeducedType() 413 .getAsOpaquePtr())); 414 415 case clang::Type::Elaborated: 416 return CanImport(CompilerType(type.GetTypeSystem(), 417 llvm::cast<clang::ElaboratedType>(qual_type) 418 ->getNamedType() 419 .getAsOpaquePtr())); 420 421 case clang::Type::Paren: 422 return CanImport(CompilerType( 423 type.GetTypeSystem(), 424 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); 425 426 default: 427 break; 428 } 429 430 return false; 431} 432 433bool ClangASTImporter::Import(const CompilerType &type) { 434 if (!ClangUtil::IsClangType(type)) 435 return false; 436 437 clang::QualType qual_type( 438 ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type))); 439 440 const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 441 switch (type_class) { 442 case clang::Type::Record: { 443 const clang::CXXRecordDecl *cxx_record_decl = 444 qual_type->getAsCXXRecordDecl(); 445 if (cxx_record_decl) { 446 if (GetDeclOrigin(cxx_record_decl).Valid()) 447 return CompleteAndFetchChildren(qual_type); 448 } 449 } break; 450 451 case clang::Type::Enum: { 452 clang::EnumDecl *enum_decl = 453 llvm::cast<clang::EnumType>(qual_type)->getDecl(); 454 if (enum_decl) { 455 if (GetDeclOrigin(enum_decl).Valid()) 456 return CompleteAndFetchChildren(qual_type); 457 } 458 } break; 459 460 case clang::Type::ObjCObject: 461 case clang::Type::ObjCInterface: { 462 const clang::ObjCObjectType *objc_class_type = 463 llvm::dyn_cast<clang::ObjCObjectType>(qual_type); 464 if (objc_class_type) { 465 clang::ObjCInterfaceDecl *class_interface_decl = 466 objc_class_type->getInterface(); 467 // We currently can't complete objective C types through the newly added 468 // ASTContext because it only supports TagDecl objects right now... 469 if (class_interface_decl) { 470 if (GetDeclOrigin(class_interface_decl).Valid()) 471 return CompleteAndFetchChildren(qual_type); 472 } 473 } 474 } break; 475 476 case clang::Type::Typedef: 477 return Import(CompilerType(type.GetTypeSystem(), 478 llvm::cast<clang::TypedefType>(qual_type) 479 ->getDecl() 480 ->getUnderlyingType() 481 .getAsOpaquePtr())); 482 483 case clang::Type::Auto: 484 return Import(CompilerType(type.GetTypeSystem(), 485 llvm::cast<clang::AutoType>(qual_type) 486 ->getDeducedType() 487 .getAsOpaquePtr())); 488 489 case clang::Type::Elaborated: 490 return Import(CompilerType(type.GetTypeSystem(), 491 llvm::cast<clang::ElaboratedType>(qual_type) 492 ->getNamedType() 493 .getAsOpaquePtr())); 494 495 case clang::Type::Paren: 496 return Import(CompilerType( 497 type.GetTypeSystem(), 498 llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())); 499 500 default: 501 break; 502 } 503 return false; 504} 505 506bool ClangASTImporter::CompleteType(const CompilerType &compiler_type) { 507 if (!CanImport(compiler_type)) 508 return false; 509 510 if (Import(compiler_type)) { 511 TypeSystemClang::CompleteTagDeclarationDefinition(compiler_type); 512 return true; 513 } 514 515 TypeSystemClang::SetHasExternalStorage(compiler_type.GetOpaqueQualType(), 516 false); 517 return false; 518} 519 520bool ClangASTImporter::LayoutRecordType( 521 const clang::RecordDecl *record_decl, uint64_t &bit_size, 522 uint64_t &alignment, 523 llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets, 524 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> 525 &base_offsets, 526 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> 527 &vbase_offsets) { 528 RecordDeclToLayoutMap::iterator pos = 529 m_record_decl_to_layout_map.find(record_decl); 530 bool success = false; 531 base_offsets.clear(); 532 vbase_offsets.clear(); 533 if (pos != m_record_decl_to_layout_map.end()) { 534 bit_size = pos->second.bit_size; 535 alignment = pos->second.alignment; 536 field_offsets.swap(pos->second.field_offsets); 537 base_offsets.swap(pos->second.base_offsets); 538 vbase_offsets.swap(pos->second.vbase_offsets); 539 m_record_decl_to_layout_map.erase(pos); 540 success = true; 541 } else { 542 bit_size = 0; 543 alignment = 0; 544 field_offsets.clear(); 545 } 546 return success; 547} 548 549void ClangASTImporter::SetRecordLayout(clang::RecordDecl *decl, 550 const LayoutInfo &layout) { 551 m_record_decl_to_layout_map.insert(std::make_pair(decl, layout)); 552} 553 554bool ClangASTImporter::CompleteTagDecl(clang::TagDecl *decl) { 555 DeclOrigin decl_origin = GetDeclOrigin(decl); 556 557 if (!decl_origin.Valid()) 558 return false; 559 560 if (!TypeSystemClang::GetCompleteDecl(decl_origin.ctx, decl_origin.decl)) 561 return false; 562 563 ImporterDelegateSP delegate_sp( 564 GetDelegate(&decl->getASTContext(), decl_origin.ctx)); 565 566 ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp, 567 &decl->getASTContext()); 568 if (delegate_sp) 569 delegate_sp->ImportDefinitionTo(decl, decl_origin.decl); 570 571 return true; 572} 573 574bool ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl, 575 clang::TagDecl *origin_decl) { 576 clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext(); 577 578 if (!TypeSystemClang::GetCompleteDecl(origin_ast_ctx, origin_decl)) 579 return false; 580 581 ImporterDelegateSP delegate_sp( 582 GetDelegate(&decl->getASTContext(), origin_ast_ctx)); 583 584 if (delegate_sp) 585 delegate_sp->ImportDefinitionTo(decl, origin_decl); 586 587 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 588 589 context_md->setOrigin(decl, DeclOrigin(origin_ast_ctx, origin_decl)); 590 return true; 591} 592 593bool ClangASTImporter::CompleteObjCInterfaceDecl( 594 clang::ObjCInterfaceDecl *interface_decl) { 595 DeclOrigin decl_origin = GetDeclOrigin(interface_decl); 596 597 if (!decl_origin.Valid()) 598 return false; 599 600 if (!TypeSystemClang::GetCompleteDecl(decl_origin.ctx, decl_origin.decl)) 601 return false; 602 603 ImporterDelegateSP delegate_sp( 604 GetDelegate(&interface_decl->getASTContext(), decl_origin.ctx)); 605 606 if (delegate_sp) 607 delegate_sp->ImportDefinitionTo(interface_decl, decl_origin.decl); 608 609 if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass()) 610 RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0)); 611 612 return true; 613} 614 615bool ClangASTImporter::CompleteAndFetchChildren(clang::QualType type) { 616 if (!RequireCompleteType(type)) 617 return false; 618 619 Log *log = GetLog(LLDBLog::Expressions); 620 621 if (const TagType *tag_type = type->getAs<TagType>()) { 622 TagDecl *tag_decl = tag_type->getDecl(); 623 624 DeclOrigin decl_origin = GetDeclOrigin(tag_decl); 625 626 if (!decl_origin.Valid()) 627 return false; 628 629 ImporterDelegateSP delegate_sp( 630 GetDelegate(&tag_decl->getASTContext(), decl_origin.ctx)); 631 632 ASTImporterDelegate::CxxModuleScope std_scope(*delegate_sp, 633 &tag_decl->getASTContext()); 634 635 TagDecl *origin_tag_decl = llvm::dyn_cast<TagDecl>(decl_origin.decl); 636 637 for (Decl *origin_child_decl : origin_tag_decl->decls()) { 638 llvm::Expected<Decl *> imported_or_err = 639 delegate_sp->Import(origin_child_decl); 640 if (!imported_or_err) { 641 LLDB_LOG_ERROR(log, imported_or_err.takeError(), 642 "Couldn't import decl: {0}"); 643 return false; 644 } 645 } 646 647 if (RecordDecl *record_decl = dyn_cast<RecordDecl>(origin_tag_decl)) 648 record_decl->setHasLoadedFieldsFromExternalStorage(true); 649 650 return true; 651 } 652 653 if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) { 654 if (ObjCInterfaceDecl *objc_interface_decl = 655 objc_object_type->getInterface()) { 656 DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl); 657 658 if (!decl_origin.Valid()) 659 return false; 660 661 ImporterDelegateSP delegate_sp( 662 GetDelegate(&objc_interface_decl->getASTContext(), decl_origin.ctx)); 663 664 ObjCInterfaceDecl *origin_interface_decl = 665 llvm::dyn_cast<ObjCInterfaceDecl>(decl_origin.decl); 666 667 for (Decl *origin_child_decl : origin_interface_decl->decls()) { 668 llvm::Expected<Decl *> imported_or_err = 669 delegate_sp->Import(origin_child_decl); 670 if (!imported_or_err) { 671 LLDB_LOG_ERROR(log, imported_or_err.takeError(), 672 "Couldn't import decl: {0}"); 673 return false; 674 } 675 } 676 677 return true; 678 } 679 return false; 680 } 681 682 return true; 683} 684 685bool ClangASTImporter::RequireCompleteType(clang::QualType type) { 686 if (type.isNull()) 687 return false; 688 689 if (const TagType *tag_type = type->getAs<TagType>()) { 690 TagDecl *tag_decl = tag_type->getDecl(); 691 692 if (tag_decl->getDefinition() || tag_decl->isBeingDefined()) 693 return true; 694 695 return CompleteTagDecl(tag_decl); 696 } 697 if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>()) { 698 if (ObjCInterfaceDecl *objc_interface_decl = 699 objc_object_type->getInterface()) 700 return CompleteObjCInterfaceDecl(objc_interface_decl); 701 return false; 702 } 703 if (const ArrayType *array_type = type->getAsArrayTypeUnsafe()) 704 return RequireCompleteType(array_type->getElementType()); 705 if (const AtomicType *atomic_type = type->getAs<AtomicType>()) 706 return RequireCompleteType(atomic_type->getPointeeType()); 707 708 return true; 709} 710 711ClangASTMetadata *ClangASTImporter::GetDeclMetadata(const clang::Decl *decl) { 712 DeclOrigin decl_origin = GetDeclOrigin(decl); 713 714 if (decl_origin.Valid()) { 715 TypeSystemClang *ast = TypeSystemClang::GetASTContext(decl_origin.ctx); 716 return ast->GetMetadata(decl_origin.decl); 717 } 718 TypeSystemClang *ast = TypeSystemClang::GetASTContext(&decl->getASTContext()); 719 return ast->GetMetadata(decl); 720} 721 722ClangASTImporter::DeclOrigin 723ClangASTImporter::GetDeclOrigin(const clang::Decl *decl) { 724 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 725 726 return context_md->getOrigin(decl); 727} 728 729void ClangASTImporter::SetDeclOrigin(const clang::Decl *decl, 730 clang::Decl *original_decl) { 731 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 732 context_md->setOrigin( 733 decl, DeclOrigin(&original_decl->getASTContext(), original_decl)); 734} 735 736void ClangASTImporter::RegisterNamespaceMap(const clang::NamespaceDecl *decl, 737 NamespaceMapSP &namespace_map) { 738 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 739 740 context_md->m_namespace_maps[decl] = namespace_map; 741} 742 743ClangASTImporter::NamespaceMapSP 744ClangASTImporter::GetNamespaceMap(const clang::NamespaceDecl *decl) { 745 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 746 747 NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps; 748 749 NamespaceMetaMap::iterator iter = namespace_maps.find(decl); 750 751 if (iter != namespace_maps.end()) 752 return iter->second; 753 return NamespaceMapSP(); 754} 755 756void ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl) { 757 assert(decl); 758 ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext()); 759 760 const DeclContext *parent_context = decl->getDeclContext(); 761 const NamespaceDecl *parent_namespace = 762 dyn_cast<NamespaceDecl>(parent_context); 763 NamespaceMapSP parent_map; 764 765 if (parent_namespace) 766 parent_map = GetNamespaceMap(parent_namespace); 767 768 NamespaceMapSP new_map; 769 770 new_map = std::make_shared<NamespaceMap>(); 771 772 if (context_md->m_map_completer) { 773 std::string namespace_string = decl->getDeclName().getAsString(); 774 775 context_md->m_map_completer->CompleteNamespaceMap( 776 new_map, ConstString(namespace_string.c_str()), parent_map); 777 } 778 779 context_md->m_namespace_maps[decl] = new_map; 780} 781 782void ClangASTImporter::ForgetDestination(clang::ASTContext *dst_ast) { 783 Log *log = GetLog(LLDBLog::Expressions); 784 785 LLDB_LOG(log, 786 " [ClangASTImporter] Forgetting destination (ASTContext*){0}", 787 dst_ast); 788 789 m_metadata_map.erase(dst_ast); 790} 791 792void ClangASTImporter::ForgetSource(clang::ASTContext *dst_ast, 793 clang::ASTContext *src_ast) { 794 ASTContextMetadataSP md = MaybeGetContextMetadata(dst_ast); 795 796 Log *log = GetLog(LLDBLog::Expressions); 797 798 LLDB_LOG(log, 799 " [ClangASTImporter] Forgetting source->dest " 800 "(ASTContext*){0}->(ASTContext*){1}", 801 src_ast, dst_ast); 802 803 if (!md) 804 return; 805 806 md->m_delegates.erase(src_ast); 807 md->removeOriginsWithContext(src_ast); 808} 809 810ClangASTImporter::MapCompleter::~MapCompleter() = default; 811 812llvm::Expected<Decl *> 813ClangASTImporter::ASTImporterDelegate::ImportImpl(Decl *From) { 814 if (m_std_handler) { 815 std::optional<Decl *> D = m_std_handler->Import(From); 816 if (D) { 817 // Make sure we don't use this decl later to map it back to it's original 818 // decl. The decl the CxxModuleHandler created has nothing to do with 819 // the one from debug info, and linking those two would just cause the 820 // ASTImporter to try 'updating' the module decl with the minimal one from 821 // the debug info. 822 m_decls_to_ignore.insert(*D); 823 return *D; 824 } 825 } 826 827 // Check which ASTContext this declaration originally came from. 828 DeclOrigin origin = m_main.GetDeclOrigin(From); 829 830 // Prevent infinite recursion when the origin tracking contains a cycle. 831 assert(origin.decl != From && "Origin points to itself?"); 832 833 // If it originally came from the target ASTContext then we can just 834 // pretend that the original is the one we imported. This can happen for 835 // example when inspecting a persistent declaration from the scratch 836 // ASTContext (which will provide the declaration when parsing the 837 // expression and then we later try to copy the declaration back to the 838 // scratch ASTContext to store the result). 839 // Without this check we would ask the ASTImporter to import a declaration 840 // into the same ASTContext where it came from (which doesn't make a lot of 841 // sense). 842 if (origin.Valid() && origin.ctx == &getToContext()) { 843 RegisterImportedDecl(From, origin.decl); 844 return origin.decl; 845 } 846 847 // This declaration came originally from another ASTContext. Instead of 848 // copying our potentially incomplete 'From' Decl we instead go to the 849 // original ASTContext and copy the original to the target. This is not 850 // only faster than first completing our current decl and then copying it 851 // to the target, but it also prevents that indirectly copying the same 852 // declaration to the same target requires the ASTImporter to merge all 853 // the different decls that appear to come from different ASTContexts (even 854 // though all these different source ASTContexts just got a copy from 855 // one source AST). 856 if (origin.Valid()) { 857 auto R = m_main.CopyDecl(&getToContext(), origin.decl); 858 if (R) { 859 RegisterImportedDecl(From, R); 860 return R; 861 } 862 } 863 864 // If we have a forcefully completed type, try to find an actual definition 865 // for it in other modules. 866 const ClangASTMetadata *md = m_main.GetDeclMetadata(From); 867 auto *td = dyn_cast<TagDecl>(From); 868 if (td && md && md->IsForcefullyCompleted()) { 869 Log *log = GetLog(LLDBLog::Expressions); 870 LLDB_LOG(log, 871 "[ClangASTImporter] Searching for a complete definition of {0} in " 872 "other modules", 873 td->getName()); 874 Expected<DeclContext *> dc_or_err = ImportContext(td->getDeclContext()); 875 if (!dc_or_err) 876 return dc_or_err.takeError(); 877 Expected<DeclarationName> dn_or_err = Import(td->getDeclName()); 878 if (!dn_or_err) 879 return dn_or_err.takeError(); 880 DeclContext *dc = *dc_or_err; 881 DeclContext::lookup_result lr = dc->lookup(*dn_or_err); 882 for (clang::Decl *candidate : lr) { 883 if (candidate->getKind() == From->getKind()) { 884 RegisterImportedDecl(From, candidate); 885 m_decls_to_ignore.insert(candidate); 886 return candidate; 887 } 888 } 889 LLDB_LOG(log, "[ClangASTImporter] Complete definition not found"); 890 } 891 892 return ASTImporter::ImportImpl(From); 893} 894 895void ClangASTImporter::ASTImporterDelegate::ImportDefinitionTo( 896 clang::Decl *to, clang::Decl *from) { 897 // We might have a forward declaration from a shared library that we 898 // gave external lexical storage so that Clang asks us about the full 899 // definition when it needs it. In this case the ASTImporter isn't aware 900 // that the forward decl from the shared library is the actual import 901 // target but would create a second declaration that would then be defined. 902 // We want that 'to' is actually complete after this function so let's 903 // tell the ASTImporter that 'to' was imported from 'from'. 904 MapImported(from, to); 905 906 Log *log = GetLog(LLDBLog::Expressions); 907 908 if (llvm::Error err = ImportDefinition(from)) { 909 LLDB_LOG_ERROR(log, std::move(err), 910 "[ClangASTImporter] Error during importing definition: {0}"); 911 return; 912 } 913 914 if (clang::TagDecl *to_tag = dyn_cast<clang::TagDecl>(to)) { 915 if (clang::TagDecl *from_tag = dyn_cast<clang::TagDecl>(from)) { 916 to_tag->setCompleteDefinition(from_tag->isCompleteDefinition()); 917 918 if (Log *log_ast = GetLog(LLDBLog::AST)) { 919 std::string name_string; 920 if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from)) { 921 llvm::raw_string_ostream name_stream(name_string); 922 from_named_decl->printName(name_stream); 923 name_stream.flush(); 924 } 925 LLDB_LOG(log_ast, "==== [ClangASTImporter][TUDecl: {0}] Imported " 926 "({1}Decl*){2}, named {3} (from " 927 "(Decl*){4})", 928 static_cast<void *>(to->getTranslationUnitDecl()), 929 from->getDeclKindName(), static_cast<void *>(to), name_string, 930 static_cast<void *>(from)); 931 932 // Log the AST of the TU. 933 std::string ast_string; 934 llvm::raw_string_ostream ast_stream(ast_string); 935 to->getTranslationUnitDecl()->dump(ast_stream); 936 LLDB_LOG(log_ast, "{0}", ast_string); 937 } 938 } 939 } 940 941 // If we're dealing with an Objective-C class, ensure that the inheritance 942 // has been set up correctly. The ASTImporter may not do this correctly if 943 // the class was originally sourced from symbols. 944 945 if (ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to)) { 946 ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass(); 947 948 if (to_superclass) 949 return; // we're not going to override it if it's set 950 951 ObjCInterfaceDecl *from_objc_interface = dyn_cast<ObjCInterfaceDecl>(from); 952 953 if (!from_objc_interface) 954 return; 955 956 ObjCInterfaceDecl *from_superclass = from_objc_interface->getSuperClass(); 957 958 if (!from_superclass) 959 return; 960 961 llvm::Expected<Decl *> imported_from_superclass_decl = 962 Import(from_superclass); 963 964 if (!imported_from_superclass_decl) { 965 LLDB_LOG_ERROR(log, imported_from_superclass_decl.takeError(), 966 "Couldn't import decl: {0}"); 967 return; 968 } 969 970 ObjCInterfaceDecl *imported_from_superclass = 971 dyn_cast<ObjCInterfaceDecl>(*imported_from_superclass_decl); 972 973 if (!imported_from_superclass) 974 return; 975 976 if (!to_objc_interface->hasDefinition()) 977 to_objc_interface->startDefinition(); 978 979 to_objc_interface->setSuperClass(m_source_ctx->getTrivialTypeSourceInfo( 980 m_source_ctx->getObjCInterfaceType(imported_from_superclass))); 981 } 982} 983 984/// Takes a CXXMethodDecl and completes the return type if necessary. This 985/// is currently only necessary for virtual functions with covariant return 986/// types where Clang's CodeGen expects that the underlying records are already 987/// completed. 988static void MaybeCompleteReturnType(ClangASTImporter &importer, 989 CXXMethodDecl *to_method) { 990 if (!to_method->isVirtual()) 991 return; 992 QualType return_type = to_method->getReturnType(); 993 if (!return_type->isPointerType() && !return_type->isReferenceType()) 994 return; 995 996 clang::RecordDecl *rd = return_type->getPointeeType()->getAsRecordDecl(); 997 if (!rd) 998 return; 999 if (rd->getDefinition()) 1000 return; 1001 1002 importer.CompleteTagDecl(rd); 1003} 1004 1005/// Recreate a module with its parents in \p to_source and return its id. 1006static OptionalClangModuleID 1007RemapModule(OptionalClangModuleID from_id, 1008 ClangExternalASTSourceCallbacks &from_source, 1009 ClangExternalASTSourceCallbacks &to_source) { 1010 if (!from_id.HasValue()) 1011 return {}; 1012 clang::Module *module = from_source.getModule(from_id.GetValue()); 1013 OptionalClangModuleID parent = RemapModule( 1014 from_source.GetIDForModule(module->Parent), from_source, to_source); 1015 TypeSystemClang &to_ts = to_source.GetTypeSystem(); 1016 return to_ts.GetOrCreateClangModule(module->Name, parent, module->IsFramework, 1017 module->IsExplicit); 1018} 1019 1020void ClangASTImporter::ASTImporterDelegate::Imported(clang::Decl *from, 1021 clang::Decl *to) { 1022 Log *log = GetLog(LLDBLog::Expressions); 1023 1024 // Some decls shouldn't be tracked here because they were not created by 1025 // copying 'from' to 'to'. Just exit early for those. 1026 if (m_decls_to_ignore.count(to)) 1027 return; 1028 1029 // Transfer module ownership information. 1030 auto *from_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>( 1031 getFromContext().getExternalSource()); 1032 // Can also be a ClangASTSourceProxy. 1033 auto *to_source = llvm::dyn_cast_or_null<ClangExternalASTSourceCallbacks>( 1034 getToContext().getExternalSource()); 1035 if (from_source && to_source) { 1036 OptionalClangModuleID from_id(from->getOwningModuleID()); 1037 OptionalClangModuleID to_id = 1038 RemapModule(from_id, *from_source, *to_source); 1039 TypeSystemClang &to_ts = to_source->GetTypeSystem(); 1040 to_ts.SetOwningModule(to, to_id); 1041 } 1042 1043 lldb::user_id_t user_id = LLDB_INVALID_UID; 1044 ClangASTMetadata *metadata = m_main.GetDeclMetadata(from); 1045 if (metadata) 1046 user_id = metadata->GetUserID(); 1047 1048 if (log) { 1049 if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from)) { 1050 std::string name_string; 1051 llvm::raw_string_ostream name_stream(name_string); 1052 from_named_decl->printName(name_stream); 1053 name_stream.flush(); 1054 1055 LLDB_LOG(log, 1056 " [ClangASTImporter] Imported ({0}Decl*){1}, named {2} (from " 1057 "(Decl*){3}), metadata {4}", 1058 from->getDeclKindName(), to, name_string, from, user_id); 1059 } else { 1060 LLDB_LOG(log, 1061 " [ClangASTImporter] Imported ({0}Decl*){1} (from " 1062 "(Decl*){2}), metadata {3}", 1063 from->getDeclKindName(), to, from, user_id); 1064 } 1065 } 1066 1067 ASTContextMetadataSP to_context_md = 1068 m_main.GetContextMetadata(&to->getASTContext()); 1069 ASTContextMetadataSP from_context_md = 1070 m_main.MaybeGetContextMetadata(m_source_ctx); 1071 1072 if (from_context_md) { 1073 DeclOrigin origin = from_context_md->getOrigin(from); 1074 1075 if (origin.Valid()) { 1076 if (origin.ctx != &to->getASTContext()) { 1077 if (!to_context_md->hasOrigin(to) || user_id != LLDB_INVALID_UID) 1078 to_context_md->setOrigin(to, origin); 1079 1080 LLDB_LOG(log, 1081 " [ClangASTImporter] Propagated origin " 1082 "(Decl*){0}/(ASTContext*){1} from (ASTContext*){2} to " 1083 "(ASTContext*){3}", 1084 origin.decl, origin.ctx, &from->getASTContext(), 1085 &to->getASTContext()); 1086 } 1087 } else { 1088 if (m_new_decl_listener) 1089 m_new_decl_listener->NewDeclImported(from, to); 1090 1091 if (!to_context_md->hasOrigin(to) || user_id != LLDB_INVALID_UID) 1092 to_context_md->setOrigin(to, DeclOrigin(m_source_ctx, from)); 1093 1094 LLDB_LOG(log, 1095 " [ClangASTImporter] Decl has no origin information in " 1096 "(ASTContext*){0}", 1097 &from->getASTContext()); 1098 } 1099 1100 if (auto *to_namespace = dyn_cast<clang::NamespaceDecl>(to)) { 1101 auto *from_namespace = cast<clang::NamespaceDecl>(from); 1102 1103 NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps; 1104 1105 NamespaceMetaMap::iterator namespace_map_iter = 1106 namespace_maps.find(from_namespace); 1107 1108 if (namespace_map_iter != namespace_maps.end()) 1109 to_context_md->m_namespace_maps[to_namespace] = 1110 namespace_map_iter->second; 1111 } 1112 } else { 1113 to_context_md->setOrigin(to, DeclOrigin(m_source_ctx, from)); 1114 1115 LLDB_LOG(log, 1116 " [ClangASTImporter] Sourced origin " 1117 "(Decl*){0}/(ASTContext*){1} into (ASTContext*){2}", 1118 from, m_source_ctx, &to->getASTContext()); 1119 } 1120 1121 if (auto *to_tag_decl = dyn_cast<TagDecl>(to)) { 1122 to_tag_decl->setHasExternalLexicalStorage(); 1123 to_tag_decl->getPrimaryContext()->setMustBuildLookupTable(); 1124 auto from_tag_decl = cast<TagDecl>(from); 1125 1126 LLDB_LOG( 1127 log, 1128 " [ClangASTImporter] To is a TagDecl - attributes {0}{1} [{2}->{3}]", 1129 (to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""), 1130 (to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""), 1131 (from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"), 1132 (to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete")); 1133 } 1134 1135 if (auto *to_namespace_decl = dyn_cast<NamespaceDecl>(to)) { 1136 m_main.BuildNamespaceMap(to_namespace_decl); 1137 to_namespace_decl->setHasExternalVisibleStorage(); 1138 } 1139 1140 if (auto *to_container_decl = dyn_cast<ObjCContainerDecl>(to)) { 1141 to_container_decl->setHasExternalLexicalStorage(); 1142 to_container_decl->setHasExternalVisibleStorage(); 1143 1144 if (log) { 1145 if (ObjCInterfaceDecl *to_interface_decl = 1146 llvm::dyn_cast<ObjCInterfaceDecl>(to_container_decl)) { 1147 LLDB_LOG( 1148 log, 1149 " [ClangASTImporter] To is an ObjCInterfaceDecl - attributes " 1150 "{0}{1}{2}", 1151 (to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""), 1152 (to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""), 1153 (to_interface_decl->hasDefinition() ? " HasDefinition" : "")); 1154 } else { 1155 LLDB_LOG( 1156 log, " [ClangASTImporter] To is an {0}Decl - attributes {1}{2}", 1157 ((Decl *)to_container_decl)->getDeclKindName(), 1158 (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""), 1159 (to_container_decl->hasExternalVisibleStorage() ? " Visible" : "")); 1160 } 1161 } 1162 } 1163 1164 if (clang::CXXMethodDecl *to_method = dyn_cast<CXXMethodDecl>(to)) 1165 MaybeCompleteReturnType(m_main, to_method); 1166} 1167 1168clang::Decl * 1169ClangASTImporter::ASTImporterDelegate::GetOriginalDecl(clang::Decl *To) { 1170 return m_main.GetDeclOrigin(To).decl; 1171} 1172