1 //===--- ASTUnit.cpp - ASTUnit utility --------------------------*- 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 // ASTUnit Implementation. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Frontend/ASTUnit.h" 15 #include "clang/AST/ASTConsumer.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/DeclVisitor.h" 18 #include "clang/AST/StmtVisitor.h" 19 #include "clang/AST/TypeOrdering.h" 20 #include "clang/Basic/Diagnostic.h" 21 #include "clang/Basic/TargetInfo.h" 22 #include "clang/Basic/TargetOptions.h" 23 #include "clang/Basic/VirtualFileSystem.h" 24 #include "clang/Frontend/CompilerInstance.h" 25 #include "clang/Frontend/FrontendActions.h" 26 #include "clang/Frontend/FrontendDiagnostic.h" 27 #include "clang/Frontend/FrontendOptions.h" 28 #include "clang/Frontend/MultiplexConsumer.h" 29 #include "clang/Frontend/Utils.h" 30 #include "clang/Lex/HeaderSearch.h" 31 #include "clang/Lex/Preprocessor.h" 32 #include "clang/Lex/PreprocessorOptions.h" 33 #include "clang/Sema/Sema.h" 34 #include "clang/Serialization/ASTReader.h" 35 #include "clang/Serialization/ASTWriter.h" 36 #include "llvm/ADT/ArrayRef.h" 37 #include "llvm/ADT/StringExtras.h" 38 #include "llvm/ADT/StringSet.h" 39 #include "llvm/Support/CrashRecoveryContext.h" 40 #include "llvm/Support/Host.h" 41 #include "llvm/Support/MemoryBuffer.h" 42 #include "llvm/Support/Mutex.h" 43 #include "llvm/Support/MutexGuard.h" 44 #include "llvm/Support/Path.h" 45 #include "llvm/Support/Timer.h" 46 #include "llvm/Support/raw_ostream.h" 47 #include <atomic> 48 #include <cstdio> 49 #include <cstdlib> 50 51 using namespace clang; 52 53 using llvm::TimeRecord; 54 55 namespace { 56 class SimpleTimer { 57 bool WantTiming; 58 TimeRecord Start; 59 std::string Output; 60 61 public: 62 explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) { 63 if (WantTiming) 64 Start = TimeRecord::getCurrentTime(); 65 } 66 67 void setOutput(const Twine &Output) { 68 if (WantTiming) 69 this->Output = Output.str(); 70 } 71 72 ~SimpleTimer() { 73 if (WantTiming) { 74 TimeRecord Elapsed = TimeRecord::getCurrentTime(); 75 Elapsed -= Start; 76 llvm::errs() << Output << ':'; 77 Elapsed.print(Elapsed, llvm::errs()); 78 llvm::errs() << '\n'; 79 } 80 } 81 }; 82 83 struct OnDiskData { 84 /// \brief The file in which the precompiled preamble is stored. 85 std::string PreambleFile; 86 87 /// \brief Temporary files that should be removed when the ASTUnit is 88 /// destroyed. 89 SmallVector<std::string, 4> TemporaryFiles; 90 91 /// \brief Erase temporary files. 92 void CleanTemporaryFiles(); 93 94 /// \brief Erase the preamble file. 95 void CleanPreambleFile(); 96 97 /// \brief Erase temporary files and the preamble file. 98 void Cleanup(); 99 }; 100 } 101 102 static llvm::sys::SmartMutex<false> &getOnDiskMutex() { 103 static llvm::sys::SmartMutex<false> M(/* recursive = */ true); 104 return M; 105 } 106 107 static void cleanupOnDiskMapAtExit(); 108 109 typedef llvm::DenseMap<const ASTUnit *, 110 std::unique_ptr<OnDiskData>> OnDiskDataMap; 111 static OnDiskDataMap &getOnDiskDataMap() { 112 static OnDiskDataMap M; 113 static bool hasRegisteredAtExit = false; 114 if (!hasRegisteredAtExit) { 115 hasRegisteredAtExit = true; 116 atexit(cleanupOnDiskMapAtExit); 117 } 118 return M; 119 } 120 121 static void cleanupOnDiskMapAtExit() { 122 // Use the mutex because there can be an alive thread destroying an ASTUnit. 123 llvm::MutexGuard Guard(getOnDiskMutex()); 124 for (const auto &I : getOnDiskDataMap()) { 125 // We don't worry about freeing the memory associated with OnDiskDataMap. 126 // All we care about is erasing stale files. 127 I.second->Cleanup(); 128 } 129 } 130 131 static OnDiskData &getOnDiskData(const ASTUnit *AU) { 132 // We require the mutex since we are modifying the structure of the 133 // DenseMap. 134 llvm::MutexGuard Guard(getOnDiskMutex()); 135 OnDiskDataMap &M = getOnDiskDataMap(); 136 auto &D = M[AU]; 137 if (!D) 138 D = llvm::make_unique<OnDiskData>(); 139 return *D; 140 } 141 142 static void erasePreambleFile(const ASTUnit *AU) { 143 getOnDiskData(AU).CleanPreambleFile(); 144 } 145 146 static void removeOnDiskEntry(const ASTUnit *AU) { 147 // We require the mutex since we are modifying the structure of the 148 // DenseMap. 149 llvm::MutexGuard Guard(getOnDiskMutex()); 150 OnDiskDataMap &M = getOnDiskDataMap(); 151 OnDiskDataMap::iterator I = M.find(AU); 152 if (I != M.end()) { 153 I->second->Cleanup(); 154 M.erase(I); 155 } 156 } 157 158 static void setPreambleFile(const ASTUnit *AU, StringRef preambleFile) { 159 getOnDiskData(AU).PreambleFile = preambleFile; 160 } 161 162 static const std::string &getPreambleFile(const ASTUnit *AU) { 163 return getOnDiskData(AU).PreambleFile; 164 } 165 166 void OnDiskData::CleanTemporaryFiles() { 167 for (StringRef File : TemporaryFiles) 168 llvm::sys::fs::remove(File); 169 TemporaryFiles.clear(); 170 } 171 172 void OnDiskData::CleanPreambleFile() { 173 if (!PreambleFile.empty()) { 174 llvm::sys::fs::remove(PreambleFile); 175 PreambleFile.clear(); 176 } 177 } 178 179 void OnDiskData::Cleanup() { 180 CleanTemporaryFiles(); 181 CleanPreambleFile(); 182 } 183 184 struct ASTUnit::ASTWriterData { 185 SmallString<128> Buffer; 186 llvm::BitstreamWriter Stream; 187 ASTWriter Writer; 188 189 ASTWriterData() : Stream(Buffer), Writer(Stream, { }) { } 190 }; 191 192 void ASTUnit::clearFileLevelDecls() { 193 llvm::DeleteContainerSeconds(FileDecls); 194 } 195 196 void ASTUnit::CleanTemporaryFiles() { 197 getOnDiskData(this).CleanTemporaryFiles(); 198 } 199 200 void ASTUnit::addTemporaryFile(StringRef TempFile) { 201 getOnDiskData(this).TemporaryFiles.push_back(TempFile); 202 } 203 204 /// \brief After failing to build a precompiled preamble (due to 205 /// errors in the source that occurs in the preamble), the number of 206 /// reparses during which we'll skip even trying to precompile the 207 /// preamble. 208 const unsigned DefaultPreambleRebuildInterval = 5; 209 210 /// \brief Tracks the number of ASTUnit objects that are currently active. 211 /// 212 /// Used for debugging purposes only. 213 static std::atomic<unsigned> ActiveASTUnitObjects; 214 215 ASTUnit::ASTUnit(bool _MainFileIsAST) 216 : Reader(nullptr), HadModuleLoaderFatalFailure(false), 217 OnlyLocalDecls(false), CaptureDiagnostics(false), 218 MainFileIsAST(_MainFileIsAST), 219 TUKind(TU_Complete), WantTiming(getenv("LIBCLANG_TIMING")), 220 OwnsRemappedFileBuffers(true), 221 NumStoredDiagnosticsFromDriver(0), 222 PreambleRebuildCounter(0), 223 NumWarningsInPreamble(0), 224 ShouldCacheCodeCompletionResults(false), 225 IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false), 226 CompletionCacheTopLevelHashValue(0), 227 PreambleTopLevelHashValue(0), 228 CurrentTopLevelHashValue(0), 229 UnsafeToFree(false) { 230 if (getenv("LIBCLANG_OBJTRACKING")) 231 fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects); 232 } 233 234 ASTUnit::~ASTUnit() { 235 // If we loaded from an AST file, balance out the BeginSourceFile call. 236 if (MainFileIsAST && getDiagnostics().getClient()) { 237 getDiagnostics().getClient()->EndSourceFile(); 238 } 239 240 clearFileLevelDecls(); 241 242 // Clean up the temporary files and the preamble file. 243 removeOnDiskEntry(this); 244 245 // Free the buffers associated with remapped files. We are required to 246 // perform this operation here because we explicitly request that the 247 // compiler instance *not* free these buffers for each invocation of the 248 // parser. 249 if (Invocation.get() && OwnsRemappedFileBuffers) { 250 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 251 for (const auto &RB : PPOpts.RemappedFileBuffers) 252 delete RB.second; 253 } 254 255 ClearCachedCompletionResults(); 256 257 if (getenv("LIBCLANG_OBJTRACKING")) 258 fprintf(stderr, "--- %u translation units\n", --ActiveASTUnitObjects); 259 } 260 261 void ASTUnit::setPreprocessor(Preprocessor *pp) { PP = pp; } 262 263 /// \brief Determine the set of code-completion contexts in which this 264 /// declaration should be shown. 265 static unsigned getDeclShowContexts(const NamedDecl *ND, 266 const LangOptions &LangOpts, 267 bool &IsNestedNameSpecifier) { 268 IsNestedNameSpecifier = false; 269 270 if (isa<UsingShadowDecl>(ND)) 271 ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl()); 272 if (!ND) 273 return 0; 274 275 uint64_t Contexts = 0; 276 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) || 277 isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) { 278 // Types can appear in these contexts. 279 if (LangOpts.CPlusPlus || !isa<TagDecl>(ND)) 280 Contexts |= (1LL << CodeCompletionContext::CCC_TopLevel) 281 | (1LL << CodeCompletionContext::CCC_ObjCIvarList) 282 | (1LL << CodeCompletionContext::CCC_ClassStructUnion) 283 | (1LL << CodeCompletionContext::CCC_Statement) 284 | (1LL << CodeCompletionContext::CCC_Type) 285 | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); 286 287 // In C++, types can appear in expressions contexts (for functional casts). 288 if (LangOpts.CPlusPlus) 289 Contexts |= (1LL << CodeCompletionContext::CCC_Expression); 290 291 // In Objective-C, message sends can send interfaces. In Objective-C++, 292 // all types are available due to functional casts. 293 if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND)) 294 Contexts |= (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); 295 296 // In Objective-C, you can only be a subclass of another Objective-C class 297 if (isa<ObjCInterfaceDecl>(ND)) 298 Contexts |= (1LL << CodeCompletionContext::CCC_ObjCInterfaceName); 299 300 // Deal with tag names. 301 if (isa<EnumDecl>(ND)) { 302 Contexts |= (1LL << CodeCompletionContext::CCC_EnumTag); 303 304 // Part of the nested-name-specifier in C++0x. 305 if (LangOpts.CPlusPlus11) 306 IsNestedNameSpecifier = true; 307 } else if (const RecordDecl *Record = dyn_cast<RecordDecl>(ND)) { 308 if (Record->isUnion()) 309 Contexts |= (1LL << CodeCompletionContext::CCC_UnionTag); 310 else 311 Contexts |= (1LL << CodeCompletionContext::CCC_ClassOrStructTag); 312 313 if (LangOpts.CPlusPlus) 314 IsNestedNameSpecifier = true; 315 } else if (isa<ClassTemplateDecl>(ND)) 316 IsNestedNameSpecifier = true; 317 } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 318 // Values can appear in these contexts. 319 Contexts = (1LL << CodeCompletionContext::CCC_Statement) 320 | (1LL << CodeCompletionContext::CCC_Expression) 321 | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) 322 | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver); 323 } else if (isa<ObjCProtocolDecl>(ND)) { 324 Contexts = (1LL << CodeCompletionContext::CCC_ObjCProtocolName); 325 } else if (isa<ObjCCategoryDecl>(ND)) { 326 Contexts = (1LL << CodeCompletionContext::CCC_ObjCCategoryName); 327 } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) { 328 Contexts = (1LL << CodeCompletionContext::CCC_Namespace); 329 330 // Part of the nested-name-specifier. 331 IsNestedNameSpecifier = true; 332 } 333 334 return Contexts; 335 } 336 337 void ASTUnit::CacheCodeCompletionResults() { 338 if (!TheSema) 339 return; 340 341 SimpleTimer Timer(WantTiming); 342 Timer.setOutput("Cache global code completions for " + getMainFileName()); 343 344 // Clear out the previous results. 345 ClearCachedCompletionResults(); 346 347 // Gather the set of global code completions. 348 typedef CodeCompletionResult Result; 349 SmallVector<Result, 8> Results; 350 CachedCompletionAllocator = new GlobalCodeCompletionAllocator; 351 CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator); 352 TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, 353 CCTUInfo, Results); 354 355 // Translate global code completions into cached completions. 356 llvm::DenseMap<CanQualType, unsigned> CompletionTypes; 357 CodeCompletionContext CCContext(CodeCompletionContext::CCC_TopLevel); 358 359 for (Result &R : Results) { 360 switch (R.Kind) { 361 case Result::RK_Declaration: { 362 bool IsNestedNameSpecifier = false; 363 CachedCodeCompletionResult CachedResult; 364 CachedResult.Completion = R.CreateCodeCompletionString( 365 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo, 366 IncludeBriefCommentsInCodeCompletion); 367 CachedResult.ShowInContexts = getDeclShowContexts( 368 R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier); 369 CachedResult.Priority = R.Priority; 370 CachedResult.Kind = R.CursorKind; 371 CachedResult.Availability = R.Availability; 372 373 // Keep track of the type of this completion in an ASTContext-agnostic 374 // way. 375 QualType UsageType = getDeclUsageType(*Ctx, R.Declaration); 376 if (UsageType.isNull()) { 377 CachedResult.TypeClass = STC_Void; 378 CachedResult.Type = 0; 379 } else { 380 CanQualType CanUsageType 381 = Ctx->getCanonicalType(UsageType.getUnqualifiedType()); 382 CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType); 383 384 // Determine whether we have already seen this type. If so, we save 385 // ourselves the work of formatting the type string by using the 386 // temporary, CanQualType-based hash table to find the associated value. 387 unsigned &TypeValue = CompletionTypes[CanUsageType]; 388 if (TypeValue == 0) { 389 TypeValue = CompletionTypes.size(); 390 CachedCompletionTypes[QualType(CanUsageType).getAsString()] 391 = TypeValue; 392 } 393 394 CachedResult.Type = TypeValue; 395 } 396 397 CachedCompletionResults.push_back(CachedResult); 398 399 /// Handle nested-name-specifiers in C++. 400 if (TheSema->Context.getLangOpts().CPlusPlus && IsNestedNameSpecifier && 401 !R.StartsNestedNameSpecifier) { 402 // The contexts in which a nested-name-specifier can appear in C++. 403 uint64_t NNSContexts 404 = (1LL << CodeCompletionContext::CCC_TopLevel) 405 | (1LL << CodeCompletionContext::CCC_ObjCIvarList) 406 | (1LL << CodeCompletionContext::CCC_ClassStructUnion) 407 | (1LL << CodeCompletionContext::CCC_Statement) 408 | (1LL << CodeCompletionContext::CCC_Expression) 409 | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) 410 | (1LL << CodeCompletionContext::CCC_EnumTag) 411 | (1LL << CodeCompletionContext::CCC_UnionTag) 412 | (1LL << CodeCompletionContext::CCC_ClassOrStructTag) 413 | (1LL << CodeCompletionContext::CCC_Type) 414 | (1LL << CodeCompletionContext::CCC_PotentiallyQualifiedName) 415 | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression); 416 417 if (isa<NamespaceDecl>(R.Declaration) || 418 isa<NamespaceAliasDecl>(R.Declaration)) 419 NNSContexts |= (1LL << CodeCompletionContext::CCC_Namespace); 420 421 if (unsigned RemainingContexts 422 = NNSContexts & ~CachedResult.ShowInContexts) { 423 // If there any contexts where this completion can be a 424 // nested-name-specifier but isn't already an option, create a 425 // nested-name-specifier completion. 426 R.StartsNestedNameSpecifier = true; 427 CachedResult.Completion = R.CreateCodeCompletionString( 428 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo, 429 IncludeBriefCommentsInCodeCompletion); 430 CachedResult.ShowInContexts = RemainingContexts; 431 CachedResult.Priority = CCP_NestedNameSpecifier; 432 CachedResult.TypeClass = STC_Void; 433 CachedResult.Type = 0; 434 CachedCompletionResults.push_back(CachedResult); 435 } 436 } 437 break; 438 } 439 440 case Result::RK_Keyword: 441 case Result::RK_Pattern: 442 // Ignore keywords and patterns; we don't care, since they are so 443 // easily regenerated. 444 break; 445 446 case Result::RK_Macro: { 447 CachedCodeCompletionResult CachedResult; 448 CachedResult.Completion = R.CreateCodeCompletionString( 449 *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo, 450 IncludeBriefCommentsInCodeCompletion); 451 CachedResult.ShowInContexts 452 = (1LL << CodeCompletionContext::CCC_TopLevel) 453 | (1LL << CodeCompletionContext::CCC_ObjCInterface) 454 | (1LL << CodeCompletionContext::CCC_ObjCImplementation) 455 | (1LL << CodeCompletionContext::CCC_ObjCIvarList) 456 | (1LL << CodeCompletionContext::CCC_ClassStructUnion) 457 | (1LL << CodeCompletionContext::CCC_Statement) 458 | (1LL << CodeCompletionContext::CCC_Expression) 459 | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) 460 | (1LL << CodeCompletionContext::CCC_MacroNameUse) 461 | (1LL << CodeCompletionContext::CCC_PreprocessorExpression) 462 | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) 463 | (1LL << CodeCompletionContext::CCC_OtherWithMacros); 464 465 CachedResult.Priority = R.Priority; 466 CachedResult.Kind = R.CursorKind; 467 CachedResult.Availability = R.Availability; 468 CachedResult.TypeClass = STC_Void; 469 CachedResult.Type = 0; 470 CachedCompletionResults.push_back(CachedResult); 471 break; 472 } 473 } 474 } 475 476 // Save the current top-level hash value. 477 CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue; 478 } 479 480 void ASTUnit::ClearCachedCompletionResults() { 481 CachedCompletionResults.clear(); 482 CachedCompletionTypes.clear(); 483 CachedCompletionAllocator = nullptr; 484 } 485 486 namespace { 487 488 /// \brief Gathers information from ASTReader that will be used to initialize 489 /// a Preprocessor. 490 class ASTInfoCollector : public ASTReaderListener { 491 Preprocessor &PP; 492 ASTContext &Context; 493 LangOptions &LangOpt; 494 std::shared_ptr<TargetOptions> &TargetOpts; 495 IntrusiveRefCntPtr<TargetInfo> &Target; 496 unsigned &Counter; 497 498 bool InitializedLanguage; 499 public: 500 ASTInfoCollector(Preprocessor &PP, ASTContext &Context, LangOptions &LangOpt, 501 std::shared_ptr<TargetOptions> &TargetOpts, 502 IntrusiveRefCntPtr<TargetInfo> &Target, unsigned &Counter) 503 : PP(PP), Context(Context), LangOpt(LangOpt), TargetOpts(TargetOpts), 504 Target(Target), Counter(Counter), InitializedLanguage(false) {} 505 506 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, 507 bool AllowCompatibleDifferences) override { 508 if (InitializedLanguage) 509 return false; 510 511 LangOpt = LangOpts; 512 InitializedLanguage = true; 513 514 updated(); 515 return false; 516 } 517 518 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, 519 bool AllowCompatibleDifferences) override { 520 // If we've already initialized the target, don't do it again. 521 if (Target) 522 return false; 523 524 this->TargetOpts = std::make_shared<TargetOptions>(TargetOpts); 525 Target = 526 TargetInfo::CreateTargetInfo(PP.getDiagnostics(), this->TargetOpts); 527 528 updated(); 529 return false; 530 } 531 532 void ReadCounter(const serialization::ModuleFile &M, 533 unsigned Value) override { 534 Counter = Value; 535 } 536 537 private: 538 void updated() { 539 if (!Target || !InitializedLanguage) 540 return; 541 542 // Inform the target of the language options. 543 // 544 // FIXME: We shouldn't need to do this, the target should be immutable once 545 // created. This complexity should be lifted elsewhere. 546 Target->adjust(LangOpt); 547 548 // Initialize the preprocessor. 549 PP.Initialize(*Target); 550 551 // Initialize the ASTContext 552 Context.InitBuiltinTypes(*Target); 553 554 // We didn't have access to the comment options when the ASTContext was 555 // constructed, so register them now. 556 Context.getCommentCommandTraits().registerCommentOptions( 557 LangOpt.CommentOpts); 558 } 559 }; 560 561 /// \brief Diagnostic consumer that saves each diagnostic it is given. 562 class StoredDiagnosticConsumer : public DiagnosticConsumer { 563 SmallVectorImpl<StoredDiagnostic> &StoredDiags; 564 SourceManager *SourceMgr; 565 566 public: 567 explicit StoredDiagnosticConsumer( 568 SmallVectorImpl<StoredDiagnostic> &StoredDiags) 569 : StoredDiags(StoredDiags), SourceMgr(nullptr) {} 570 571 void BeginSourceFile(const LangOptions &LangOpts, 572 const Preprocessor *PP = nullptr) override { 573 if (PP) 574 SourceMgr = &PP->getSourceManager(); 575 } 576 577 void HandleDiagnostic(DiagnosticsEngine::Level Level, 578 const Diagnostic &Info) override; 579 }; 580 581 /// \brief RAII object that optionally captures diagnostics, if 582 /// there is no diagnostic client to capture them already. 583 class CaptureDroppedDiagnostics { 584 DiagnosticsEngine &Diags; 585 StoredDiagnosticConsumer Client; 586 DiagnosticConsumer *PreviousClient; 587 std::unique_ptr<DiagnosticConsumer> OwningPreviousClient; 588 589 public: 590 CaptureDroppedDiagnostics(bool RequestCapture, DiagnosticsEngine &Diags, 591 SmallVectorImpl<StoredDiagnostic> &StoredDiags) 592 : Diags(Diags), Client(StoredDiags), PreviousClient(nullptr) 593 { 594 if (RequestCapture || Diags.getClient() == nullptr) { 595 OwningPreviousClient = Diags.takeClient(); 596 PreviousClient = Diags.getClient(); 597 Diags.setClient(&Client, false); 598 } 599 } 600 601 ~CaptureDroppedDiagnostics() { 602 if (Diags.getClient() == &Client) 603 Diags.setClient(PreviousClient, !!OwningPreviousClient.release()); 604 } 605 }; 606 607 } // anonymous namespace 608 609 void StoredDiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level Level, 610 const Diagnostic &Info) { 611 // Default implementation (Warnings/errors count). 612 DiagnosticConsumer::HandleDiagnostic(Level, Info); 613 614 // Only record the diagnostic if it's part of the source manager we know 615 // about. This effectively drops diagnostics from modules we're building. 616 // FIXME: In the long run, ee don't want to drop source managers from modules. 617 if (!Info.hasSourceManager() || &Info.getSourceManager() == SourceMgr) 618 StoredDiags.emplace_back(Level, Info); 619 } 620 621 ASTMutationListener *ASTUnit::getASTMutationListener() { 622 if (WriterData) 623 return &WriterData->Writer; 624 return nullptr; 625 } 626 627 ASTDeserializationListener *ASTUnit::getDeserializationListener() { 628 if (WriterData) 629 return &WriterData->Writer; 630 return nullptr; 631 } 632 633 std::unique_ptr<llvm::MemoryBuffer> 634 ASTUnit::getBufferForFile(StringRef Filename, std::string *ErrorStr) { 635 assert(FileMgr); 636 auto Buffer = FileMgr->getBufferForFile(Filename); 637 if (Buffer) 638 return std::move(*Buffer); 639 if (ErrorStr) 640 *ErrorStr = Buffer.getError().message(); 641 return nullptr; 642 } 643 644 /// \brief Configure the diagnostics object for use with ASTUnit. 645 void ASTUnit::ConfigureDiags(IntrusiveRefCntPtr<DiagnosticsEngine> Diags, 646 ASTUnit &AST, bool CaptureDiagnostics) { 647 assert(Diags.get() && "no DiagnosticsEngine was provided"); 648 if (CaptureDiagnostics) 649 Diags->setClient(new StoredDiagnosticConsumer(AST.StoredDiagnostics)); 650 } 651 652 std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile( 653 const std::string &Filename, const PCHContainerReader &PCHContainerRdr, 654 IntrusiveRefCntPtr<DiagnosticsEngine> Diags, 655 const FileSystemOptions &FileSystemOpts, bool UseDebugInfo, 656 bool OnlyLocalDecls, ArrayRef<RemappedFile> RemappedFiles, 657 bool CaptureDiagnostics, bool AllowPCHWithCompilerErrors, 658 bool UserFilesAreVolatile) { 659 std::unique_ptr<ASTUnit> AST(new ASTUnit(true)); 660 661 // Recover resources if we crash before exiting this method. 662 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 663 ASTUnitCleanup(AST.get()); 664 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 665 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 666 DiagCleanup(Diags.get()); 667 668 ConfigureDiags(Diags, *AST, CaptureDiagnostics); 669 670 AST->OnlyLocalDecls = OnlyLocalDecls; 671 AST->CaptureDiagnostics = CaptureDiagnostics; 672 AST->Diagnostics = Diags; 673 IntrusiveRefCntPtr<vfs::FileSystem> VFS = vfs::getRealFileSystem(); 674 AST->FileMgr = new FileManager(FileSystemOpts, VFS); 675 AST->UserFilesAreVolatile = UserFilesAreVolatile; 676 AST->SourceMgr = new SourceManager(AST->getDiagnostics(), 677 AST->getFileManager(), 678 UserFilesAreVolatile); 679 AST->HSOpts = new HeaderSearchOptions(); 680 AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat(); 681 AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts, 682 AST->getSourceManager(), 683 AST->getDiagnostics(), 684 AST->ASTFileLangOpts, 685 /*Target=*/nullptr)); 686 687 PreprocessorOptions *PPOpts = new PreprocessorOptions(); 688 689 for (const auto &RemappedFile : RemappedFiles) 690 PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second); 691 692 // Gather Info for preprocessor construction later on. 693 694 HeaderSearch &HeaderInfo = *AST->HeaderInfo; 695 unsigned Counter; 696 697 AST->PP = 698 new Preprocessor(PPOpts, AST->getDiagnostics(), AST->ASTFileLangOpts, 699 AST->getSourceManager(), HeaderInfo, *AST, 700 /*IILookup=*/nullptr, 701 /*OwnsHeaderSearch=*/false); 702 Preprocessor &PP = *AST->PP; 703 704 AST->Ctx = new ASTContext(AST->ASTFileLangOpts, AST->getSourceManager(), 705 PP.getIdentifierTable(), PP.getSelectorTable(), 706 PP.getBuiltinInfo()); 707 ASTContext &Context = *AST->Ctx; 708 709 bool disableValid = false; 710 if (::getenv("LIBCLANG_DISABLE_PCH_VALIDATION")) 711 disableValid = true; 712 AST->Reader = new ASTReader(PP, Context, PCHContainerRdr, { }, 713 /*isysroot=*/"", 714 /*DisableValidation=*/disableValid, 715 AllowPCHWithCompilerErrors); 716 717 AST->Reader->setListener(llvm::make_unique<ASTInfoCollector>( 718 *AST->PP, Context, AST->ASTFileLangOpts, AST->TargetOpts, AST->Target, 719 Counter)); 720 721 // Attach the AST reader to the AST context as an external AST 722 // source, so that declarations will be deserialized from the 723 // AST file as needed. 724 // We need the external source to be set up before we read the AST, because 725 // eagerly-deserialized declarations may use it. 726 Context.setExternalSource(AST->Reader); 727 728 switch (AST->Reader->ReadAST(Filename, serialization::MK_MainFile, 729 SourceLocation(), ASTReader::ARR_None)) { 730 case ASTReader::Success: 731 break; 732 733 case ASTReader::Failure: 734 case ASTReader::Missing: 735 case ASTReader::OutOfDate: 736 case ASTReader::VersionMismatch: 737 case ASTReader::ConfigurationMismatch: 738 case ASTReader::HadErrors: 739 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); 740 return nullptr; 741 } 742 743 AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile(); 744 745 PP.setCounterValue(Counter); 746 747 // Create an AST consumer, even though it isn't used. 748 AST->Consumer.reset(new ASTConsumer); 749 750 // Create a semantic analysis object and tell the AST reader about it. 751 AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); 752 AST->TheSema->Initialize(); 753 AST->Reader->InitializeSema(*AST->TheSema); 754 755 // Tell the diagnostic client that we have started a source file. 756 AST->getDiagnostics().getClient()->BeginSourceFile(Context.getLangOpts(),&PP); 757 758 return AST; 759 } 760 761 namespace { 762 763 /// \brief Preprocessor callback class that updates a hash value with the names 764 /// of all macros that have been defined by the translation unit. 765 class MacroDefinitionTrackerPPCallbacks : public PPCallbacks { 766 unsigned &Hash; 767 768 public: 769 explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { } 770 771 void MacroDefined(const Token &MacroNameTok, 772 const MacroDirective *MD) override { 773 Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash); 774 } 775 }; 776 777 /// \brief Add the given declaration to the hash of all top-level entities. 778 void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { 779 if (!D) 780 return; 781 782 DeclContext *DC = D->getDeclContext(); 783 if (!DC) 784 return; 785 786 if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit())) 787 return; 788 789 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) { 790 if (EnumDecl *EnumD = dyn_cast<EnumDecl>(D)) { 791 // For an unscoped enum include the enumerators in the hash since they 792 // enter the top-level namespace. 793 if (!EnumD->isScoped()) { 794 for (const auto *EI : EnumD->enumerators()) { 795 if (EI->getIdentifier()) 796 Hash = llvm::HashString(EI->getIdentifier()->getName(), Hash); 797 } 798 } 799 } 800 801 if (ND->getIdentifier()) 802 Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash); 803 else if (DeclarationName Name = ND->getDeclName()) { 804 std::string NameStr = Name.getAsString(); 805 Hash = llvm::HashString(NameStr, Hash); 806 } 807 return; 808 } 809 810 if (ImportDecl *ImportD = dyn_cast<ImportDecl>(D)) { 811 if (Module *Mod = ImportD->getImportedModule()) { 812 std::string ModName = Mod->getFullModuleName(); 813 Hash = llvm::HashString(ModName, Hash); 814 } 815 return; 816 } 817 } 818 819 class TopLevelDeclTrackerConsumer : public ASTConsumer { 820 ASTUnit &Unit; 821 unsigned &Hash; 822 823 public: 824 TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash) 825 : Unit(_Unit), Hash(Hash) { 826 Hash = 0; 827 } 828 829 void handleTopLevelDecl(Decl *D) { 830 if (!D) 831 return; 832 833 // FIXME: Currently ObjC method declarations are incorrectly being 834 // reported as top-level declarations, even though their DeclContext 835 // is the containing ObjC @interface/@implementation. This is a 836 // fundamental problem in the parser right now. 837 if (isa<ObjCMethodDecl>(D)) 838 return; 839 840 AddTopLevelDeclarationToHash(D, Hash); 841 Unit.addTopLevelDecl(D); 842 843 handleFileLevelDecl(D); 844 } 845 846 void handleFileLevelDecl(Decl *D) { 847 Unit.addFileLevelDecl(D); 848 if (NamespaceDecl *NSD = dyn_cast<NamespaceDecl>(D)) { 849 for (auto *I : NSD->decls()) 850 handleFileLevelDecl(I); 851 } 852 } 853 854 bool HandleTopLevelDecl(DeclGroupRef D) override { 855 for (Decl *TopLevelDecl : D) 856 handleTopLevelDecl(TopLevelDecl); 857 return true; 858 } 859 860 // We're not interested in "interesting" decls. 861 void HandleInterestingDecl(DeclGroupRef) override {} 862 863 void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { 864 for (Decl *TopLevelDecl : D) 865 handleTopLevelDecl(TopLevelDecl); 866 } 867 868 ASTMutationListener *GetASTMutationListener() override { 869 return Unit.getASTMutationListener(); 870 } 871 872 ASTDeserializationListener *GetASTDeserializationListener() override { 873 return Unit.getDeserializationListener(); 874 } 875 }; 876 877 class TopLevelDeclTrackerAction : public ASTFrontendAction { 878 public: 879 ASTUnit &Unit; 880 881 std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, 882 StringRef InFile) override { 883 CI.getPreprocessor().addPPCallbacks( 884 llvm::make_unique<MacroDefinitionTrackerPPCallbacks>( 885 Unit.getCurrentTopLevelHashValue())); 886 return llvm::make_unique<TopLevelDeclTrackerConsumer>( 887 Unit, Unit.getCurrentTopLevelHashValue()); 888 } 889 890 public: 891 TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} 892 893 bool hasCodeCompletionSupport() const override { return false; } 894 TranslationUnitKind getTranslationUnitKind() override { 895 return Unit.getTranslationUnitKind(); 896 } 897 }; 898 899 class PrecompilePreambleAction : public ASTFrontendAction { 900 ASTUnit &Unit; 901 bool HasEmittedPreamblePCH; 902 903 public: 904 explicit PrecompilePreambleAction(ASTUnit &Unit) 905 : Unit(Unit), HasEmittedPreamblePCH(false) {} 906 907 std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, 908 StringRef InFile) override; 909 bool hasEmittedPreamblePCH() const { return HasEmittedPreamblePCH; } 910 void setHasEmittedPreamblePCH() { HasEmittedPreamblePCH = true; } 911 bool shouldEraseOutputFiles() override { return !hasEmittedPreamblePCH(); } 912 913 bool hasCodeCompletionSupport() const override { return false; } 914 bool hasASTFileSupport() const override { return false; } 915 TranslationUnitKind getTranslationUnitKind() override { return TU_Prefix; } 916 }; 917 918 class PrecompilePreambleConsumer : public PCHGenerator { 919 ASTUnit &Unit; 920 unsigned &Hash; 921 std::vector<Decl *> TopLevelDecls; 922 PrecompilePreambleAction *Action; 923 raw_ostream *Out; 924 925 public: 926 PrecompilePreambleConsumer(ASTUnit &Unit, PrecompilePreambleAction *Action, 927 const Preprocessor &PP, StringRef isysroot, 928 raw_ostream *Out) 929 : PCHGenerator(PP, "", nullptr, isysroot, std::make_shared<PCHBuffer>(), 930 ArrayRef<llvm::IntrusiveRefCntPtr<ModuleFileExtension>>(), 931 /*AllowASTWithErrors=*/true), 932 Unit(Unit), Hash(Unit.getCurrentTopLevelHashValue()), Action(Action), 933 Out(Out) { 934 Hash = 0; 935 } 936 937 bool HandleTopLevelDecl(DeclGroupRef DG) override { 938 for (Decl *D : DG) { 939 // FIXME: Currently ObjC method declarations are incorrectly being 940 // reported as top-level declarations, even though their DeclContext 941 // is the containing ObjC @interface/@implementation. This is a 942 // fundamental problem in the parser right now. 943 if (isa<ObjCMethodDecl>(D)) 944 continue; 945 AddTopLevelDeclarationToHash(D, Hash); 946 TopLevelDecls.push_back(D); 947 } 948 return true; 949 } 950 951 void HandleTranslationUnit(ASTContext &Ctx) override { 952 PCHGenerator::HandleTranslationUnit(Ctx); 953 if (hasEmittedPCH()) { 954 // Write the generated bitstream to "Out". 955 *Out << getPCH(); 956 // Make sure it hits disk now. 957 Out->flush(); 958 // Free the buffer. 959 llvm::SmallVector<char, 0> Empty; 960 getPCH() = std::move(Empty); 961 962 // Translate the top-level declarations we captured during 963 // parsing into declaration IDs in the precompiled 964 // preamble. This will allow us to deserialize those top-level 965 // declarations when requested. 966 for (Decl *D : TopLevelDecls) { 967 // Invalid top-level decls may not have been serialized. 968 if (D->isInvalidDecl()) 969 continue; 970 Unit.addTopLevelDeclFromPreamble(getWriter().getDeclID(D)); 971 } 972 973 Action->setHasEmittedPreamblePCH(); 974 } 975 } 976 }; 977 978 } // anonymous namespace 979 980 std::unique_ptr<ASTConsumer> 981 PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI, 982 StringRef InFile) { 983 std::string Sysroot; 984 std::string OutputFile; 985 raw_ostream *OS = GeneratePCHAction::ComputeASTConsumerArguments( 986 CI, InFile, Sysroot, OutputFile); 987 if (!OS) 988 return nullptr; 989 990 if (!CI.getFrontendOpts().RelocatablePCH) 991 Sysroot.clear(); 992 993 CI.getPreprocessor().addPPCallbacks( 994 llvm::make_unique<MacroDefinitionTrackerPPCallbacks>( 995 Unit.getCurrentTopLevelHashValue())); 996 return llvm::make_unique<PrecompilePreambleConsumer>( 997 Unit, this, CI.getPreprocessor(), Sysroot, OS); 998 } 999 1000 static bool isNonDriverDiag(const StoredDiagnostic &StoredDiag) { 1001 return StoredDiag.getLocation().isValid(); 1002 } 1003 1004 static void 1005 checkAndRemoveNonDriverDiags(SmallVectorImpl<StoredDiagnostic> &StoredDiags) { 1006 // Get rid of stored diagnostics except the ones from the driver which do not 1007 // have a source location. 1008 StoredDiags.erase( 1009 std::remove_if(StoredDiags.begin(), StoredDiags.end(), isNonDriverDiag), 1010 StoredDiags.end()); 1011 } 1012 1013 static void checkAndSanitizeDiags(SmallVectorImpl<StoredDiagnostic> & 1014 StoredDiagnostics, 1015 SourceManager &SM) { 1016 // The stored diagnostic has the old source manager in it; update 1017 // the locations to refer into the new source manager. Since we've 1018 // been careful to make sure that the source manager's state 1019 // before and after are identical, so that we can reuse the source 1020 // location itself. 1021 for (StoredDiagnostic &SD : StoredDiagnostics) { 1022 if (SD.getLocation().isValid()) { 1023 FullSourceLoc Loc(SD.getLocation(), SM); 1024 SD.setLocation(Loc); 1025 } 1026 } 1027 } 1028 1029 /// Parse the source file into a translation unit using the given compiler 1030 /// invocation, replacing the current translation unit. 1031 /// 1032 /// \returns True if a failure occurred that causes the ASTUnit not to 1033 /// contain any translation-unit information, false otherwise. 1034 bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps, 1035 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer) { 1036 SavedMainFileBuffer.reset(); 1037 1038 if (!Invocation) 1039 return true; 1040 1041 // Create the compiler instance to use for building the AST. 1042 std::unique_ptr<CompilerInstance> Clang( 1043 new CompilerInstance(std::move(PCHContainerOps))); 1044 1045 // Recover resources if we crash before exiting this method. 1046 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 1047 CICleanup(Clang.get()); 1048 1049 IntrusiveRefCntPtr<CompilerInvocation> 1050 CCInvocation(new CompilerInvocation(*Invocation)); 1051 1052 Clang->setInvocation(CCInvocation.get()); 1053 OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); 1054 1055 // Set up diagnostics, capturing any diagnostics that would 1056 // otherwise be dropped. 1057 Clang->setDiagnostics(&getDiagnostics()); 1058 1059 // Create the target instance. 1060 Clang->setTarget(TargetInfo::CreateTargetInfo( 1061 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 1062 if (!Clang->hasTarget()) 1063 return true; 1064 1065 // Inform the target of the language options. 1066 // 1067 // FIXME: We shouldn't need to do this, the target should be immutable once 1068 // created. This complexity should be lifted elsewhere. 1069 Clang->getTarget().adjust(Clang->getLangOpts()); 1070 1071 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 1072 "Invocation must have exactly one source file!"); 1073 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && 1074 "FIXME: AST inputs not yet supported here!"); 1075 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && 1076 "IR inputs not support here!"); 1077 1078 // Configure the various subsystems. 1079 LangOpts = Clang->getInvocation().LangOpts; 1080 FileSystemOpts = Clang->getFileSystemOpts(); 1081 if (!FileMgr) { 1082 Clang->createFileManager(); 1083 FileMgr = &Clang->getFileManager(); 1084 } 1085 SourceMgr = new SourceManager(getDiagnostics(), *FileMgr, 1086 UserFilesAreVolatile); 1087 TheSema.reset(); 1088 Ctx = nullptr; 1089 PP = nullptr; 1090 Reader = nullptr; 1091 1092 // Clear out old caches and data. 1093 TopLevelDecls.clear(); 1094 clearFileLevelDecls(); 1095 CleanTemporaryFiles(); 1096 1097 if (!OverrideMainBuffer) { 1098 checkAndRemoveNonDriverDiags(StoredDiagnostics); 1099 TopLevelDeclsInPreamble.clear(); 1100 } 1101 1102 // Create a file manager object to provide access to and cache the filesystem. 1103 Clang->setFileManager(&getFileManager()); 1104 1105 // Create the source manager. 1106 Clang->setSourceManager(&getSourceManager()); 1107 1108 // If the main file has been overridden due to the use of a preamble, 1109 // make that override happen and introduce the preamble. 1110 PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts(); 1111 if (OverrideMainBuffer) { 1112 PreprocessorOpts.addRemappedFile(OriginalSourceFile, 1113 OverrideMainBuffer.get()); 1114 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); 1115 PreprocessorOpts.PrecompiledPreambleBytes.second 1116 = PreambleEndsAtStartOfLine; 1117 PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); 1118 PreprocessorOpts.DisablePCHValidation = true; 1119 1120 // The stored diagnostic has the old source manager in it; update 1121 // the locations to refer into the new source manager. Since we've 1122 // been careful to make sure that the source manager's state 1123 // before and after are identical, so that we can reuse the source 1124 // location itself. 1125 checkAndSanitizeDiags(StoredDiagnostics, getSourceManager()); 1126 1127 // Keep track of the override buffer; 1128 SavedMainFileBuffer = std::move(OverrideMainBuffer); 1129 } 1130 1131 std::unique_ptr<TopLevelDeclTrackerAction> Act( 1132 new TopLevelDeclTrackerAction(*this)); 1133 1134 // Recover resources if we crash before exiting this method. 1135 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction> 1136 ActCleanup(Act.get()); 1137 1138 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) 1139 goto error; 1140 1141 if (SavedMainFileBuffer) 1142 TranslateStoredDiagnostics(getFileManager(), getSourceManager(), 1143 PreambleDiagnostics, StoredDiagnostics); 1144 1145 if (!Act->Execute()) 1146 goto error; 1147 1148 transferASTDataFromCompilerInstance(*Clang); 1149 1150 Act->EndSourceFile(); 1151 1152 FailedParseDiagnostics.clear(); 1153 1154 return false; 1155 1156 error: 1157 // Remove the overridden buffer we used for the preamble. 1158 SavedMainFileBuffer = nullptr; 1159 1160 // Keep the ownership of the data in the ASTUnit because the client may 1161 // want to see the diagnostics. 1162 transferASTDataFromCompilerInstance(*Clang); 1163 FailedParseDiagnostics.swap(StoredDiagnostics); 1164 StoredDiagnostics.clear(); 1165 NumStoredDiagnosticsFromDriver = 0; 1166 return true; 1167 } 1168 1169 /// \brief Simple function to retrieve a path for a preamble precompiled header. 1170 static std::string GetPreamblePCHPath() { 1171 // FIXME: This is a hack so that we can override the preamble file during 1172 // crash-recovery testing, which is the only case where the preamble files 1173 // are not necessarily cleaned up. 1174 const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"); 1175 if (TmpFile) 1176 return TmpFile; 1177 1178 SmallString<128> Path; 1179 llvm::sys::fs::createTemporaryFile("preamble", "pch", Path); 1180 1181 return Path.str(); 1182 } 1183 1184 /// \brief Compute the preamble for the main file, providing the source buffer 1185 /// that corresponds to the main file along with a pair (bytes, start-of-line) 1186 /// that describes the preamble. 1187 ASTUnit::ComputedPreamble 1188 ASTUnit::ComputePreamble(CompilerInvocation &Invocation, unsigned MaxLines) { 1189 FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); 1190 PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts(); 1191 1192 // Try to determine if the main file has been remapped, either from the 1193 // command line (to another file) or directly through the compiler invocation 1194 // (to a memory buffer). 1195 llvm::MemoryBuffer *Buffer = nullptr; 1196 std::unique_ptr<llvm::MemoryBuffer> BufferOwner; 1197 std::string MainFilePath(FrontendOpts.Inputs[0].getFile()); 1198 llvm::sys::fs::UniqueID MainFileID; 1199 if (!llvm::sys::fs::getUniqueID(MainFilePath, MainFileID)) { 1200 // Check whether there is a file-file remapping of the main file 1201 for (const auto &RF : PreprocessorOpts.RemappedFiles) { 1202 std::string MPath(RF.first); 1203 llvm::sys::fs::UniqueID MID; 1204 if (!llvm::sys::fs::getUniqueID(MPath, MID)) { 1205 if (MainFileID == MID) { 1206 // We found a remapping. Try to load the resulting, remapped source. 1207 BufferOwner = getBufferForFile(RF.second); 1208 if (!BufferOwner) 1209 return ComputedPreamble(nullptr, nullptr, 0, true); 1210 } 1211 } 1212 } 1213 1214 // Check whether there is a file-buffer remapping. It supercedes the 1215 // file-file remapping. 1216 for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { 1217 std::string MPath(RB.first); 1218 llvm::sys::fs::UniqueID MID; 1219 if (!llvm::sys::fs::getUniqueID(MPath, MID)) { 1220 if (MainFileID == MID) { 1221 // We found a remapping. 1222 BufferOwner.reset(); 1223 Buffer = const_cast<llvm::MemoryBuffer *>(RB.second); 1224 } 1225 } 1226 } 1227 } 1228 1229 // If the main source file was not remapped, load it now. 1230 if (!Buffer && !BufferOwner) { 1231 BufferOwner = getBufferForFile(FrontendOpts.Inputs[0].getFile()); 1232 if (!BufferOwner) 1233 return ComputedPreamble(nullptr, nullptr, 0, true); 1234 } 1235 1236 if (!Buffer) 1237 Buffer = BufferOwner.get(); 1238 auto Pre = Lexer::ComputePreamble(Buffer->getBuffer(), 1239 *Invocation.getLangOpts(), MaxLines); 1240 return ComputedPreamble(Buffer, std::move(BufferOwner), Pre.first, 1241 Pre.second); 1242 } 1243 1244 ASTUnit::PreambleFileHash 1245 ASTUnit::PreambleFileHash::createForFile(off_t Size, time_t ModTime) { 1246 PreambleFileHash Result; 1247 Result.Size = Size; 1248 Result.ModTime = ModTime; 1249 memset(Result.MD5, 0, sizeof(Result.MD5)); 1250 return Result; 1251 } 1252 1253 ASTUnit::PreambleFileHash ASTUnit::PreambleFileHash::createForMemoryBuffer( 1254 const llvm::MemoryBuffer *Buffer) { 1255 PreambleFileHash Result; 1256 Result.Size = Buffer->getBufferSize(); 1257 Result.ModTime = 0; 1258 1259 llvm::MD5 MD5Ctx; 1260 MD5Ctx.update(Buffer->getBuffer().data()); 1261 MD5Ctx.final(Result.MD5); 1262 1263 return Result; 1264 } 1265 1266 namespace clang { 1267 bool operator==(const ASTUnit::PreambleFileHash &LHS, 1268 const ASTUnit::PreambleFileHash &RHS) { 1269 return LHS.Size == RHS.Size && LHS.ModTime == RHS.ModTime && 1270 memcmp(LHS.MD5, RHS.MD5, sizeof(LHS.MD5)) == 0; 1271 } 1272 } // namespace clang 1273 1274 static std::pair<unsigned, unsigned> 1275 makeStandaloneRange(CharSourceRange Range, const SourceManager &SM, 1276 const LangOptions &LangOpts) { 1277 CharSourceRange FileRange = Lexer::makeFileCharRange(Range, SM, LangOpts); 1278 unsigned Offset = SM.getFileOffset(FileRange.getBegin()); 1279 unsigned EndOffset = SM.getFileOffset(FileRange.getEnd()); 1280 return std::make_pair(Offset, EndOffset); 1281 } 1282 1283 static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM, 1284 const LangOptions &LangOpts, 1285 const FixItHint &InFix) { 1286 ASTUnit::StandaloneFixIt OutFix; 1287 OutFix.RemoveRange = makeStandaloneRange(InFix.RemoveRange, SM, LangOpts); 1288 OutFix.InsertFromRange = makeStandaloneRange(InFix.InsertFromRange, SM, 1289 LangOpts); 1290 OutFix.CodeToInsert = InFix.CodeToInsert; 1291 OutFix.BeforePreviousInsertions = InFix.BeforePreviousInsertions; 1292 return OutFix; 1293 } 1294 1295 static ASTUnit::StandaloneDiagnostic 1296 makeStandaloneDiagnostic(const LangOptions &LangOpts, 1297 const StoredDiagnostic &InDiag) { 1298 ASTUnit::StandaloneDiagnostic OutDiag; 1299 OutDiag.ID = InDiag.getID(); 1300 OutDiag.Level = InDiag.getLevel(); 1301 OutDiag.Message = InDiag.getMessage(); 1302 OutDiag.LocOffset = 0; 1303 if (InDiag.getLocation().isInvalid()) 1304 return OutDiag; 1305 const SourceManager &SM = InDiag.getLocation().getManager(); 1306 SourceLocation FileLoc = SM.getFileLoc(InDiag.getLocation()); 1307 OutDiag.Filename = SM.getFilename(FileLoc); 1308 if (OutDiag.Filename.empty()) 1309 return OutDiag; 1310 OutDiag.LocOffset = SM.getFileOffset(FileLoc); 1311 for (const CharSourceRange &Range : InDiag.getRanges()) 1312 OutDiag.Ranges.push_back(makeStandaloneRange(Range, SM, LangOpts)); 1313 for (const FixItHint &FixIt : InDiag.getFixIts()) 1314 OutDiag.FixIts.push_back(makeStandaloneFixIt(SM, LangOpts, FixIt)); 1315 1316 return OutDiag; 1317 } 1318 1319 /// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing 1320 /// the source file. 1321 /// 1322 /// This routine will compute the preamble of the main source file. If a 1323 /// non-trivial preamble is found, it will precompile that preamble into a 1324 /// precompiled header so that the precompiled preamble can be used to reduce 1325 /// reparsing time. If a precompiled preamble has already been constructed, 1326 /// this routine will determine if it is still valid and, if so, avoid 1327 /// rebuilding the precompiled preamble. 1328 /// 1329 /// \param AllowRebuild When true (the default), this routine is 1330 /// allowed to rebuild the precompiled preamble if it is found to be 1331 /// out-of-date. 1332 /// 1333 /// \param MaxLines When non-zero, the maximum number of lines that 1334 /// can occur within the preamble. 1335 /// 1336 /// \returns If the precompiled preamble can be used, returns a newly-allocated 1337 /// buffer that should be used in place of the main file when doing so. 1338 /// Otherwise, returns a NULL pointer. 1339 std::unique_ptr<llvm::MemoryBuffer> 1340 ASTUnit::getMainBufferWithPrecompiledPreamble( 1341 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 1342 const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, 1343 unsigned MaxLines) { 1344 1345 IntrusiveRefCntPtr<CompilerInvocation> 1346 PreambleInvocation(new CompilerInvocation(PreambleInvocationIn)); 1347 FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); 1348 PreprocessorOptions &PreprocessorOpts 1349 = PreambleInvocation->getPreprocessorOpts(); 1350 1351 ComputedPreamble NewPreamble = ComputePreamble(*PreambleInvocation, MaxLines); 1352 1353 if (!NewPreamble.Size) { 1354 // We couldn't find a preamble in the main source. Clear out the current 1355 // preamble, if we have one. It's obviously no good any more. 1356 Preamble.clear(); 1357 erasePreambleFile(this); 1358 1359 // The next time we actually see a preamble, precompile it. 1360 PreambleRebuildCounter = 1; 1361 return nullptr; 1362 } 1363 1364 if (!Preamble.empty()) { 1365 // We've previously computed a preamble. Check whether we have the same 1366 // preamble now that we did before, and that there's enough space in 1367 // the main-file buffer within the precompiled preamble to fit the 1368 // new main file. 1369 if (Preamble.size() == NewPreamble.Size && 1370 PreambleEndsAtStartOfLine == NewPreamble.PreambleEndsAtStartOfLine && 1371 memcmp(Preamble.getBufferStart(), NewPreamble.Buffer->getBufferStart(), 1372 NewPreamble.Size) == 0) { 1373 // The preamble has not changed. We may be able to re-use the precompiled 1374 // preamble. 1375 1376 // Check that none of the files used by the preamble have changed. 1377 bool AnyFileChanged = false; 1378 1379 // First, make a record of those files that have been overridden via 1380 // remapping or unsaved_files. 1381 std::map<llvm::sys::fs::UniqueID, PreambleFileHash> OverriddenFiles; 1382 for (const auto &R : PreprocessorOpts.RemappedFiles) { 1383 if (AnyFileChanged) 1384 break; 1385 1386 vfs::Status Status; 1387 if (FileMgr->getNoncachedStatValue(R.second, Status)) { 1388 // If we can't stat the file we're remapping to, assume that something 1389 // horrible happened. 1390 AnyFileChanged = true; 1391 break; 1392 } 1393 1394 OverriddenFiles[Status.getUniqueID()] = PreambleFileHash::createForFile( 1395 Status.getSize(), Status.getLastModificationTime().toEpochTime()); 1396 } 1397 1398 for (const auto &RB : PreprocessorOpts.RemappedFileBuffers) { 1399 if (AnyFileChanged) 1400 break; 1401 1402 vfs::Status Status; 1403 if (FileMgr->getNoncachedStatValue(RB.first, Status)) { 1404 AnyFileChanged = true; 1405 break; 1406 } 1407 1408 OverriddenFiles[Status.getUniqueID()] = 1409 PreambleFileHash::createForMemoryBuffer(RB.second); 1410 } 1411 1412 // Check whether anything has changed. 1413 for (llvm::StringMap<PreambleFileHash>::iterator 1414 F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end(); 1415 !AnyFileChanged && F != FEnd; 1416 ++F) { 1417 vfs::Status Status; 1418 if (FileMgr->getNoncachedStatValue(F->first(), Status)) { 1419 // If we can't stat the file, assume that something horrible happened. 1420 AnyFileChanged = true; 1421 break; 1422 } 1423 1424 std::map<llvm::sys::fs::UniqueID, PreambleFileHash>::iterator Overridden 1425 = OverriddenFiles.find(Status.getUniqueID()); 1426 if (Overridden != OverriddenFiles.end()) { 1427 // This file was remapped; check whether the newly-mapped file 1428 // matches up with the previous mapping. 1429 if (Overridden->second != F->second) 1430 AnyFileChanged = true; 1431 continue; 1432 } 1433 1434 // The file was not remapped; check whether it has changed on disk. 1435 if (Status.getSize() != uint64_t(F->second.Size) || 1436 Status.getLastModificationTime().toEpochTime() != 1437 uint64_t(F->second.ModTime)) 1438 AnyFileChanged = true; 1439 } 1440 1441 if (!AnyFileChanged) { 1442 // Okay! We can re-use the precompiled preamble. 1443 1444 // Set the state of the diagnostic object to mimic its state 1445 // after parsing the preamble. 1446 getDiagnostics().Reset(); 1447 ProcessWarningOptions(getDiagnostics(), 1448 PreambleInvocation->getDiagnosticOpts()); 1449 getDiagnostics().setNumWarnings(NumWarningsInPreamble); 1450 1451 return llvm::MemoryBuffer::getMemBufferCopy( 1452 NewPreamble.Buffer->getBuffer(), FrontendOpts.Inputs[0].getFile()); 1453 } 1454 } 1455 1456 // If we aren't allowed to rebuild the precompiled preamble, just 1457 // return now. 1458 if (!AllowRebuild) 1459 return nullptr; 1460 1461 // We can't reuse the previously-computed preamble. Build a new one. 1462 Preamble.clear(); 1463 PreambleDiagnostics.clear(); 1464 erasePreambleFile(this); 1465 PreambleRebuildCounter = 1; 1466 } else if (!AllowRebuild) { 1467 // We aren't allowed to rebuild the precompiled preamble; just 1468 // return now. 1469 return nullptr; 1470 } 1471 1472 // If the preamble rebuild counter > 1, it's because we previously 1473 // failed to build a preamble and we're not yet ready to try 1474 // again. Decrement the counter and return a failure. 1475 if (PreambleRebuildCounter > 1) { 1476 --PreambleRebuildCounter; 1477 return nullptr; 1478 } 1479 1480 // Create a temporary file for the precompiled preamble. In rare 1481 // circumstances, this can fail. 1482 std::string PreamblePCHPath = GetPreamblePCHPath(); 1483 if (PreamblePCHPath.empty()) { 1484 // Try again next time. 1485 PreambleRebuildCounter = 1; 1486 return nullptr; 1487 } 1488 1489 // We did not previously compute a preamble, or it can't be reused anyway. 1490 SimpleTimer PreambleTimer(WantTiming); 1491 PreambleTimer.setOutput("Precompiling preamble"); 1492 1493 // Save the preamble text for later; we'll need to compare against it for 1494 // subsequent reparses. 1495 StringRef MainFilename = FrontendOpts.Inputs[0].getFile(); 1496 Preamble.assign(FileMgr->getFile(MainFilename), 1497 NewPreamble.Buffer->getBufferStart(), 1498 NewPreamble.Buffer->getBufferStart() + NewPreamble.Size); 1499 PreambleEndsAtStartOfLine = NewPreamble.PreambleEndsAtStartOfLine; 1500 1501 PreambleBuffer = llvm::MemoryBuffer::getMemBufferCopy( 1502 NewPreamble.Buffer->getBuffer().slice(0, Preamble.size()), MainFilename); 1503 1504 // Remap the main source file to the preamble buffer. 1505 StringRef MainFilePath = FrontendOpts.Inputs[0].getFile(); 1506 PreprocessorOpts.addRemappedFile(MainFilePath, PreambleBuffer.get()); 1507 1508 // Tell the compiler invocation to generate a temporary precompiled header. 1509 FrontendOpts.ProgramAction = frontend::GeneratePCH; 1510 // FIXME: Generate the precompiled header into memory? 1511 FrontendOpts.OutputFile = PreamblePCHPath; 1512 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 1513 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 1514 1515 // Create the compiler instance to use for building the precompiled preamble. 1516 std::unique_ptr<CompilerInstance> Clang( 1517 new CompilerInstance(std::move(PCHContainerOps))); 1518 1519 // Recover resources if we crash before exiting this method. 1520 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 1521 CICleanup(Clang.get()); 1522 1523 Clang->setInvocation(&*PreambleInvocation); 1524 OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); 1525 1526 // Set up diagnostics, capturing all of the diagnostics produced. 1527 Clang->setDiagnostics(&getDiagnostics()); 1528 1529 // Create the target instance. 1530 Clang->setTarget(TargetInfo::CreateTargetInfo( 1531 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 1532 if (!Clang->hasTarget()) { 1533 llvm::sys::fs::remove(FrontendOpts.OutputFile); 1534 Preamble.clear(); 1535 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1536 PreprocessorOpts.RemappedFileBuffers.pop_back(); 1537 return nullptr; 1538 } 1539 1540 // Inform the target of the language options. 1541 // 1542 // FIXME: We shouldn't need to do this, the target should be immutable once 1543 // created. This complexity should be lifted elsewhere. 1544 Clang->getTarget().adjust(Clang->getLangOpts()); 1545 1546 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 1547 "Invocation must have exactly one source file!"); 1548 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && 1549 "FIXME: AST inputs not yet supported here!"); 1550 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && 1551 "IR inputs not support here!"); 1552 1553 // Clear out old caches and data. 1554 getDiagnostics().Reset(); 1555 ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts()); 1556 checkAndRemoveNonDriverDiags(StoredDiagnostics); 1557 TopLevelDecls.clear(); 1558 TopLevelDeclsInPreamble.clear(); 1559 PreambleDiagnostics.clear(); 1560 1561 IntrusiveRefCntPtr<vfs::FileSystem> VFS = 1562 createVFSFromCompilerInvocation(Clang->getInvocation(), getDiagnostics()); 1563 if (!VFS) 1564 return nullptr; 1565 1566 // Create a file manager object to provide access to and cache the filesystem. 1567 Clang->setFileManager(new FileManager(Clang->getFileSystemOpts(), VFS)); 1568 1569 // Create the source manager. 1570 Clang->setSourceManager(new SourceManager(getDiagnostics(), 1571 Clang->getFileManager())); 1572 1573 auto PreambleDepCollector = std::make_shared<DependencyCollector>(); 1574 Clang->addDependencyCollector(PreambleDepCollector); 1575 1576 std::unique_ptr<PrecompilePreambleAction> Act; 1577 Act.reset(new PrecompilePreambleAction(*this)); 1578 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { 1579 llvm::sys::fs::remove(FrontendOpts.OutputFile); 1580 Preamble.clear(); 1581 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1582 PreprocessorOpts.RemappedFileBuffers.pop_back(); 1583 return nullptr; 1584 } 1585 1586 Act->Execute(); 1587 1588 // Transfer any diagnostics generated when parsing the preamble into the set 1589 // of preamble diagnostics. 1590 for (stored_diag_iterator I = stored_diag_afterDriver_begin(), 1591 E = stored_diag_end(); 1592 I != E; ++I) 1593 PreambleDiagnostics.push_back( 1594 makeStandaloneDiagnostic(Clang->getLangOpts(), *I)); 1595 1596 Act->EndSourceFile(); 1597 1598 checkAndRemoveNonDriverDiags(StoredDiagnostics); 1599 1600 if (!Act->hasEmittedPreamblePCH()) { 1601 // The preamble PCH failed (e.g. there was a module loading fatal error), 1602 // so no precompiled header was generated. Forget that we even tried. 1603 // FIXME: Should we leave a note for ourselves to try again? 1604 llvm::sys::fs::remove(FrontendOpts.OutputFile); 1605 Preamble.clear(); 1606 TopLevelDeclsInPreamble.clear(); 1607 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1608 PreprocessorOpts.RemappedFileBuffers.pop_back(); 1609 return nullptr; 1610 } 1611 1612 // Keep track of the preamble we precompiled. 1613 setPreambleFile(this, FrontendOpts.OutputFile); 1614 NumWarningsInPreamble = getDiagnostics().getNumWarnings(); 1615 1616 // Keep track of all of the files that the source manager knows about, 1617 // so we can verify whether they have changed or not. 1618 FilesInPreamble.clear(); 1619 SourceManager &SourceMgr = Clang->getSourceManager(); 1620 for (auto &Filename : PreambleDepCollector->getDependencies()) { 1621 const FileEntry *File = Clang->getFileManager().getFile(Filename); 1622 if (!File || File == SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())) 1623 continue; 1624 if (time_t ModTime = File->getModificationTime()) { 1625 FilesInPreamble[File->getName()] = PreambleFileHash::createForFile( 1626 File->getSize(), ModTime); 1627 } else { 1628 llvm::MemoryBuffer *Buffer = SourceMgr.getMemoryBufferForFile(File); 1629 FilesInPreamble[File->getName()] = 1630 PreambleFileHash::createForMemoryBuffer(Buffer); 1631 } 1632 } 1633 1634 PreambleRebuildCounter = 1; 1635 PreprocessorOpts.RemappedFileBuffers.pop_back(); 1636 1637 // If the hash of top-level entities differs from the hash of the top-level 1638 // entities the last time we rebuilt the preamble, clear out the completion 1639 // cache. 1640 if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) { 1641 CompletionCacheTopLevelHashValue = 0; 1642 PreambleTopLevelHashValue = CurrentTopLevelHashValue; 1643 } 1644 1645 return llvm::MemoryBuffer::getMemBufferCopy(NewPreamble.Buffer->getBuffer(), 1646 MainFilename); 1647 } 1648 1649 void ASTUnit::RealizeTopLevelDeclsFromPreamble() { 1650 std::vector<Decl *> Resolved; 1651 Resolved.reserve(TopLevelDeclsInPreamble.size()); 1652 ExternalASTSource &Source = *getASTContext().getExternalSource(); 1653 for (serialization::DeclID TopLevelDecl : TopLevelDeclsInPreamble) { 1654 // Resolve the declaration ID to an actual declaration, possibly 1655 // deserializing the declaration in the process. 1656 if (Decl *D = Source.GetExternalDecl(TopLevelDecl)) 1657 Resolved.push_back(D); 1658 } 1659 TopLevelDeclsInPreamble.clear(); 1660 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end()); 1661 } 1662 1663 void ASTUnit::transferASTDataFromCompilerInstance(CompilerInstance &CI) { 1664 // Steal the created target, context, and preprocessor if they have been 1665 // created. 1666 assert(CI.hasInvocation() && "missing invocation"); 1667 LangOpts = CI.getInvocation().LangOpts; 1668 TheSema = CI.takeSema(); 1669 Consumer = CI.takeASTConsumer(); 1670 if (CI.hasASTContext()) 1671 Ctx = &CI.getASTContext(); 1672 if (CI.hasPreprocessor()) 1673 PP = &CI.getPreprocessor(); 1674 CI.setSourceManager(nullptr); 1675 CI.setFileManager(nullptr); 1676 if (CI.hasTarget()) 1677 Target = &CI.getTarget(); 1678 Reader = CI.getModuleManager(); 1679 HadModuleLoaderFatalFailure = CI.hadModuleLoaderFatalFailure(); 1680 } 1681 1682 StringRef ASTUnit::getMainFileName() const { 1683 if (Invocation && !Invocation->getFrontendOpts().Inputs.empty()) { 1684 const FrontendInputFile &Input = Invocation->getFrontendOpts().Inputs[0]; 1685 if (Input.isFile()) 1686 return Input.getFile(); 1687 else 1688 return Input.getBuffer()->getBufferIdentifier(); 1689 } 1690 1691 if (SourceMgr) { 1692 if (const FileEntry * 1693 FE = SourceMgr->getFileEntryForID(SourceMgr->getMainFileID())) 1694 return FE->getName(); 1695 } 1696 1697 return StringRef(); 1698 } 1699 1700 StringRef ASTUnit::getASTFileName() const { 1701 if (!isMainFileAST()) 1702 return StringRef(); 1703 1704 serialization::ModuleFile & 1705 Mod = Reader->getModuleManager().getPrimaryModule(); 1706 return Mod.FileName; 1707 } 1708 1709 ASTUnit *ASTUnit::create(CompilerInvocation *CI, 1710 IntrusiveRefCntPtr<DiagnosticsEngine> Diags, 1711 bool CaptureDiagnostics, 1712 bool UserFilesAreVolatile) { 1713 std::unique_ptr<ASTUnit> AST; 1714 AST.reset(new ASTUnit(false)); 1715 ConfigureDiags(Diags, *AST, CaptureDiagnostics); 1716 AST->Diagnostics = Diags; 1717 AST->Invocation = CI; 1718 AST->FileSystemOpts = CI->getFileSystemOpts(); 1719 IntrusiveRefCntPtr<vfs::FileSystem> VFS = 1720 createVFSFromCompilerInvocation(*CI, *Diags); 1721 if (!VFS) 1722 return nullptr; 1723 AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); 1724 AST->UserFilesAreVolatile = UserFilesAreVolatile; 1725 AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr, 1726 UserFilesAreVolatile); 1727 1728 return AST.release(); 1729 } 1730 1731 ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( 1732 CompilerInvocation *CI, 1733 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 1734 IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FrontendAction *Action, 1735 ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, 1736 bool OnlyLocalDecls, bool CaptureDiagnostics, 1737 unsigned PrecompilePreambleAfterNParses, bool CacheCodeCompletionResults, 1738 bool IncludeBriefCommentsInCodeCompletion, bool UserFilesAreVolatile, 1739 std::unique_ptr<ASTUnit> *ErrAST) { 1740 assert(CI && "A CompilerInvocation is required"); 1741 1742 std::unique_ptr<ASTUnit> OwnAST; 1743 ASTUnit *AST = Unit; 1744 if (!AST) { 1745 // Create the AST unit. 1746 OwnAST.reset(create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile)); 1747 AST = OwnAST.get(); 1748 if (!AST) 1749 return nullptr; 1750 } 1751 1752 if (!ResourceFilesPath.empty()) { 1753 // Override the resources path. 1754 CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; 1755 } 1756 AST->OnlyLocalDecls = OnlyLocalDecls; 1757 AST->CaptureDiagnostics = CaptureDiagnostics; 1758 if (PrecompilePreambleAfterNParses > 0) 1759 AST->PreambleRebuildCounter = PrecompilePreambleAfterNParses; 1760 AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete; 1761 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; 1762 AST->IncludeBriefCommentsInCodeCompletion 1763 = IncludeBriefCommentsInCodeCompletion; 1764 1765 // Recover resources if we crash before exiting this method. 1766 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 1767 ASTUnitCleanup(OwnAST.get()); 1768 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 1769 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 1770 DiagCleanup(Diags.get()); 1771 1772 // We'll manage file buffers ourselves. 1773 CI->getPreprocessorOpts().RetainRemappedFileBuffers = true; 1774 CI->getFrontendOpts().DisableFree = false; 1775 ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts()); 1776 1777 // Create the compiler instance to use for building the AST. 1778 std::unique_ptr<CompilerInstance> Clang( 1779 new CompilerInstance(std::move(PCHContainerOps))); 1780 1781 // Recover resources if we crash before exiting this method. 1782 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 1783 CICleanup(Clang.get()); 1784 1785 Clang->setInvocation(CI); 1786 AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); 1787 1788 // Set up diagnostics, capturing any diagnostics that would 1789 // otherwise be dropped. 1790 Clang->setDiagnostics(&AST->getDiagnostics()); 1791 1792 // Create the target instance. 1793 Clang->setTarget(TargetInfo::CreateTargetInfo( 1794 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 1795 if (!Clang->hasTarget()) 1796 return nullptr; 1797 1798 // Inform the target of the language options. 1799 // 1800 // FIXME: We shouldn't need to do this, the target should be immutable once 1801 // created. This complexity should be lifted elsewhere. 1802 Clang->getTarget().adjust(Clang->getLangOpts()); 1803 1804 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 1805 "Invocation must have exactly one source file!"); 1806 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && 1807 "FIXME: AST inputs not yet supported here!"); 1808 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && 1809 "IR inputs not supported here!"); 1810 1811 // Configure the various subsystems. 1812 AST->TheSema.reset(); 1813 AST->Ctx = nullptr; 1814 AST->PP = nullptr; 1815 AST->Reader = nullptr; 1816 1817 // Create a file manager object to provide access to and cache the filesystem. 1818 Clang->setFileManager(&AST->getFileManager()); 1819 1820 // Create the source manager. 1821 Clang->setSourceManager(&AST->getSourceManager()); 1822 1823 FrontendAction *Act = Action; 1824 1825 std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct; 1826 if (!Act) { 1827 TrackerAct.reset(new TopLevelDeclTrackerAction(*AST)); 1828 Act = TrackerAct.get(); 1829 } 1830 1831 // Recover resources if we crash before exiting this method. 1832 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction> 1833 ActCleanup(TrackerAct.get()); 1834 1835 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { 1836 AST->transferASTDataFromCompilerInstance(*Clang); 1837 if (OwnAST && ErrAST) 1838 ErrAST->swap(OwnAST); 1839 1840 return nullptr; 1841 } 1842 1843 if (Persistent && !TrackerAct) { 1844 Clang->getPreprocessor().addPPCallbacks( 1845 llvm::make_unique<MacroDefinitionTrackerPPCallbacks>( 1846 AST->getCurrentTopLevelHashValue())); 1847 std::vector<std::unique_ptr<ASTConsumer>> Consumers; 1848 if (Clang->hasASTConsumer()) 1849 Consumers.push_back(Clang->takeASTConsumer()); 1850 Consumers.push_back(llvm::make_unique<TopLevelDeclTrackerConsumer>( 1851 *AST, AST->getCurrentTopLevelHashValue())); 1852 Clang->setASTConsumer( 1853 llvm::make_unique<MultiplexConsumer>(std::move(Consumers))); 1854 } 1855 if (!Act->Execute()) { 1856 AST->transferASTDataFromCompilerInstance(*Clang); 1857 if (OwnAST && ErrAST) 1858 ErrAST->swap(OwnAST); 1859 1860 return nullptr; 1861 } 1862 1863 // Steal the created target, context, and preprocessor. 1864 AST->transferASTDataFromCompilerInstance(*Clang); 1865 1866 Act->EndSourceFile(); 1867 1868 if (OwnAST) 1869 return OwnAST.release(); 1870 else 1871 return AST; 1872 } 1873 1874 bool ASTUnit::LoadFromCompilerInvocation( 1875 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 1876 unsigned PrecompilePreambleAfterNParses) { 1877 if (!Invocation) 1878 return true; 1879 1880 // We'll manage file buffers ourselves. 1881 Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true; 1882 Invocation->getFrontendOpts().DisableFree = false; 1883 ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); 1884 1885 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer; 1886 if (PrecompilePreambleAfterNParses > 0) { 1887 PreambleRebuildCounter = PrecompilePreambleAfterNParses; 1888 OverrideMainBuffer = 1889 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation); 1890 } 1891 1892 SimpleTimer ParsingTimer(WantTiming); 1893 ParsingTimer.setOutput("Parsing " + getMainFileName()); 1894 1895 // Recover resources if we crash before exiting this method. 1896 llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer> 1897 MemBufferCleanup(OverrideMainBuffer.get()); 1898 1899 return Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer)); 1900 } 1901 1902 std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation( 1903 CompilerInvocation *CI, 1904 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 1905 IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr, 1906 bool OnlyLocalDecls, bool CaptureDiagnostics, 1907 unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind, 1908 bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, 1909 bool UserFilesAreVolatile) { 1910 // Create the AST unit. 1911 std::unique_ptr<ASTUnit> AST(new ASTUnit(false)); 1912 ConfigureDiags(Diags, *AST, CaptureDiagnostics); 1913 AST->Diagnostics = Diags; 1914 AST->OnlyLocalDecls = OnlyLocalDecls; 1915 AST->CaptureDiagnostics = CaptureDiagnostics; 1916 AST->TUKind = TUKind; 1917 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; 1918 AST->IncludeBriefCommentsInCodeCompletion 1919 = IncludeBriefCommentsInCodeCompletion; 1920 AST->Invocation = CI; 1921 AST->FileSystemOpts = FileMgr->getFileSystemOpts(); 1922 AST->FileMgr = FileMgr; 1923 AST->UserFilesAreVolatile = UserFilesAreVolatile; 1924 1925 // Recover resources if we crash before exiting this method. 1926 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 1927 ASTUnitCleanup(AST.get()); 1928 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 1929 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 1930 DiagCleanup(Diags.get()); 1931 1932 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), 1933 PrecompilePreambleAfterNParses)) 1934 return nullptr; 1935 return AST; 1936 } 1937 1938 ASTUnit *ASTUnit::LoadFromCommandLine( 1939 const char **ArgBegin, const char **ArgEnd, 1940 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 1941 IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath, 1942 bool OnlyLocalDecls, bool CaptureDiagnostics, 1943 ArrayRef<RemappedFile> RemappedFiles, bool RemappedFilesKeepOriginalName, 1944 unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind, 1945 bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion, 1946 bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies, 1947 bool UserFilesAreVolatile, bool ForSerialization, 1948 llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST) { 1949 assert(Diags.get() && "no DiagnosticsEngine was provided"); 1950 1951 SmallVector<StoredDiagnostic, 4> StoredDiagnostics; 1952 1953 IntrusiveRefCntPtr<CompilerInvocation> CI; 1954 1955 { 1956 1957 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, 1958 StoredDiagnostics); 1959 1960 CI = clang::createInvocationFromCommandLine( 1961 llvm::makeArrayRef(ArgBegin, ArgEnd), 1962 Diags); 1963 if (!CI) 1964 return nullptr; 1965 } 1966 1967 // Override any files that need remapping 1968 for (const auto &RemappedFile : RemappedFiles) { 1969 CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first, 1970 RemappedFile.second); 1971 } 1972 PreprocessorOptions &PPOpts = CI->getPreprocessorOpts(); 1973 PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName; 1974 PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors; 1975 1976 // Override the resources path. 1977 CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; 1978 1979 CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies; 1980 1981 if (ModuleFormat) 1982 CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue(); 1983 1984 // Create the AST unit. 1985 std::unique_ptr<ASTUnit> AST; 1986 AST.reset(new ASTUnit(false)); 1987 ConfigureDiags(Diags, *AST, CaptureDiagnostics); 1988 AST->Diagnostics = Diags; 1989 AST->FileSystemOpts = CI->getFileSystemOpts(); 1990 IntrusiveRefCntPtr<vfs::FileSystem> VFS = 1991 createVFSFromCompilerInvocation(*CI, *Diags); 1992 if (!VFS) 1993 return nullptr; 1994 AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); 1995 AST->OnlyLocalDecls = OnlyLocalDecls; 1996 AST->CaptureDiagnostics = CaptureDiagnostics; 1997 AST->TUKind = TUKind; 1998 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; 1999 AST->IncludeBriefCommentsInCodeCompletion 2000 = IncludeBriefCommentsInCodeCompletion; 2001 AST->UserFilesAreVolatile = UserFilesAreVolatile; 2002 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); 2003 AST->StoredDiagnostics.swap(StoredDiagnostics); 2004 AST->Invocation = CI; 2005 if (ForSerialization) 2006 AST->WriterData.reset(new ASTWriterData()); 2007 // Zero out now to ease cleanup during crash recovery. 2008 CI = nullptr; 2009 Diags = nullptr; 2010 2011 // Recover resources if we crash before exiting this method. 2012 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 2013 ASTUnitCleanup(AST.get()); 2014 2015 if (AST->LoadFromCompilerInvocation(std::move(PCHContainerOps), 2016 PrecompilePreambleAfterNParses)) { 2017 // Some error occurred, if caller wants to examine diagnostics, pass it the 2018 // ASTUnit. 2019 if (ErrAST) { 2020 AST->StoredDiagnostics.swap(AST->FailedParseDiagnostics); 2021 ErrAST->swap(AST); 2022 } 2023 return nullptr; 2024 } 2025 2026 return AST.release(); 2027 } 2028 2029 bool ASTUnit::Reparse(std::shared_ptr<PCHContainerOperations> PCHContainerOps, 2030 ArrayRef<RemappedFile> RemappedFiles) { 2031 if (!Invocation) 2032 return true; 2033 2034 clearFileLevelDecls(); 2035 2036 SimpleTimer ParsingTimer(WantTiming); 2037 ParsingTimer.setOutput("Reparsing " + getMainFileName()); 2038 2039 // Remap files. 2040 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 2041 for (const auto &RB : PPOpts.RemappedFileBuffers) 2042 delete RB.second; 2043 2044 Invocation->getPreprocessorOpts().clearRemappedFiles(); 2045 for (const auto &RemappedFile : RemappedFiles) { 2046 Invocation->getPreprocessorOpts().addRemappedFile(RemappedFile.first, 2047 RemappedFile.second); 2048 } 2049 2050 // If we have a preamble file lying around, or if we might try to 2051 // build a precompiled preamble, do so now. 2052 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer; 2053 if (!getPreambleFile(this).empty() || PreambleRebuildCounter > 0) 2054 OverrideMainBuffer = 2055 getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation); 2056 2057 // Clear out the diagnostics state. 2058 FileMgr.reset(); 2059 getDiagnostics().Reset(); 2060 ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); 2061 if (OverrideMainBuffer) 2062 getDiagnostics().setNumWarnings(NumWarningsInPreamble); 2063 2064 // Parse the sources 2065 bool Result = 2066 Parse(std::move(PCHContainerOps), std::move(OverrideMainBuffer)); 2067 2068 // If we're caching global code-completion results, and the top-level 2069 // declarations have changed, clear out the code-completion cache. 2070 if (!Result && ShouldCacheCodeCompletionResults && 2071 CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue) 2072 CacheCodeCompletionResults(); 2073 2074 // We now need to clear out the completion info related to this translation 2075 // unit; it'll be recreated if necessary. 2076 CCTUInfo.reset(); 2077 2078 return Result; 2079 } 2080 2081 //----------------------------------------------------------------------------// 2082 // Code completion 2083 //----------------------------------------------------------------------------// 2084 2085 namespace { 2086 /// \brief Code completion consumer that combines the cached code-completion 2087 /// results from an ASTUnit with the code-completion results provided to it, 2088 /// then passes the result on to 2089 class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer { 2090 uint64_t NormalContexts; 2091 ASTUnit &AST; 2092 CodeCompleteConsumer &Next; 2093 2094 public: 2095 AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, 2096 const CodeCompleteOptions &CodeCompleteOpts) 2097 : CodeCompleteConsumer(CodeCompleteOpts, Next.isOutputBinary()), 2098 AST(AST), Next(Next) 2099 { 2100 // Compute the set of contexts in which we will look when we don't have 2101 // any information about the specific context. 2102 NormalContexts 2103 = (1LL << CodeCompletionContext::CCC_TopLevel) 2104 | (1LL << CodeCompletionContext::CCC_ObjCInterface) 2105 | (1LL << CodeCompletionContext::CCC_ObjCImplementation) 2106 | (1LL << CodeCompletionContext::CCC_ObjCIvarList) 2107 | (1LL << CodeCompletionContext::CCC_Statement) 2108 | (1LL << CodeCompletionContext::CCC_Expression) 2109 | (1LL << CodeCompletionContext::CCC_ObjCMessageReceiver) 2110 | (1LL << CodeCompletionContext::CCC_DotMemberAccess) 2111 | (1LL << CodeCompletionContext::CCC_ArrowMemberAccess) 2112 | (1LL << CodeCompletionContext::CCC_ObjCPropertyAccess) 2113 | (1LL << CodeCompletionContext::CCC_ObjCProtocolName) 2114 | (1LL << CodeCompletionContext::CCC_ParenthesizedExpression) 2115 | (1LL << CodeCompletionContext::CCC_Recovery); 2116 2117 if (AST.getASTContext().getLangOpts().CPlusPlus) 2118 NormalContexts |= (1LL << CodeCompletionContext::CCC_EnumTag) 2119 | (1LL << CodeCompletionContext::CCC_UnionTag) 2120 | (1LL << CodeCompletionContext::CCC_ClassOrStructTag); 2121 } 2122 2123 void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, 2124 CodeCompletionResult *Results, 2125 unsigned NumResults) override; 2126 2127 void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 2128 OverloadCandidate *Candidates, 2129 unsigned NumCandidates) override { 2130 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates); 2131 } 2132 2133 CodeCompletionAllocator &getAllocator() override { 2134 return Next.getAllocator(); 2135 } 2136 2137 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { 2138 return Next.getCodeCompletionTUInfo(); 2139 } 2140 }; 2141 } // anonymous namespace 2142 2143 /// \brief Helper function that computes which global names are hidden by the 2144 /// local code-completion results. 2145 static void CalculateHiddenNames(const CodeCompletionContext &Context, 2146 CodeCompletionResult *Results, 2147 unsigned NumResults, 2148 ASTContext &Ctx, 2149 llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){ 2150 bool OnlyTagNames = false; 2151 switch (Context.getKind()) { 2152 case CodeCompletionContext::CCC_Recovery: 2153 case CodeCompletionContext::CCC_TopLevel: 2154 case CodeCompletionContext::CCC_ObjCInterface: 2155 case CodeCompletionContext::CCC_ObjCImplementation: 2156 case CodeCompletionContext::CCC_ObjCIvarList: 2157 case CodeCompletionContext::CCC_ClassStructUnion: 2158 case CodeCompletionContext::CCC_Statement: 2159 case CodeCompletionContext::CCC_Expression: 2160 case CodeCompletionContext::CCC_ObjCMessageReceiver: 2161 case CodeCompletionContext::CCC_DotMemberAccess: 2162 case CodeCompletionContext::CCC_ArrowMemberAccess: 2163 case CodeCompletionContext::CCC_ObjCPropertyAccess: 2164 case CodeCompletionContext::CCC_Namespace: 2165 case CodeCompletionContext::CCC_Type: 2166 case CodeCompletionContext::CCC_Name: 2167 case CodeCompletionContext::CCC_PotentiallyQualifiedName: 2168 case CodeCompletionContext::CCC_ParenthesizedExpression: 2169 case CodeCompletionContext::CCC_ObjCInterfaceName: 2170 break; 2171 2172 case CodeCompletionContext::CCC_EnumTag: 2173 case CodeCompletionContext::CCC_UnionTag: 2174 case CodeCompletionContext::CCC_ClassOrStructTag: 2175 OnlyTagNames = true; 2176 break; 2177 2178 case CodeCompletionContext::CCC_ObjCProtocolName: 2179 case CodeCompletionContext::CCC_MacroName: 2180 case CodeCompletionContext::CCC_MacroNameUse: 2181 case CodeCompletionContext::CCC_PreprocessorExpression: 2182 case CodeCompletionContext::CCC_PreprocessorDirective: 2183 case CodeCompletionContext::CCC_NaturalLanguage: 2184 case CodeCompletionContext::CCC_SelectorName: 2185 case CodeCompletionContext::CCC_TypeQualifiers: 2186 case CodeCompletionContext::CCC_Other: 2187 case CodeCompletionContext::CCC_OtherWithMacros: 2188 case CodeCompletionContext::CCC_ObjCInstanceMessage: 2189 case CodeCompletionContext::CCC_ObjCClassMessage: 2190 case CodeCompletionContext::CCC_ObjCCategoryName: 2191 // We're looking for nothing, or we're looking for names that cannot 2192 // be hidden. 2193 return; 2194 } 2195 2196 typedef CodeCompletionResult Result; 2197 for (unsigned I = 0; I != NumResults; ++I) { 2198 if (Results[I].Kind != Result::RK_Declaration) 2199 continue; 2200 2201 unsigned IDNS 2202 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace(); 2203 2204 bool Hiding = false; 2205 if (OnlyTagNames) 2206 Hiding = (IDNS & Decl::IDNS_Tag); 2207 else { 2208 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | 2209 Decl::IDNS_Namespace | Decl::IDNS_Ordinary | 2210 Decl::IDNS_NonMemberOperator); 2211 if (Ctx.getLangOpts().CPlusPlus) 2212 HiddenIDNS |= Decl::IDNS_Tag; 2213 Hiding = (IDNS & HiddenIDNS); 2214 } 2215 2216 if (!Hiding) 2217 continue; 2218 2219 DeclarationName Name = Results[I].Declaration->getDeclName(); 2220 if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo()) 2221 HiddenNames.insert(Identifier->getName()); 2222 else 2223 HiddenNames.insert(Name.getAsString()); 2224 } 2225 } 2226 2227 void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, 2228 CodeCompletionContext Context, 2229 CodeCompletionResult *Results, 2230 unsigned NumResults) { 2231 // Merge the results we were given with the results we cached. 2232 bool AddedResult = false; 2233 uint64_t InContexts = 2234 Context.getKind() == CodeCompletionContext::CCC_Recovery 2235 ? NormalContexts : (1LL << Context.getKind()); 2236 // Contains the set of names that are hidden by "local" completion results. 2237 llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames; 2238 typedef CodeCompletionResult Result; 2239 SmallVector<Result, 8> AllResults; 2240 for (ASTUnit::cached_completion_iterator 2241 C = AST.cached_completion_begin(), 2242 CEnd = AST.cached_completion_end(); 2243 C != CEnd; ++C) { 2244 // If the context we are in matches any of the contexts we are 2245 // interested in, we'll add this result. 2246 if ((C->ShowInContexts & InContexts) == 0) 2247 continue; 2248 2249 // If we haven't added any results previously, do so now. 2250 if (!AddedResult) { 2251 CalculateHiddenNames(Context, Results, NumResults, S.Context, 2252 HiddenNames); 2253 AllResults.insert(AllResults.end(), Results, Results + NumResults); 2254 AddedResult = true; 2255 } 2256 2257 // Determine whether this global completion result is hidden by a local 2258 // completion result. If so, skip it. 2259 if (C->Kind != CXCursor_MacroDefinition && 2260 HiddenNames.count(C->Completion->getTypedText())) 2261 continue; 2262 2263 // Adjust priority based on similar type classes. 2264 unsigned Priority = C->Priority; 2265 CodeCompletionString *Completion = C->Completion; 2266 if (!Context.getPreferredType().isNull()) { 2267 if (C->Kind == CXCursor_MacroDefinition) { 2268 Priority = getMacroUsagePriority(C->Completion->getTypedText(), 2269 S.getLangOpts(), 2270 Context.getPreferredType()->isAnyPointerType()); 2271 } else if (C->Type) { 2272 CanQualType Expected 2273 = S.Context.getCanonicalType( 2274 Context.getPreferredType().getUnqualifiedType()); 2275 SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected); 2276 if (ExpectedSTC == C->TypeClass) { 2277 // We know this type is similar; check for an exact match. 2278 llvm::StringMap<unsigned> &CachedCompletionTypes 2279 = AST.getCachedCompletionTypes(); 2280 llvm::StringMap<unsigned>::iterator Pos 2281 = CachedCompletionTypes.find(QualType(Expected).getAsString()); 2282 if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type) 2283 Priority /= CCF_ExactTypeMatch; 2284 else 2285 Priority /= CCF_SimilarTypeMatch; 2286 } 2287 } 2288 } 2289 2290 // Adjust the completion string, if required. 2291 if (C->Kind == CXCursor_MacroDefinition && 2292 Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) { 2293 // Create a new code-completion string that just contains the 2294 // macro name, without its arguments. 2295 CodeCompletionBuilder Builder(getAllocator(), getCodeCompletionTUInfo(), 2296 CCP_CodePattern, C->Availability); 2297 Builder.AddTypedTextChunk(C->Completion->getTypedText()); 2298 Priority = CCP_CodePattern; 2299 Completion = Builder.TakeString(); 2300 } 2301 2302 AllResults.push_back(Result(Completion, Priority, C->Kind, 2303 C->Availability)); 2304 } 2305 2306 // If we did not add any cached completion results, just forward the 2307 // results we were given to the next consumer. 2308 if (!AddedResult) { 2309 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); 2310 return; 2311 } 2312 2313 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(), 2314 AllResults.size()); 2315 } 2316 2317 void ASTUnit::CodeComplete( 2318 StringRef File, unsigned Line, unsigned Column, 2319 ArrayRef<RemappedFile> RemappedFiles, bool IncludeMacros, 2320 bool IncludeCodePatterns, bool IncludeBriefComments, 2321 CodeCompleteConsumer &Consumer, 2322 std::shared_ptr<PCHContainerOperations> PCHContainerOps, 2323 DiagnosticsEngine &Diag, LangOptions &LangOpts, SourceManager &SourceMgr, 2324 FileManager &FileMgr, SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics, 2325 SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) { 2326 if (!Invocation) 2327 return; 2328 2329 SimpleTimer CompletionTimer(WantTiming); 2330 CompletionTimer.setOutput("Code completion @ " + File + ":" + 2331 Twine(Line) + ":" + Twine(Column)); 2332 2333 IntrusiveRefCntPtr<CompilerInvocation> 2334 CCInvocation(new CompilerInvocation(*Invocation)); 2335 2336 FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts(); 2337 CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts; 2338 PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts(); 2339 2340 CodeCompleteOpts.IncludeMacros = IncludeMacros && 2341 CachedCompletionResults.empty(); 2342 CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns; 2343 CodeCompleteOpts.IncludeGlobals = CachedCompletionResults.empty(); 2344 CodeCompleteOpts.IncludeBriefComments = IncludeBriefComments; 2345 2346 assert(IncludeBriefComments == this->IncludeBriefCommentsInCodeCompletion); 2347 2348 FrontendOpts.CodeCompletionAt.FileName = File; 2349 FrontendOpts.CodeCompletionAt.Line = Line; 2350 FrontendOpts.CodeCompletionAt.Column = Column; 2351 2352 // Set the language options appropriately. 2353 LangOpts = *CCInvocation->getLangOpts(); 2354 2355 // Spell-checking and warnings are wasteful during code-completion. 2356 LangOpts.SpellChecking = false; 2357 CCInvocation->getDiagnosticOpts().IgnoreWarnings = true; 2358 2359 std::unique_ptr<CompilerInstance> Clang( 2360 new CompilerInstance(PCHContainerOps)); 2361 2362 // Recover resources if we crash before exiting this method. 2363 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 2364 CICleanup(Clang.get()); 2365 2366 Clang->setInvocation(&*CCInvocation); 2367 OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); 2368 2369 // Set up diagnostics, capturing any diagnostics produced. 2370 Clang->setDiagnostics(&Diag); 2371 CaptureDroppedDiagnostics Capture(true, 2372 Clang->getDiagnostics(), 2373 StoredDiagnostics); 2374 ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts()); 2375 2376 // Create the target instance. 2377 Clang->setTarget(TargetInfo::CreateTargetInfo( 2378 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 2379 if (!Clang->hasTarget()) { 2380 Clang->setInvocation(nullptr); 2381 return; 2382 } 2383 2384 // Inform the target of the language options. 2385 // 2386 // FIXME: We shouldn't need to do this, the target should be immutable once 2387 // created. This complexity should be lifted elsewhere. 2388 Clang->getTarget().adjust(Clang->getLangOpts()); 2389 2390 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 2391 "Invocation must have exactly one source file!"); 2392 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_AST && 2393 "FIXME: AST inputs not yet supported here!"); 2394 assert(Clang->getFrontendOpts().Inputs[0].getKind() != IK_LLVM_IR && 2395 "IR inputs not support here!"); 2396 2397 2398 // Use the source and file managers that we were given. 2399 Clang->setFileManager(&FileMgr); 2400 Clang->setSourceManager(&SourceMgr); 2401 2402 // Remap files. 2403 PreprocessorOpts.clearRemappedFiles(); 2404 PreprocessorOpts.RetainRemappedFileBuffers = true; 2405 for (const auto &RemappedFile : RemappedFiles) { 2406 PreprocessorOpts.addRemappedFile(RemappedFile.first, RemappedFile.second); 2407 OwnedBuffers.push_back(RemappedFile.second); 2408 } 2409 2410 // Use the code completion consumer we were given, but adding any cached 2411 // code-completion results. 2412 AugmentedCodeCompleteConsumer *AugmentedConsumer 2413 = new AugmentedCodeCompleteConsumer(*this, Consumer, CodeCompleteOpts); 2414 Clang->setCodeCompletionConsumer(AugmentedConsumer); 2415 2416 // If we have a precompiled preamble, try to use it. We only allow 2417 // the use of the precompiled preamble if we're if the completion 2418 // point is within the main file, after the end of the precompiled 2419 // preamble. 2420 std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer; 2421 if (!getPreambleFile(this).empty()) { 2422 std::string CompleteFilePath(File); 2423 llvm::sys::fs::UniqueID CompleteFileID; 2424 2425 if (!llvm::sys::fs::getUniqueID(CompleteFilePath, CompleteFileID)) { 2426 std::string MainPath(OriginalSourceFile); 2427 llvm::sys::fs::UniqueID MainID; 2428 if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) { 2429 if (CompleteFileID == MainID && Line > 1) 2430 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble( 2431 PCHContainerOps, *CCInvocation, false, Line - 1); 2432 } 2433 } 2434 } 2435 2436 // If the main file has been overridden due to the use of a preamble, 2437 // make that override happen and introduce the preamble. 2438 if (OverrideMainBuffer) { 2439 PreprocessorOpts.addRemappedFile(OriginalSourceFile, 2440 OverrideMainBuffer.get()); 2441 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); 2442 PreprocessorOpts.PrecompiledPreambleBytes.second 2443 = PreambleEndsAtStartOfLine; 2444 PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this); 2445 PreprocessorOpts.DisablePCHValidation = true; 2446 2447 OwnedBuffers.push_back(OverrideMainBuffer.release()); 2448 } else { 2449 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 2450 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 2451 } 2452 2453 // Disable the preprocessing record if modules are not enabled. 2454 if (!Clang->getLangOpts().Modules) 2455 PreprocessorOpts.DetailedRecord = false; 2456 2457 std::unique_ptr<SyntaxOnlyAction> Act; 2458 Act.reset(new SyntaxOnlyAction); 2459 if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { 2460 Act->Execute(); 2461 Act->EndSourceFile(); 2462 } 2463 } 2464 2465 bool ASTUnit::Save(StringRef File) { 2466 if (HadModuleLoaderFatalFailure) 2467 return true; 2468 2469 // Write to a temporary file and later rename it to the actual file, to avoid 2470 // possible race conditions. 2471 SmallString<128> TempPath; 2472 TempPath = File; 2473 TempPath += "-%%%%%%%%"; 2474 int fd; 2475 if (llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath)) 2476 return true; 2477 2478 // FIXME: Can we somehow regenerate the stat cache here, or do we need to 2479 // unconditionally create a stat cache when we parse the file? 2480 llvm::raw_fd_ostream Out(fd, /*shouldClose=*/true); 2481 2482 serialize(Out); 2483 Out.close(); 2484 if (Out.has_error()) { 2485 Out.clear_error(); 2486 return true; 2487 } 2488 2489 if (llvm::sys::fs::rename(TempPath, File)) { 2490 llvm::sys::fs::remove(TempPath); 2491 return true; 2492 } 2493 2494 return false; 2495 } 2496 2497 static bool serializeUnit(ASTWriter &Writer, 2498 SmallVectorImpl<char> &Buffer, 2499 Sema &S, 2500 bool hasErrors, 2501 raw_ostream &OS) { 2502 Writer.WriteAST(S, std::string(), nullptr, "", hasErrors); 2503 2504 // Write the generated bitstream to "Out". 2505 if (!Buffer.empty()) 2506 OS.write(Buffer.data(), Buffer.size()); 2507 2508 return false; 2509 } 2510 2511 bool ASTUnit::serialize(raw_ostream &OS) { 2512 // For serialization we are lenient if the errors were only warn-as-error kind. 2513 bool hasErrors = getDiagnostics().hasUncompilableErrorOccurred(); 2514 2515 if (WriterData) 2516 return serializeUnit(WriterData->Writer, WriterData->Buffer, 2517 getSema(), hasErrors, OS); 2518 2519 SmallString<128> Buffer; 2520 llvm::BitstreamWriter Stream(Buffer); 2521 ASTWriter Writer(Stream, { }); 2522 return serializeUnit(Writer, Buffer, getSema(), hasErrors, OS); 2523 } 2524 2525 typedef ContinuousRangeMap<unsigned, int, 2> SLocRemap; 2526 2527 void ASTUnit::TranslateStoredDiagnostics( 2528 FileManager &FileMgr, 2529 SourceManager &SrcMgr, 2530 const SmallVectorImpl<StandaloneDiagnostic> &Diags, 2531 SmallVectorImpl<StoredDiagnostic> &Out) { 2532 // Map the standalone diagnostic into the new source manager. We also need to 2533 // remap all the locations to the new view. This includes the diag location, 2534 // any associated source ranges, and the source ranges of associated fix-its. 2535 // FIXME: There should be a cleaner way to do this. 2536 2537 SmallVector<StoredDiagnostic, 4> Result; 2538 Result.reserve(Diags.size()); 2539 for (const StandaloneDiagnostic &SD : Diags) { 2540 // Rebuild the StoredDiagnostic. 2541 if (SD.Filename.empty()) 2542 continue; 2543 const FileEntry *FE = FileMgr.getFile(SD.Filename); 2544 if (!FE) 2545 continue; 2546 FileID FID = SrcMgr.translateFile(FE); 2547 SourceLocation FileLoc = SrcMgr.getLocForStartOfFile(FID); 2548 if (FileLoc.isInvalid()) 2549 continue; 2550 SourceLocation L = FileLoc.getLocWithOffset(SD.LocOffset); 2551 FullSourceLoc Loc(L, SrcMgr); 2552 2553 SmallVector<CharSourceRange, 4> Ranges; 2554 Ranges.reserve(SD.Ranges.size()); 2555 for (const auto &Range : SD.Ranges) { 2556 SourceLocation BL = FileLoc.getLocWithOffset(Range.first); 2557 SourceLocation EL = FileLoc.getLocWithOffset(Range.second); 2558 Ranges.push_back(CharSourceRange::getCharRange(BL, EL)); 2559 } 2560 2561 SmallVector<FixItHint, 2> FixIts; 2562 FixIts.reserve(SD.FixIts.size()); 2563 for (const StandaloneFixIt &FixIt : SD.FixIts) { 2564 FixIts.push_back(FixItHint()); 2565 FixItHint &FH = FixIts.back(); 2566 FH.CodeToInsert = FixIt.CodeToInsert; 2567 SourceLocation BL = FileLoc.getLocWithOffset(FixIt.RemoveRange.first); 2568 SourceLocation EL = FileLoc.getLocWithOffset(FixIt.RemoveRange.second); 2569 FH.RemoveRange = CharSourceRange::getCharRange(BL, EL); 2570 } 2571 2572 Result.push_back(StoredDiagnostic(SD.Level, SD.ID, 2573 SD.Message, Loc, Ranges, FixIts)); 2574 } 2575 Result.swap(Out); 2576 } 2577 2578 void ASTUnit::addFileLevelDecl(Decl *D) { 2579 assert(D); 2580 2581 // We only care about local declarations. 2582 if (D->isFromASTFile()) 2583 return; 2584 2585 SourceManager &SM = *SourceMgr; 2586 SourceLocation Loc = D->getLocation(); 2587 if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc)) 2588 return; 2589 2590 // We only keep track of the file-level declarations of each file. 2591 if (!D->getLexicalDeclContext()->isFileContext()) 2592 return; 2593 2594 SourceLocation FileLoc = SM.getFileLoc(Loc); 2595 assert(SM.isLocalSourceLocation(FileLoc)); 2596 FileID FID; 2597 unsigned Offset; 2598 std::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc); 2599 if (FID.isInvalid()) 2600 return; 2601 2602 LocDeclsTy *&Decls = FileDecls[FID]; 2603 if (!Decls) 2604 Decls = new LocDeclsTy(); 2605 2606 std::pair<unsigned, Decl *> LocDecl(Offset, D); 2607 2608 if (Decls->empty() || Decls->back().first <= Offset) { 2609 Decls->push_back(LocDecl); 2610 return; 2611 } 2612 2613 LocDeclsTy::iterator I = std::upper_bound(Decls->begin(), Decls->end(), 2614 LocDecl, llvm::less_first()); 2615 2616 Decls->insert(I, LocDecl); 2617 } 2618 2619 void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length, 2620 SmallVectorImpl<Decl *> &Decls) { 2621 if (File.isInvalid()) 2622 return; 2623 2624 if (SourceMgr->isLoadedFileID(File)) { 2625 assert(Ctx->getExternalSource() && "No external source!"); 2626 return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length, 2627 Decls); 2628 } 2629 2630 FileDeclsTy::iterator I = FileDecls.find(File); 2631 if (I == FileDecls.end()) 2632 return; 2633 2634 LocDeclsTy &LocDecls = *I->second; 2635 if (LocDecls.empty()) 2636 return; 2637 2638 LocDeclsTy::iterator BeginIt = 2639 std::lower_bound(LocDecls.begin(), LocDecls.end(), 2640 std::make_pair(Offset, (Decl *)nullptr), 2641 llvm::less_first()); 2642 if (BeginIt != LocDecls.begin()) 2643 --BeginIt; 2644 2645 // If we are pointing at a top-level decl inside an objc container, we need 2646 // to backtrack until we find it otherwise we will fail to report that the 2647 // region overlaps with an objc container. 2648 while (BeginIt != LocDecls.begin() && 2649 BeginIt->second->isTopLevelDeclInObjCContainer()) 2650 --BeginIt; 2651 2652 LocDeclsTy::iterator EndIt = std::upper_bound( 2653 LocDecls.begin(), LocDecls.end(), 2654 std::make_pair(Offset + Length, (Decl *)nullptr), llvm::less_first()); 2655 if (EndIt != LocDecls.end()) 2656 ++EndIt; 2657 2658 for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt) 2659 Decls.push_back(DIt->second); 2660 } 2661 2662 SourceLocation ASTUnit::getLocation(const FileEntry *File, 2663 unsigned Line, unsigned Col) const { 2664 const SourceManager &SM = getSourceManager(); 2665 SourceLocation Loc = SM.translateFileLineCol(File, Line, Col); 2666 return SM.getMacroArgExpandedLocation(Loc); 2667 } 2668 2669 SourceLocation ASTUnit::getLocation(const FileEntry *File, 2670 unsigned Offset) const { 2671 const SourceManager &SM = getSourceManager(); 2672 SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1); 2673 return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset)); 2674 } 2675 2676 /// \brief If \arg Loc is a loaded location from the preamble, returns 2677 /// the corresponding local location of the main file, otherwise it returns 2678 /// \arg Loc. 2679 SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) { 2680 FileID PreambleID; 2681 if (SourceMgr) 2682 PreambleID = SourceMgr->getPreambleFileID(); 2683 2684 if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) 2685 return Loc; 2686 2687 unsigned Offs; 2688 if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble.size()) { 2689 SourceLocation FileLoc 2690 = SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID()); 2691 return FileLoc.getLocWithOffset(Offs); 2692 } 2693 2694 return Loc; 2695 } 2696 2697 /// \brief If \arg Loc is a local location of the main file but inside the 2698 /// preamble chunk, returns the corresponding loaded location from the 2699 /// preamble, otherwise it returns \arg Loc. 2700 SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) { 2701 FileID PreambleID; 2702 if (SourceMgr) 2703 PreambleID = SourceMgr->getPreambleFileID(); 2704 2705 if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid()) 2706 return Loc; 2707 2708 unsigned Offs; 2709 if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) && 2710 Offs < Preamble.size()) { 2711 SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID); 2712 return FileLoc.getLocWithOffset(Offs); 2713 } 2714 2715 return Loc; 2716 } 2717 2718 bool ASTUnit::isInPreambleFileID(SourceLocation Loc) { 2719 FileID FID; 2720 if (SourceMgr) 2721 FID = SourceMgr->getPreambleFileID(); 2722 2723 if (Loc.isInvalid() || FID.isInvalid()) 2724 return false; 2725 2726 return SourceMgr->isInFileID(Loc, FID); 2727 } 2728 2729 bool ASTUnit::isInMainFileID(SourceLocation Loc) { 2730 FileID FID; 2731 if (SourceMgr) 2732 FID = SourceMgr->getMainFileID(); 2733 2734 if (Loc.isInvalid() || FID.isInvalid()) 2735 return false; 2736 2737 return SourceMgr->isInFileID(Loc, FID); 2738 } 2739 2740 SourceLocation ASTUnit::getEndOfPreambleFileID() { 2741 FileID FID; 2742 if (SourceMgr) 2743 FID = SourceMgr->getPreambleFileID(); 2744 2745 if (FID.isInvalid()) 2746 return SourceLocation(); 2747 2748 return SourceMgr->getLocForEndOfFile(FID); 2749 } 2750 2751 SourceLocation ASTUnit::getStartOfMainFileID() { 2752 FileID FID; 2753 if (SourceMgr) 2754 FID = SourceMgr->getMainFileID(); 2755 2756 if (FID.isInvalid()) 2757 return SourceLocation(); 2758 2759 return SourceMgr->getLocForStartOfFile(FID); 2760 } 2761 2762 llvm::iterator_range<PreprocessingRecord::iterator> 2763 ASTUnit::getLocalPreprocessingEntities() const { 2764 if (isMainFileAST()) { 2765 serialization::ModuleFile & 2766 Mod = Reader->getModuleManager().getPrimaryModule(); 2767 return Reader->getModulePreprocessedEntities(Mod); 2768 } 2769 2770 if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord()) 2771 return llvm::make_range(PPRec->local_begin(), PPRec->local_end()); 2772 2773 return llvm::make_range(PreprocessingRecord::iterator(), 2774 PreprocessingRecord::iterator()); 2775 } 2776 2777 bool ASTUnit::visitLocalTopLevelDecls(void *context, DeclVisitorFn Fn) { 2778 if (isMainFileAST()) { 2779 serialization::ModuleFile & 2780 Mod = Reader->getModuleManager().getPrimaryModule(); 2781 for (const Decl *D : Reader->getModuleFileLevelDecls(Mod)) { 2782 if (!Fn(context, D)) 2783 return false; 2784 } 2785 2786 return true; 2787 } 2788 2789 for (ASTUnit::top_level_iterator TL = top_level_begin(), 2790 TLEnd = top_level_end(); 2791 TL != TLEnd; ++TL) { 2792 if (!Fn(context, *TL)) 2793 return false; 2794 } 2795 2796 return true; 2797 } 2798 2799 const FileEntry *ASTUnit::getPCHFile() { 2800 if (!Reader) 2801 return nullptr; 2802 2803 serialization::ModuleFile *Mod = nullptr; 2804 Reader->getModuleManager().visit([&Mod](serialization::ModuleFile &M) { 2805 switch (M.Kind) { 2806 case serialization::MK_ImplicitModule: 2807 case serialization::MK_ExplicitModule: 2808 return true; // skip dependencies. 2809 case serialization::MK_PCH: 2810 Mod = &M; 2811 return true; // found it. 2812 case serialization::MK_Preamble: 2813 return false; // look in dependencies. 2814 case serialization::MK_MainFile: 2815 return false; // look in dependencies. 2816 } 2817 2818 return true; 2819 }); 2820 if (Mod) 2821 return Mod->File; 2822 2823 return nullptr; 2824 } 2825 2826 bool ASTUnit::isModuleFile() { 2827 return isMainFileAST() && ASTFileLangOpts.CompilingModule; 2828 } 2829 2830 void ASTUnit::PreambleData::countLines() const { 2831 NumLines = 0; 2832 if (empty()) 2833 return; 2834 2835 NumLines = std::count(Buffer.begin(), Buffer.end(), '\n'); 2836 2837 if (Buffer.back() != '\n') 2838 ++NumLines; 2839 } 2840 2841 #ifndef NDEBUG 2842 ASTUnit::ConcurrencyState::ConcurrencyState() { 2843 Mutex = new llvm::sys::MutexImpl(/*recursive=*/true); 2844 } 2845 2846 ASTUnit::ConcurrencyState::~ConcurrencyState() { 2847 delete static_cast<llvm::sys::MutexImpl *>(Mutex); 2848 } 2849 2850 void ASTUnit::ConcurrencyState::start() { 2851 bool acquired = static_cast<llvm::sys::MutexImpl *>(Mutex)->tryacquire(); 2852 assert(acquired && "Concurrent access to ASTUnit!"); 2853 } 2854 2855 void ASTUnit::ConcurrencyState::finish() { 2856 static_cast<llvm::sys::MutexImpl *>(Mutex)->release(); 2857 } 2858 2859 #else // NDEBUG 2860 2861 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = nullptr; } 2862 ASTUnit::ConcurrencyState::~ConcurrencyState() {} 2863 void ASTUnit::ConcurrencyState::start() {} 2864 void ASTUnit::ConcurrencyState::finish() {} 2865 2866 #endif // NDEBUG 2867