ASTUnit.cpp revision 875ab10245d3bf37252dd822aa1616bb0a391095
1//===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===// 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/ASTContext.h" 16#include "clang/AST/ASTConsumer.h" 17#include "clang/AST/DeclVisitor.h" 18#include "clang/AST/TypeOrdering.h" 19#include "clang/AST/StmtVisitor.h" 20#include "clang/Driver/Compilation.h" 21#include "clang/Driver/Driver.h" 22#include "clang/Driver/Job.h" 23#include "clang/Driver/Tool.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/Serialization/ASTReader.h" 29#include "clang/Serialization/ASTWriter.h" 30#include "clang/Lex/HeaderSearch.h" 31#include "clang/Lex/Preprocessor.h" 32#include "clang/Basic/TargetOptions.h" 33#include "clang/Basic/TargetInfo.h" 34#include "clang/Basic/Diagnostic.h" 35#include "llvm/ADT/StringSet.h" 36#include "llvm/Support/MemoryBuffer.h" 37#include "llvm/System/Host.h" 38#include "llvm/System/Path.h" 39#include "llvm/Support/raw_ostream.h" 40#include "llvm/Support/Timer.h" 41#include <cstdlib> 42#include <cstdio> 43#include <sys/stat.h> 44using namespace clang; 45 46/// \brief After failing to build a precompiled preamble (due to 47/// errors in the source that occurs in the preamble), the number of 48/// reparses during which we'll skip even trying to precompile the 49/// preamble. 50const unsigned DefaultPreambleRebuildInterval = 5; 51 52ASTUnit::ASTUnit(bool _MainFileIsAST) 53 : CaptureDiagnostics(false), MainFileIsAST(_MainFileIsAST), 54 CompleteTranslationUnit(true), ConcurrencyCheckValue(CheckUnlocked), 55 PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0), 56 ShouldCacheCodeCompletionResults(false), 57 NumTopLevelDeclsAtLastCompletionCache(0), 58 CacheCodeCompletionCoolDown(0), 59 UnsafeToFree(false) { 60} 61 62ASTUnit::~ASTUnit() { 63 ConcurrencyCheckValue = CheckLocked; 64 CleanTemporaryFiles(); 65 if (!PreambleFile.empty()) 66 llvm::sys::Path(PreambleFile).eraseFromDisk(); 67 68 // Free the buffers associated with remapped files. We are required to 69 // perform this operation here because we explicitly request that the 70 // compiler instance *not* free these buffers for each invocation of the 71 // parser. 72 if (Invocation.get()) { 73 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 74 for (PreprocessorOptions::remapped_file_buffer_iterator 75 FB = PPOpts.remapped_file_buffer_begin(), 76 FBEnd = PPOpts.remapped_file_buffer_end(); 77 FB != FBEnd; 78 ++FB) 79 delete FB->second; 80 } 81 82 delete SavedMainFileBuffer; 83 delete PreambleBuffer; 84 85 ClearCachedCompletionResults(); 86 87 for (unsigned I = 0, N = Timers.size(); I != N; ++I) 88 delete Timers[I]; 89} 90 91void ASTUnit::CleanTemporaryFiles() { 92 for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) 93 TemporaryFiles[I].eraseFromDisk(); 94 TemporaryFiles.clear(); 95} 96 97/// \brief Determine the set of code-completion contexts in which this 98/// declaration should be shown. 99static unsigned getDeclShowContexts(NamedDecl *ND, 100 const LangOptions &LangOpts, 101 bool &IsNestedNameSpecifier) { 102 IsNestedNameSpecifier = false; 103 104 if (isa<UsingShadowDecl>(ND)) 105 ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl()); 106 if (!ND) 107 return 0; 108 109 unsigned Contexts = 0; 110 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) || 111 isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) { 112 // Types can appear in these contexts. 113 if (LangOpts.CPlusPlus || !isa<TagDecl>(ND)) 114 Contexts |= (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 115 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 116 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1)) 117 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 118 | (1 << (CodeCompletionContext::CCC_Type - 1)); 119 120 // In C++, types can appear in expressions contexts (for functional casts). 121 if (LangOpts.CPlusPlus) 122 Contexts |= (1 << (CodeCompletionContext::CCC_Expression - 1)); 123 124 // In Objective-C, message sends can send interfaces. In Objective-C++, 125 // all types are available due to functional casts. 126 if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND)) 127 Contexts |= (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)); 128 129 // Deal with tag names. 130 if (isa<EnumDecl>(ND)) { 131 Contexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1)); 132 133 // Part of the nested-name-specifier in C++0x. 134 if (LangOpts.CPlusPlus0x) 135 IsNestedNameSpecifier = true; 136 } else if (RecordDecl *Record = dyn_cast<RecordDecl>(ND)) { 137 if (Record->isUnion()) 138 Contexts |= (1 << (CodeCompletionContext::CCC_UnionTag - 1)); 139 else 140 Contexts |= (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1)); 141 142 if (LangOpts.CPlusPlus) 143 IsNestedNameSpecifier = true; 144 } else if (isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) 145 IsNestedNameSpecifier = true; 146 } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 147 // Values can appear in these contexts. 148 Contexts = (1 << (CodeCompletionContext::CCC_Statement - 1)) 149 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 150 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)); 151 } else if (isa<ObjCProtocolDecl>(ND)) { 152 Contexts = (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1)); 153 } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) { 154 Contexts = (1 << (CodeCompletionContext::CCC_Namespace - 1)); 155 156 // Part of the nested-name-specifier. 157 IsNestedNameSpecifier = true; 158 } 159 160 return Contexts; 161} 162 163void ASTUnit::CacheCodeCompletionResults() { 164 if (!TheSema) 165 return; 166 167 llvm::Timer *CachingTimer = 0; 168 if (TimerGroup.get()) { 169 CachingTimer = new llvm::Timer("Cache global code completions", 170 *TimerGroup); 171 CachingTimer->startTimer(); 172 Timers.push_back(CachingTimer); 173 } 174 175 // Clear out the previous results. 176 ClearCachedCompletionResults(); 177 178 // Gather the set of global code completions. 179 typedef CodeCompleteConsumer::Result Result; 180 llvm::SmallVector<Result, 8> Results; 181 TheSema->GatherGlobalCodeCompletions(Results); 182 183 // Translate global code completions into cached completions. 184 llvm::DenseMap<CanQualType, unsigned> CompletionTypes; 185 186 for (unsigned I = 0, N = Results.size(); I != N; ++I) { 187 switch (Results[I].Kind) { 188 case Result::RK_Declaration: { 189 bool IsNestedNameSpecifier = false; 190 CachedCodeCompletionResult CachedResult; 191 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema); 192 CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration, 193 Ctx->getLangOptions(), 194 IsNestedNameSpecifier); 195 CachedResult.Priority = Results[I].Priority; 196 CachedResult.Kind = Results[I].CursorKind; 197 198 // Keep track of the type of this completion in an ASTContext-agnostic 199 // way. 200 QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration); 201 if (UsageType.isNull()) { 202 CachedResult.TypeClass = STC_Void; 203 CachedResult.Type = 0; 204 } else { 205 CanQualType CanUsageType 206 = Ctx->getCanonicalType(UsageType.getUnqualifiedType()); 207 CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType); 208 209 // Determine whether we have already seen this type. If so, we save 210 // ourselves the work of formatting the type string by using the 211 // temporary, CanQualType-based hash table to find the associated value. 212 unsigned &TypeValue = CompletionTypes[CanUsageType]; 213 if (TypeValue == 0) { 214 TypeValue = CompletionTypes.size(); 215 CachedCompletionTypes[QualType(CanUsageType).getAsString()] 216 = TypeValue; 217 } 218 219 CachedResult.Type = TypeValue; 220 } 221 222 CachedCompletionResults.push_back(CachedResult); 223 224 /// Handle nested-name-specifiers in C++. 225 if (TheSema->Context.getLangOptions().CPlusPlus && 226 IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) { 227 // The contexts in which a nested-name-specifier can appear in C++. 228 unsigned NNSContexts 229 = (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 230 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 231 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1)) 232 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 233 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 234 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)) 235 | (1 << (CodeCompletionContext::CCC_EnumTag - 1)) 236 | (1 << (CodeCompletionContext::CCC_UnionTag - 1)) 237 | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1)) 238 | (1 << (CodeCompletionContext::CCC_Type - 1)); 239 240 if (isa<NamespaceDecl>(Results[I].Declaration) || 241 isa<NamespaceAliasDecl>(Results[I].Declaration)) 242 NNSContexts |= (1 << (CodeCompletionContext::CCC_Namespace - 1)); 243 244 if (unsigned RemainingContexts 245 = NNSContexts & ~CachedResult.ShowInContexts) { 246 // If there any contexts where this completion can be a 247 // nested-name-specifier but isn't already an option, create a 248 // nested-name-specifier completion. 249 Results[I].StartsNestedNameSpecifier = true; 250 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema); 251 CachedResult.ShowInContexts = RemainingContexts; 252 CachedResult.Priority = CCP_NestedNameSpecifier; 253 CachedResult.TypeClass = STC_Void; 254 CachedResult.Type = 0; 255 CachedCompletionResults.push_back(CachedResult); 256 } 257 } 258 break; 259 } 260 261 case Result::RK_Keyword: 262 case Result::RK_Pattern: 263 // Ignore keywords and patterns; we don't care, since they are so 264 // easily regenerated. 265 break; 266 267 case Result::RK_Macro: { 268 CachedCodeCompletionResult CachedResult; 269 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema); 270 CachedResult.ShowInContexts 271 = (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 272 | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1)) 273 | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1)) 274 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 275 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1)) 276 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 277 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 278 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)); 279 CachedResult.Priority = Results[I].Priority; 280 CachedResult.Kind = Results[I].CursorKind; 281 CachedResult.TypeClass = STC_Void; 282 CachedResult.Type = 0; 283 CachedCompletionResults.push_back(CachedResult); 284 break; 285 } 286 } 287 Results[I].Destroy(); 288 } 289 290 if (CachingTimer) 291 CachingTimer->stopTimer(); 292 293 // Make a note of the state when we performed this caching. 294 NumTopLevelDeclsAtLastCompletionCache = top_level_size(); 295 CacheCodeCompletionCoolDown = 15; 296} 297 298void ASTUnit::ClearCachedCompletionResults() { 299 for (unsigned I = 0, N = CachedCompletionResults.size(); I != N; ++I) 300 delete CachedCompletionResults[I].Completion; 301 CachedCompletionResults.clear(); 302 CachedCompletionTypes.clear(); 303} 304 305namespace { 306 307/// \brief Gathers information from ASTReader that will be used to initialize 308/// a Preprocessor. 309class ASTInfoCollector : public ASTReaderListener { 310 LangOptions &LangOpt; 311 HeaderSearch &HSI; 312 std::string &TargetTriple; 313 std::string &Predefines; 314 unsigned &Counter; 315 316 unsigned NumHeaderInfos; 317 318public: 319 ASTInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI, 320 std::string &TargetTriple, std::string &Predefines, 321 unsigned &Counter) 322 : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple), 323 Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {} 324 325 virtual bool ReadLanguageOptions(const LangOptions &LangOpts) { 326 LangOpt = LangOpts; 327 return false; 328 } 329 330 virtual bool ReadTargetTriple(llvm::StringRef Triple) { 331 TargetTriple = Triple; 332 return false; 333 } 334 335 virtual bool ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 336 llvm::StringRef OriginalFileName, 337 std::string &SuggestedPredefines) { 338 Predefines = Buffers[0].Data; 339 for (unsigned I = 1, N = Buffers.size(); I != N; ++I) { 340 Predefines += Buffers[I].Data; 341 } 342 return false; 343 } 344 345 virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) { 346 HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++); 347 } 348 349 virtual void ReadCounter(unsigned Value) { 350 Counter = Value; 351 } 352}; 353 354class StoredDiagnosticClient : public DiagnosticClient { 355 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags; 356 357public: 358 explicit StoredDiagnosticClient( 359 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags) 360 : StoredDiags(StoredDiags) { } 361 362 virtual void HandleDiagnostic(Diagnostic::Level Level, 363 const DiagnosticInfo &Info); 364}; 365 366/// \brief RAII object that optionally captures diagnostics, if 367/// there is no diagnostic client to capture them already. 368class CaptureDroppedDiagnostics { 369 Diagnostic &Diags; 370 StoredDiagnosticClient Client; 371 DiagnosticClient *PreviousClient; 372 373public: 374 CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags, 375 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags) 376 : Diags(Diags), Client(StoredDiags), PreviousClient(0) 377 { 378 if (RequestCapture || Diags.getClient() == 0) { 379 PreviousClient = Diags.takeClient(); 380 Diags.setClient(&Client); 381 } 382 } 383 384 ~CaptureDroppedDiagnostics() { 385 if (Diags.getClient() == &Client) { 386 Diags.takeClient(); 387 Diags.setClient(PreviousClient); 388 } 389 } 390}; 391 392} // anonymous namespace 393 394void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level, 395 const DiagnosticInfo &Info) { 396 StoredDiags.push_back(StoredDiagnostic(Level, Info)); 397} 398 399const std::string &ASTUnit::getOriginalSourceFileName() { 400 return OriginalSourceFile; 401} 402 403const std::string &ASTUnit::getASTFileName() { 404 assert(isMainFileAST() && "Not an ASTUnit from an AST file!"); 405 return static_cast<ASTReader *>(Ctx->getExternalSource())->getFileName(); 406} 407 408ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename, 409 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 410 bool OnlyLocalDecls, 411 RemappedFile *RemappedFiles, 412 unsigned NumRemappedFiles, 413 bool CaptureDiagnostics) { 414 llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true)); 415 416 if (!Diags.getPtr()) { 417 // No diagnostics engine was provided, so create our own diagnostics object 418 // with the default options. 419 DiagnosticOptions DiagOpts; 420 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0); 421 } 422 423 AST->CaptureDiagnostics = CaptureDiagnostics; 424 AST->OnlyLocalDecls = OnlyLocalDecls; 425 AST->Diagnostics = Diags; 426 AST->FileMgr.reset(new FileManager); 427 AST->SourceMgr.reset(new SourceManager(AST->getDiagnostics())); 428 AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager())); 429 430 // If requested, capture diagnostics in the ASTUnit. 431 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, AST->getDiagnostics(), 432 AST->StoredDiagnostics); 433 434 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 435 // Create the file entry for the file that we're mapping from. 436 const FileEntry *FromFile 437 = AST->getFileManager().getVirtualFile(RemappedFiles[I].first, 438 RemappedFiles[I].second->getBufferSize(), 439 0); 440 if (!FromFile) { 441 AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file) 442 << RemappedFiles[I].first; 443 delete RemappedFiles[I].second; 444 continue; 445 } 446 447 // Override the contents of the "from" file with the contents of 448 // the "to" file. 449 AST->getSourceManager().overrideFileContents(FromFile, 450 RemappedFiles[I].second); 451 } 452 453 // Gather Info for preprocessor construction later on. 454 455 LangOptions LangInfo; 456 HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); 457 std::string TargetTriple; 458 std::string Predefines; 459 unsigned Counter; 460 461 llvm::OwningPtr<ASTReader> Reader; 462 463 Reader.reset(new ASTReader(AST->getSourceManager(), AST->getFileManager(), 464 AST->getDiagnostics())); 465 Reader->setListener(new ASTInfoCollector(LangInfo, HeaderInfo, TargetTriple, 466 Predefines, Counter)); 467 468 switch (Reader->ReadAST(Filename)) { 469 case ASTReader::Success: 470 break; 471 472 case ASTReader::Failure: 473 case ASTReader::IgnorePCH: 474 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); 475 return NULL; 476 } 477 478 AST->OriginalSourceFile = Reader->getOriginalSourceFile(); 479 480 // AST file loaded successfully. Now create the preprocessor. 481 482 // Get information about the target being compiled for. 483 // 484 // FIXME: This is broken, we should store the TargetOptions in the AST file. 485 TargetOptions TargetOpts; 486 TargetOpts.ABI = ""; 487 TargetOpts.CXXABI = ""; 488 TargetOpts.CPU = ""; 489 TargetOpts.Features.clear(); 490 TargetOpts.Triple = TargetTriple; 491 AST->Target.reset(TargetInfo::CreateTargetInfo(AST->getDiagnostics(), 492 TargetOpts)); 493 AST->PP.reset(new Preprocessor(AST->getDiagnostics(), LangInfo, 494 *AST->Target.get(), 495 AST->getSourceManager(), HeaderInfo)); 496 Preprocessor &PP = *AST->PP.get(); 497 498 PP.setPredefines(Reader->getSuggestedPredefines()); 499 PP.setCounterValue(Counter); 500 Reader->setPreprocessor(PP); 501 502 // Create and initialize the ASTContext. 503 504 AST->Ctx.reset(new ASTContext(LangInfo, 505 AST->getSourceManager(), 506 *AST->Target.get(), 507 PP.getIdentifierTable(), 508 PP.getSelectorTable(), 509 PP.getBuiltinInfo(), 510 /* size_reserve = */0)); 511 ASTContext &Context = *AST->Ctx.get(); 512 513 Reader->InitializeContext(Context); 514 515 // Attach the AST reader to the AST context as an external AST 516 // source, so that declarations will be deserialized from the 517 // AST file as needed. 518 ASTReader *ReaderPtr = Reader.get(); 519 llvm::OwningPtr<ExternalASTSource> Source(Reader.take()); 520 Context.setExternalSource(Source); 521 522 // Create an AST consumer, even though it isn't used. 523 AST->Consumer.reset(new ASTConsumer); 524 525 // Create a semantic analysis object and tell the AST reader about it. 526 AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); 527 AST->TheSema->Initialize(); 528 ReaderPtr->InitializeSema(*AST->TheSema); 529 530 return AST.take(); 531} 532 533namespace { 534 535class TopLevelDeclTrackerConsumer : public ASTConsumer { 536 ASTUnit &Unit; 537 538public: 539 TopLevelDeclTrackerConsumer(ASTUnit &_Unit) : Unit(_Unit) {} 540 541 void HandleTopLevelDecl(DeclGroupRef D) { 542 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { 543 Decl *D = *it; 544 // FIXME: Currently ObjC method declarations are incorrectly being 545 // reported as top-level declarations, even though their DeclContext 546 // is the containing ObjC @interface/@implementation. This is a 547 // fundamental problem in the parser right now. 548 if (isa<ObjCMethodDecl>(D)) 549 continue; 550 Unit.addTopLevelDecl(D); 551 } 552 } 553 554 // We're not interested in "interesting" decls. 555 void HandleInterestingDecl(DeclGroupRef) {} 556}; 557 558class TopLevelDeclTrackerAction : public ASTFrontendAction { 559public: 560 ASTUnit &Unit; 561 562 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, 563 llvm::StringRef InFile) { 564 return new TopLevelDeclTrackerConsumer(Unit); 565 } 566 567public: 568 TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} 569 570 virtual bool hasCodeCompletionSupport() const { return false; } 571 virtual bool usesCompleteTranslationUnit() { 572 return Unit.isCompleteTranslationUnit(); 573 } 574}; 575 576class PrecompilePreambleConsumer : public PCHGenerator { 577 ASTUnit &Unit; 578 std::vector<Decl *> TopLevelDecls; 579 580public: 581 PrecompilePreambleConsumer(ASTUnit &Unit, 582 const Preprocessor &PP, bool Chaining, 583 const char *isysroot, llvm::raw_ostream *Out) 584 : PCHGenerator(PP, Chaining, isysroot, Out), Unit(Unit) { } 585 586 virtual void HandleTopLevelDecl(DeclGroupRef D) { 587 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { 588 Decl *D = *it; 589 // FIXME: Currently ObjC method declarations are incorrectly being 590 // reported as top-level declarations, even though their DeclContext 591 // is the containing ObjC @interface/@implementation. This is a 592 // fundamental problem in the parser right now. 593 if (isa<ObjCMethodDecl>(D)) 594 continue; 595 TopLevelDecls.push_back(D); 596 } 597 } 598 599 virtual void HandleTranslationUnit(ASTContext &Ctx) { 600 PCHGenerator::HandleTranslationUnit(Ctx); 601 if (!Unit.getDiagnostics().hasErrorOccurred()) { 602 // Translate the top-level declarations we captured during 603 // parsing into declaration IDs in the precompiled 604 // preamble. This will allow us to deserialize those top-level 605 // declarations when requested. 606 for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I) 607 Unit.addTopLevelDeclFromPreamble( 608 getWriter().getDeclID(TopLevelDecls[I])); 609 } 610 } 611}; 612 613class PrecompilePreambleAction : public ASTFrontendAction { 614 ASTUnit &Unit; 615 616public: 617 explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit) {} 618 619 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, 620 llvm::StringRef InFile) { 621 std::string Sysroot; 622 llvm::raw_ostream *OS = 0; 623 bool Chaining; 624 if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, 625 OS, Chaining)) 626 return 0; 627 628 const char *isysroot = CI.getFrontendOpts().RelocatablePCH ? 629 Sysroot.c_str() : 0; 630 return new PrecompilePreambleConsumer(Unit, CI.getPreprocessor(), Chaining, 631 isysroot, OS); 632 } 633 634 virtual bool hasCodeCompletionSupport() const { return false; } 635 virtual bool hasASTFileSupport() const { return false; } 636 virtual bool usesCompleteTranslationUnit() { return false; } 637}; 638 639} 640 641/// Parse the source file into a translation unit using the given compiler 642/// invocation, replacing the current translation unit. 643/// 644/// \returns True if a failure occurred that causes the ASTUnit not to 645/// contain any translation-unit information, false otherwise. 646bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) { 647 delete SavedMainFileBuffer; 648 SavedMainFileBuffer = 0; 649 650 if (!Invocation.get()) { 651 delete OverrideMainBuffer; 652 return true; 653 } 654 655 // Create the compiler instance to use for building the AST. 656 CompilerInstance Clang; 657 Clang.setInvocation(Invocation.take()); 658 OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second; 659 660 // Set up diagnostics, capturing any diagnostics that would 661 // otherwise be dropped. 662 Clang.setDiagnostics(&getDiagnostics()); 663 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, 664 getDiagnostics(), 665 StoredDiagnostics); 666 667 // Create the target instance. 668 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(), 669 Clang.getTargetOpts())); 670 if (!Clang.hasTarget()) { 671 delete OverrideMainBuffer; 672 return true; 673 } 674 675 // Inform the target of the language options. 676 // 677 // FIXME: We shouldn't need to do this, the target should be immutable once 678 // created. This complexity should be lifted elsewhere. 679 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts()); 680 681 assert(Clang.getFrontendOpts().Inputs.size() == 1 && 682 "Invocation must have exactly one source file!"); 683 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST && 684 "FIXME: AST inputs not yet supported here!"); 685 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 686 "IR inputs not support here!"); 687 688 // Configure the various subsystems. 689 // FIXME: Should we retain the previous file manager? 690 FileMgr.reset(new FileManager); 691 SourceMgr.reset(new SourceManager(getDiagnostics())); 692 TheSema.reset(); 693 Ctx.reset(); 694 PP.reset(); 695 696 // Clear out old caches and data. 697 TopLevelDecls.clear(); 698 CleanTemporaryFiles(); 699 PreprocessedEntitiesByFile.clear(); 700 701 if (!OverrideMainBuffer) { 702 StoredDiagnostics.clear(); 703 TopLevelDeclsInPreamble.clear(); 704 } 705 706 // Create a file manager object to provide access to and cache the filesystem. 707 Clang.setFileManager(&getFileManager()); 708 709 // Create the source manager. 710 Clang.setSourceManager(&getSourceManager()); 711 712 // If the main file has been overridden due to the use of a preamble, 713 // make that override happen and introduce the preamble. 714 PreprocessorOptions &PreprocessorOpts = Clang.getPreprocessorOpts(); 715 std::string PriorImplicitPCHInclude; 716 if (OverrideMainBuffer) { 717 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); 718 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); 719 PreprocessorOpts.PrecompiledPreambleBytes.second 720 = PreambleEndsAtStartOfLine; 721 PriorImplicitPCHInclude = PreprocessorOpts.ImplicitPCHInclude; 722 PreprocessorOpts.ImplicitPCHInclude = PreambleFile; 723 PreprocessorOpts.DisablePCHValidation = true; 724 725 // Keep track of the override buffer; 726 SavedMainFileBuffer = OverrideMainBuffer; 727 728 // The stored diagnostic has the old source manager in it; update 729 // the locations to refer into the new source manager. Since we've 730 // been careful to make sure that the source manager's state 731 // before and after are identical, so that we can reuse the source 732 // location itself. 733 for (unsigned I = 0, N = StoredDiagnostics.size(); I != N; ++I) { 734 FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), 735 getSourceManager()); 736 StoredDiagnostics[I].setLocation(Loc); 737 } 738 } else { 739 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 740 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 741 } 742 743 llvm::OwningPtr<TopLevelDeclTrackerAction> Act; 744 Act.reset(new TopLevelDeclTrackerAction(*this)); 745 if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second, 746 Clang.getFrontendOpts().Inputs[0].first)) 747 goto error; 748 749 Act->Execute(); 750 751 // Steal the created target, context, and preprocessor, and take back the 752 // source and file managers. 753 TheSema.reset(Clang.takeSema()); 754 Consumer.reset(Clang.takeASTConsumer()); 755 Ctx.reset(Clang.takeASTContext()); 756 PP.reset(Clang.takePreprocessor()); 757 Clang.takeSourceManager(); 758 Clang.takeFileManager(); 759 Target.reset(Clang.takeTarget()); 760 761 Act->EndSourceFile(); 762 763 // Remove the overridden buffer we used for the preamble. 764 if (OverrideMainBuffer) { 765 PreprocessorOpts.eraseRemappedFile( 766 PreprocessorOpts.remapped_file_buffer_end() - 1); 767 PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude; 768 } 769 770 Invocation.reset(Clang.takeInvocation()); 771 772 // If we were asked to cache code-completion results and don't have any 773 // results yet, do so now. 774 if (ShouldCacheCodeCompletionResults && CachedCompletionResults.empty()) 775 CacheCodeCompletionResults(); 776 777 return false; 778 779error: 780 // Remove the overridden buffer we used for the preamble. 781 if (OverrideMainBuffer) { 782 PreprocessorOpts.eraseRemappedFile( 783 PreprocessorOpts.remapped_file_buffer_end() - 1); 784 PreprocessorOpts.DisablePCHValidation = true; 785 PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude; 786 delete OverrideMainBuffer; 787 } 788 789 Clang.takeSourceManager(); 790 Clang.takeFileManager(); 791 Invocation.reset(Clang.takeInvocation()); 792 return true; 793} 794 795/// \brief Simple function to retrieve a path for a preamble precompiled header. 796static std::string GetPreamblePCHPath() { 797 // FIXME: This is lame; sys::Path should provide this function (in particular, 798 // it should know how to find the temporary files dir). 799 // FIXME: This is really lame. I copied this code from the Driver! 800 std::string Error; 801 const char *TmpDir = ::getenv("TMPDIR"); 802 if (!TmpDir) 803 TmpDir = ::getenv("TEMP"); 804 if (!TmpDir) 805 TmpDir = ::getenv("TMP"); 806 if (!TmpDir) 807 TmpDir = "/tmp"; 808 llvm::sys::Path P(TmpDir); 809 P.appendComponent("preamble"); 810 P.appendSuffix("pch"); 811 if (P.createTemporaryFileOnDisk()) 812 return std::string(); 813 814 return P.str(); 815} 816 817/// \brief Compute the preamble for the main file, providing the source buffer 818/// that corresponds to the main file along with a pair (bytes, start-of-line) 819/// that describes the preamble. 820std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > 821ASTUnit::ComputePreamble(CompilerInvocation &Invocation, 822 unsigned MaxLines, bool &CreatedBuffer) { 823 FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); 824 PreprocessorOptions &PreprocessorOpts 825 = Invocation.getPreprocessorOpts(); 826 CreatedBuffer = false; 827 828 // Try to determine if the main file has been remapped, either from the 829 // command line (to another file) or directly through the compiler invocation 830 // (to a memory buffer). 831 llvm::MemoryBuffer *Buffer = 0; 832 llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second); 833 if (const llvm::sys::FileStatus *MainFileStatus = MainFilePath.getFileStatus()) { 834 // Check whether there is a file-file remapping of the main file 835 for (PreprocessorOptions::remapped_file_iterator 836 M = PreprocessorOpts.remapped_file_begin(), 837 E = PreprocessorOpts.remapped_file_end(); 838 M != E; 839 ++M) { 840 llvm::sys::PathWithStatus MPath(M->first); 841 if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) { 842 if (MainFileStatus->uniqueID == MStatus->uniqueID) { 843 // We found a remapping. Try to load the resulting, remapped source. 844 if (CreatedBuffer) { 845 delete Buffer; 846 CreatedBuffer = false; 847 } 848 849 Buffer = llvm::MemoryBuffer::getFile(M->second); 850 if (!Buffer) 851 return std::make_pair((llvm::MemoryBuffer*)0, 852 std::make_pair(0, true)); 853 CreatedBuffer = true; 854 855 // Remove this remapping. We've captured the buffer already. 856 M = PreprocessorOpts.eraseRemappedFile(M); 857 E = PreprocessorOpts.remapped_file_end(); 858 if (M == E) 859 break; 860 } 861 } 862 } 863 864 // Check whether there is a file-buffer remapping. It supercedes the 865 // file-file remapping. 866 for (PreprocessorOptions::remapped_file_buffer_iterator 867 M = PreprocessorOpts.remapped_file_buffer_begin(), 868 E = PreprocessorOpts.remapped_file_buffer_end(); 869 M != E; 870 ++M) { 871 llvm::sys::PathWithStatus MPath(M->first); 872 if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) { 873 if (MainFileStatus->uniqueID == MStatus->uniqueID) { 874 // We found a remapping. 875 if (CreatedBuffer) { 876 delete Buffer; 877 CreatedBuffer = false; 878 } 879 880 Buffer = const_cast<llvm::MemoryBuffer *>(M->second); 881 882 // Remove this remapping. We've captured the buffer already. 883 M = PreprocessorOpts.eraseRemappedFile(M); 884 E = PreprocessorOpts.remapped_file_buffer_end(); 885 if (M == E) 886 break; 887 } 888 } 889 } 890 } 891 892 // If the main source file was not remapped, load it now. 893 if (!Buffer) { 894 Buffer = llvm::MemoryBuffer::getFile(FrontendOpts.Inputs[0].second); 895 if (!Buffer) 896 return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true)); 897 898 CreatedBuffer = true; 899 } 900 901 return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, MaxLines)); 902} 903 904static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old, 905 bool DeleteOld, 906 unsigned NewSize, 907 llvm::StringRef NewName) { 908 llvm::MemoryBuffer *Result 909 = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName); 910 memcpy(const_cast<char*>(Result->getBufferStart()), 911 Old->getBufferStart(), Old->getBufferSize()); 912 memset(const_cast<char*>(Result->getBufferStart()) + Old->getBufferSize(), 913 ' ', NewSize - Old->getBufferSize() - 1); 914 const_cast<char*>(Result->getBufferEnd())[-1] = '\n'; 915 916 if (DeleteOld) 917 delete Old; 918 919 return Result; 920} 921 922/// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing 923/// the source file. 924/// 925/// This routine will compute the preamble of the main source file. If a 926/// non-trivial preamble is found, it will precompile that preamble into a 927/// precompiled header so that the precompiled preamble can be used to reduce 928/// reparsing time. If a precompiled preamble has already been constructed, 929/// this routine will determine if it is still valid and, if so, avoid 930/// rebuilding the precompiled preamble. 931/// 932/// \param AllowRebuild When true (the default), this routine is 933/// allowed to rebuild the precompiled preamble if it is found to be 934/// out-of-date. 935/// 936/// \param MaxLines When non-zero, the maximum number of lines that 937/// can occur within the preamble. 938/// 939/// \returns If the precompiled preamble can be used, returns a newly-allocated 940/// buffer that should be used in place of the main file when doing so. 941/// Otherwise, returns a NULL pointer. 942llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( 943 CompilerInvocation PreambleInvocation, 944 bool AllowRebuild, 945 unsigned MaxLines) { 946 FrontendOptions &FrontendOpts = PreambleInvocation.getFrontendOpts(); 947 PreprocessorOptions &PreprocessorOpts 948 = PreambleInvocation.getPreprocessorOpts(); 949 950 bool CreatedPreambleBuffer = false; 951 std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > NewPreamble 952 = ComputePreamble(PreambleInvocation, MaxLines, CreatedPreambleBuffer); 953 954 if (!NewPreamble.second.first) { 955 // We couldn't find a preamble in the main source. Clear out the current 956 // preamble, if we have one. It's obviously no good any more. 957 Preamble.clear(); 958 if (!PreambleFile.empty()) { 959 llvm::sys::Path(PreambleFile).eraseFromDisk(); 960 PreambleFile.clear(); 961 } 962 if (CreatedPreambleBuffer) 963 delete NewPreamble.first; 964 965 // The next time we actually see a preamble, precompile it. 966 PreambleRebuildCounter = 1; 967 return 0; 968 } 969 970 if (!Preamble.empty()) { 971 // We've previously computed a preamble. Check whether we have the same 972 // preamble now that we did before, and that there's enough space in 973 // the main-file buffer within the precompiled preamble to fit the 974 // new main file. 975 if (Preamble.size() == NewPreamble.second.first && 976 PreambleEndsAtStartOfLine == NewPreamble.second.second && 977 NewPreamble.first->getBufferSize() < PreambleReservedSize-2 && 978 memcmp(&Preamble[0], NewPreamble.first->getBufferStart(), 979 NewPreamble.second.first) == 0) { 980 // The preamble has not changed. We may be able to re-use the precompiled 981 // preamble. 982 983 // Check that none of the files used by the preamble have changed. 984 bool AnyFileChanged = false; 985 986 // First, make a record of those files that have been overridden via 987 // remapping or unsaved_files. 988 llvm::StringMap<std::pair<off_t, time_t> > OverriddenFiles; 989 for (PreprocessorOptions::remapped_file_iterator 990 R = PreprocessorOpts.remapped_file_begin(), 991 REnd = PreprocessorOpts.remapped_file_end(); 992 !AnyFileChanged && R != REnd; 993 ++R) { 994 struct stat StatBuf; 995 if (stat(R->second.c_str(), &StatBuf)) { 996 // If we can't stat the file we're remapping to, assume that something 997 // horrible happened. 998 AnyFileChanged = true; 999 break; 1000 } 1001 1002 OverriddenFiles[R->first] = std::make_pair(StatBuf.st_size, 1003 StatBuf.st_mtime); 1004 } 1005 for (PreprocessorOptions::remapped_file_buffer_iterator 1006 R = PreprocessorOpts.remapped_file_buffer_begin(), 1007 REnd = PreprocessorOpts.remapped_file_buffer_end(); 1008 !AnyFileChanged && R != REnd; 1009 ++R) { 1010 // FIXME: Should we actually compare the contents of file->buffer 1011 // remappings? 1012 OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(), 1013 0); 1014 } 1015 1016 // Check whether anything has changed. 1017 for (llvm::StringMap<std::pair<off_t, time_t> >::iterator 1018 F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end(); 1019 !AnyFileChanged && F != FEnd; 1020 ++F) { 1021 llvm::StringMap<std::pair<off_t, time_t> >::iterator Overridden 1022 = OverriddenFiles.find(F->first()); 1023 if (Overridden != OverriddenFiles.end()) { 1024 // This file was remapped; check whether the newly-mapped file 1025 // matches up with the previous mapping. 1026 if (Overridden->second != F->second) 1027 AnyFileChanged = true; 1028 continue; 1029 } 1030 1031 // The file was not remapped; check whether it has changed on disk. 1032 struct stat StatBuf; 1033 if (stat(F->first(), &StatBuf)) { 1034 // If we can't stat the file, assume that something horrible happened. 1035 AnyFileChanged = true; 1036 } else if (StatBuf.st_size != F->second.first || 1037 StatBuf.st_mtime != F->second.second) 1038 AnyFileChanged = true; 1039 } 1040 1041 if (!AnyFileChanged) { 1042 // Okay! We can re-use the precompiled preamble. 1043 1044 // Set the state of the diagnostic object to mimic its state 1045 // after parsing the preamble. 1046 getDiagnostics().Reset(); 1047 getDiagnostics().setNumWarnings(NumWarningsInPreamble); 1048 if (StoredDiagnostics.size() > NumStoredDiagnosticsInPreamble) 1049 StoredDiagnostics.erase( 1050 StoredDiagnostics.begin() + NumStoredDiagnosticsInPreamble, 1051 StoredDiagnostics.end()); 1052 1053 // Create a version of the main file buffer that is padded to 1054 // buffer size we reserved when creating the preamble. 1055 return CreatePaddedMainFileBuffer(NewPreamble.first, 1056 CreatedPreambleBuffer, 1057 PreambleReservedSize, 1058 FrontendOpts.Inputs[0].second); 1059 } 1060 } 1061 1062 // If we aren't allowed to rebuild the precompiled preamble, just 1063 // return now. 1064 if (!AllowRebuild) 1065 return 0; 1066 1067 // We can't reuse the previously-computed preamble. Build a new one. 1068 Preamble.clear(); 1069 llvm::sys::Path(PreambleFile).eraseFromDisk(); 1070 PreambleRebuildCounter = 1; 1071 } else if (!AllowRebuild) { 1072 // We aren't allowed to rebuild the precompiled preamble; just 1073 // return now. 1074 return 0; 1075 } 1076 1077 // If the preamble rebuild counter > 1, it's because we previously 1078 // failed to build a preamble and we're not yet ready to try 1079 // again. Decrement the counter and return a failure. 1080 if (PreambleRebuildCounter > 1) { 1081 --PreambleRebuildCounter; 1082 return 0; 1083 } 1084 1085 // We did not previously compute a preamble, or it can't be reused anyway. 1086 llvm::Timer *PreambleTimer = 0; 1087 if (TimerGroup.get()) { 1088 PreambleTimer = new llvm::Timer("Precompiling preamble", *TimerGroup); 1089 PreambleTimer->startTimer(); 1090 Timers.push_back(PreambleTimer); 1091 } 1092 1093 // Create a new buffer that stores the preamble. The buffer also contains 1094 // extra space for the original contents of the file (which will be present 1095 // when we actually parse the file) along with more room in case the file 1096 // grows. 1097 PreambleReservedSize = NewPreamble.first->getBufferSize(); 1098 if (PreambleReservedSize < 4096) 1099 PreambleReservedSize = 8191; 1100 else 1101 PreambleReservedSize *= 2; 1102 1103 // Save the preamble text for later; we'll need to compare against it for 1104 // subsequent reparses. 1105 Preamble.assign(NewPreamble.first->getBufferStart(), 1106 NewPreamble.first->getBufferStart() 1107 + NewPreamble.second.first); 1108 PreambleEndsAtStartOfLine = NewPreamble.second.second; 1109 1110 delete PreambleBuffer; 1111 PreambleBuffer 1112 = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize, 1113 FrontendOpts.Inputs[0].second); 1114 memcpy(const_cast<char*>(PreambleBuffer->getBufferStart()), 1115 NewPreamble.first->getBufferStart(), Preamble.size()); 1116 memset(const_cast<char*>(PreambleBuffer->getBufferStart()) + Preamble.size(), 1117 ' ', PreambleReservedSize - Preamble.size() - 1); 1118 const_cast<char*>(PreambleBuffer->getBufferEnd())[-1] = '\n'; 1119 1120 // Remap the main source file to the preamble buffer. 1121 llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second); 1122 PreprocessorOpts.addRemappedFile(MainFilePath.str(), PreambleBuffer); 1123 1124 // Tell the compiler invocation to generate a temporary precompiled header. 1125 FrontendOpts.ProgramAction = frontend::GeneratePCH; 1126 // FIXME: Set ChainedPCH unconditionally, once it is ready. 1127 if (::getenv("LIBCLANG_CHAINING")) 1128 FrontendOpts.ChainedPCH = true; 1129 // FIXME: Generate the precompiled header into memory? 1130 FrontendOpts.OutputFile = GetPreamblePCHPath(); 1131 1132 // Create the compiler instance to use for building the precompiled preamble. 1133 CompilerInstance Clang; 1134 Clang.setInvocation(&PreambleInvocation); 1135 OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second; 1136 1137 // Set up diagnostics, capturing all of the diagnostics produced. 1138 Clang.setDiagnostics(&getDiagnostics()); 1139 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, 1140 getDiagnostics(), 1141 StoredDiagnostics); 1142 1143 // Create the target instance. 1144 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(), 1145 Clang.getTargetOpts())); 1146 if (!Clang.hasTarget()) { 1147 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk(); 1148 Preamble.clear(); 1149 if (CreatedPreambleBuffer) 1150 delete NewPreamble.first; 1151 if (PreambleTimer) 1152 PreambleTimer->stopTimer(); 1153 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1154 PreprocessorOpts.eraseRemappedFile( 1155 PreprocessorOpts.remapped_file_buffer_end() - 1); 1156 return 0; 1157 } 1158 1159 // Inform the target of the language options. 1160 // 1161 // FIXME: We shouldn't need to do this, the target should be immutable once 1162 // created. This complexity should be lifted elsewhere. 1163 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts()); 1164 1165 assert(Clang.getFrontendOpts().Inputs.size() == 1 && 1166 "Invocation must have exactly one source file!"); 1167 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST && 1168 "FIXME: AST inputs not yet supported here!"); 1169 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 1170 "IR inputs not support here!"); 1171 1172 // Clear out old caches and data. 1173 StoredDiagnostics.clear(); 1174 TopLevelDecls.clear(); 1175 TopLevelDeclsInPreamble.clear(); 1176 1177 // Create a file manager object to provide access to and cache the filesystem. 1178 Clang.setFileManager(new FileManager); 1179 1180 // Create the source manager. 1181 Clang.setSourceManager(new SourceManager(getDiagnostics())); 1182 1183 llvm::OwningPtr<PrecompilePreambleAction> Act; 1184 Act.reset(new PrecompilePreambleAction(*this)); 1185 if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second, 1186 Clang.getFrontendOpts().Inputs[0].first)) { 1187 Clang.takeInvocation(); 1188 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk(); 1189 Preamble.clear(); 1190 if (CreatedPreambleBuffer) 1191 delete NewPreamble.first; 1192 if (PreambleTimer) 1193 PreambleTimer->stopTimer(); 1194 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1195 PreprocessorOpts.eraseRemappedFile( 1196 PreprocessorOpts.remapped_file_buffer_end() - 1); 1197 return 0; 1198 } 1199 1200 Act->Execute(); 1201 Act->EndSourceFile(); 1202 Clang.takeInvocation(); 1203 1204 if (Diagnostics->hasErrorOccurred()) { 1205 // There were errors parsing the preamble, so no precompiled header was 1206 // generated. Forget that we even tried. 1207 // FIXME: Should we leave a note for ourselves to try again? 1208 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk(); 1209 Preamble.clear(); 1210 if (CreatedPreambleBuffer) 1211 delete NewPreamble.first; 1212 if (PreambleTimer) 1213 PreambleTimer->stopTimer(); 1214 TopLevelDeclsInPreamble.clear(); 1215 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1216 PreprocessorOpts.eraseRemappedFile( 1217 PreprocessorOpts.remapped_file_buffer_end() - 1); 1218 return 0; 1219 } 1220 1221 // Keep track of the preamble we precompiled. 1222 PreambleFile = FrontendOpts.OutputFile; 1223 NumStoredDiagnosticsInPreamble = StoredDiagnostics.size(); 1224 NumWarningsInPreamble = getDiagnostics().getNumWarnings(); 1225 1226 // Keep track of all of the files that the source manager knows about, 1227 // so we can verify whether they have changed or not. 1228 FilesInPreamble.clear(); 1229 SourceManager &SourceMgr = Clang.getSourceManager(); 1230 const llvm::MemoryBuffer *MainFileBuffer 1231 = SourceMgr.getBuffer(SourceMgr.getMainFileID()); 1232 for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(), 1233 FEnd = SourceMgr.fileinfo_end(); 1234 F != FEnd; 1235 ++F) { 1236 const FileEntry *File = F->second->Entry; 1237 if (!File || F->second->getRawBuffer() == MainFileBuffer) 1238 continue; 1239 1240 FilesInPreamble[File->getName()] 1241 = std::make_pair(F->second->getSize(), File->getModificationTime()); 1242 } 1243 1244 if (PreambleTimer) 1245 PreambleTimer->stopTimer(); 1246 1247 PreambleRebuildCounter = 1; 1248 PreprocessorOpts.eraseRemappedFile( 1249 PreprocessorOpts.remapped_file_buffer_end() - 1); 1250 return CreatePaddedMainFileBuffer(NewPreamble.first, 1251 CreatedPreambleBuffer, 1252 PreambleReservedSize, 1253 FrontendOpts.Inputs[0].second); 1254} 1255 1256void ASTUnit::RealizeTopLevelDeclsFromPreamble() { 1257 std::vector<Decl *> Resolved; 1258 Resolved.reserve(TopLevelDeclsInPreamble.size()); 1259 ExternalASTSource &Source = *getASTContext().getExternalSource(); 1260 for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) { 1261 // Resolve the declaration ID to an actual declaration, possibly 1262 // deserializing the declaration in the process. 1263 Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]); 1264 if (D) 1265 Resolved.push_back(D); 1266 } 1267 TopLevelDeclsInPreamble.clear(); 1268 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end()); 1269} 1270 1271unsigned ASTUnit::getMaxPCHLevel() const { 1272 if (!getOnlyLocalDecls()) 1273 return Decl::MaxPCHLevel; 1274 1275 unsigned Result = 0; 1276 if (isMainFileAST() || SavedMainFileBuffer) 1277 ++Result; 1278 return Result; 1279} 1280 1281ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI, 1282 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 1283 bool OnlyLocalDecls, 1284 bool CaptureDiagnostics, 1285 bool PrecompilePreamble, 1286 bool CompleteTranslationUnit, 1287 bool CacheCodeCompletionResults) { 1288 if (!Diags.getPtr()) { 1289 // No diagnostics engine was provided, so create our own diagnostics object 1290 // with the default options. 1291 DiagnosticOptions DiagOpts; 1292 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0); 1293 } 1294 1295 // Create the AST unit. 1296 llvm::OwningPtr<ASTUnit> AST; 1297 AST.reset(new ASTUnit(false)); 1298 AST->Diagnostics = Diags; 1299 AST->CaptureDiagnostics = CaptureDiagnostics; 1300 AST->OnlyLocalDecls = OnlyLocalDecls; 1301 AST->CompleteTranslationUnit = CompleteTranslationUnit; 1302 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; 1303 AST->Invocation.reset(CI); 1304 CI->getPreprocessorOpts().RetainRemappedFileBuffers = true; 1305 1306 if (getenv("LIBCLANG_TIMING")) 1307 AST->TimerGroup.reset( 1308 new llvm::TimerGroup(CI->getFrontendOpts().Inputs[0].second)); 1309 1310 1311 llvm::MemoryBuffer *OverrideMainBuffer = 0; 1312 // FIXME: When C++ PCH is ready, allow use of it for a precompiled preamble. 1313 if (PrecompilePreamble && !CI->getLangOpts().CPlusPlus) { 1314 AST->PreambleRebuildCounter = 1; 1315 OverrideMainBuffer 1316 = AST->getMainBufferWithPrecompiledPreamble(*AST->Invocation); 1317 } 1318 1319 llvm::Timer *ParsingTimer = 0; 1320 if (AST->TimerGroup.get()) { 1321 ParsingTimer = new llvm::Timer("Initial parse", *AST->TimerGroup); 1322 ParsingTimer->startTimer(); 1323 AST->Timers.push_back(ParsingTimer); 1324 } 1325 1326 bool Failed = AST->Parse(OverrideMainBuffer); 1327 if (ParsingTimer) 1328 ParsingTimer->stopTimer(); 1329 1330 return Failed? 0 : AST.take(); 1331} 1332 1333ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin, 1334 const char **ArgEnd, 1335 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 1336 llvm::StringRef ResourceFilesPath, 1337 bool OnlyLocalDecls, 1338 RemappedFile *RemappedFiles, 1339 unsigned NumRemappedFiles, 1340 bool CaptureDiagnostics, 1341 bool PrecompilePreamble, 1342 bool CompleteTranslationUnit, 1343 bool CacheCodeCompletionResults) { 1344 bool CreatedDiagnosticsObject = false; 1345 1346 if (!Diags.getPtr()) { 1347 // No diagnostics engine was provided, so create our own diagnostics object 1348 // with the default options. 1349 DiagnosticOptions DiagOpts; 1350 Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0); 1351 CreatedDiagnosticsObject = true; 1352 } 1353 1354 llvm::SmallVector<const char *, 16> Args; 1355 Args.push_back("<clang>"); // FIXME: Remove dummy argument. 1356 Args.insert(Args.end(), ArgBegin, ArgEnd); 1357 1358 // FIXME: Find a cleaner way to force the driver into restricted modes. We 1359 // also want to force it to use clang. 1360 Args.push_back("-fsyntax-only"); 1361 1362 // FIXME: We shouldn't have to pass in the path info. 1363 driver::Driver TheDriver("clang", llvm::sys::getHostTriple(), 1364 "a.out", false, false, *Diags); 1365 1366 // Don't check that inputs exist, they have been remapped. 1367 TheDriver.setCheckInputsExist(false); 1368 1369 llvm::OwningPtr<driver::Compilation> C( 1370 TheDriver.BuildCompilation(Args.size(), Args.data())); 1371 1372 // We expect to get back exactly one command job, if we didn't something 1373 // failed. 1374 const driver::JobList &Jobs = C->getJobs(); 1375 if (Jobs.size() != 1 || !isa<driver::Command>(Jobs.begin())) { 1376 llvm::SmallString<256> Msg; 1377 llvm::raw_svector_ostream OS(Msg); 1378 C->PrintJob(OS, C->getJobs(), "; ", true); 1379 Diags->Report(diag::err_fe_expected_compiler_job) << OS.str(); 1380 return 0; 1381 } 1382 1383 const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin()); 1384 if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") { 1385 Diags->Report(diag::err_fe_expected_clang_command); 1386 return 0; 1387 } 1388 1389 const driver::ArgStringList &CCArgs = Cmd->getArguments(); 1390 llvm::OwningPtr<CompilerInvocation> CI(new CompilerInvocation); 1391 CompilerInvocation::CreateFromArgs(*CI, 1392 const_cast<const char **>(CCArgs.data()), 1393 const_cast<const char **>(CCArgs.data()) + 1394 CCArgs.size(), 1395 *Diags); 1396 1397 // Override any files that need remapping 1398 for (unsigned I = 0; I != NumRemappedFiles; ++I) 1399 CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, 1400 RemappedFiles[I].second); 1401 1402 // Override the resources path. 1403 CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; 1404 1405 CI->getFrontendOpts().DisableFree = false; 1406 return LoadFromCompilerInvocation(CI.take(), Diags, OnlyLocalDecls, 1407 CaptureDiagnostics, PrecompilePreamble, 1408 CompleteTranslationUnit, 1409 CacheCodeCompletionResults); 1410} 1411 1412bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) { 1413 if (!Invocation.get()) 1414 return true; 1415 1416 llvm::Timer *ReparsingTimer = 0; 1417 if (TimerGroup.get()) { 1418 ReparsingTimer = new llvm::Timer("Reparse", *TimerGroup); 1419 ReparsingTimer->startTimer(); 1420 Timers.push_back(ReparsingTimer); 1421 } 1422 1423 // Remap files. 1424 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 1425 for (PreprocessorOptions::remapped_file_buffer_iterator 1426 R = PPOpts.remapped_file_buffer_begin(), 1427 REnd = PPOpts.remapped_file_buffer_end(); 1428 R != REnd; 1429 ++R) { 1430 delete R->second; 1431 } 1432 Invocation->getPreprocessorOpts().clearRemappedFiles(); 1433 for (unsigned I = 0; I != NumRemappedFiles; ++I) 1434 Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, 1435 RemappedFiles[I].second); 1436 1437 // If we have a preamble file lying around, or if we might try to 1438 // build a precompiled preamble, do so now. 1439 llvm::MemoryBuffer *OverrideMainBuffer = 0; 1440 if (!PreambleFile.empty() || PreambleRebuildCounter > 0) 1441 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); 1442 1443 // Clear out the diagnostics state. 1444 if (!OverrideMainBuffer) 1445 getDiagnostics().Reset(); 1446 1447 // Parse the sources 1448 bool Result = Parse(OverrideMainBuffer); 1449 if (ReparsingTimer) 1450 ReparsingTimer->stopTimer(); 1451 1452 if (ShouldCacheCodeCompletionResults) { 1453 if (CacheCodeCompletionCoolDown > 0) 1454 --CacheCodeCompletionCoolDown; 1455 else if (top_level_size() != NumTopLevelDeclsAtLastCompletionCache) 1456 CacheCodeCompletionResults(); 1457 } 1458 1459 return Result; 1460} 1461 1462//----------------------------------------------------------------------------// 1463// Code completion 1464//----------------------------------------------------------------------------// 1465 1466namespace { 1467 /// \brief Code completion consumer that combines the cached code-completion 1468 /// results from an ASTUnit with the code-completion results provided to it, 1469 /// then passes the result on to 1470 class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer { 1471 unsigned NormalContexts; 1472 ASTUnit &AST; 1473 CodeCompleteConsumer &Next; 1474 1475 public: 1476 AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, 1477 bool IncludeMacros, bool IncludeCodePatterns, 1478 bool IncludeGlobals) 1479 : CodeCompleteConsumer(IncludeMacros, IncludeCodePatterns, IncludeGlobals, 1480 Next.isOutputBinary()), AST(AST), Next(Next) 1481 { 1482 // Compute the set of contexts in which we will look when we don't have 1483 // any information about the specific context. 1484 NormalContexts 1485 = (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 1486 | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1)) 1487 | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1)) 1488 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 1489 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 1490 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 1491 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)) 1492 | (1 << (CodeCompletionContext::CCC_MemberAccess - 1)) 1493 | (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1)); 1494 1495 if (AST.getASTContext().getLangOptions().CPlusPlus) 1496 NormalContexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1)) 1497 | (1 << (CodeCompletionContext::CCC_UnionTag - 1)) 1498 | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1)); 1499 } 1500 1501 virtual void ProcessCodeCompleteResults(Sema &S, 1502 CodeCompletionContext Context, 1503 Result *Results, 1504 unsigned NumResults); 1505 1506 virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 1507 OverloadCandidate *Candidates, 1508 unsigned NumCandidates) { 1509 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates); 1510 } 1511 }; 1512} 1513 1514/// \brief Helper function that computes which global names are hidden by the 1515/// local code-completion results. 1516void CalculateHiddenNames(const CodeCompletionContext &Context, 1517 CodeCompleteConsumer::Result *Results, 1518 unsigned NumResults, 1519 ASTContext &Ctx, 1520 llvm::StringSet<> &HiddenNames) { 1521 bool OnlyTagNames = false; 1522 switch (Context.getKind()) { 1523 case CodeCompletionContext::CCC_Other: 1524 case CodeCompletionContext::CCC_TopLevel: 1525 case CodeCompletionContext::CCC_ObjCInterface: 1526 case CodeCompletionContext::CCC_ObjCImplementation: 1527 case CodeCompletionContext::CCC_ObjCIvarList: 1528 case CodeCompletionContext::CCC_ClassStructUnion: 1529 case CodeCompletionContext::CCC_Statement: 1530 case CodeCompletionContext::CCC_Expression: 1531 case CodeCompletionContext::CCC_ObjCMessageReceiver: 1532 case CodeCompletionContext::CCC_MemberAccess: 1533 case CodeCompletionContext::CCC_Namespace: 1534 case CodeCompletionContext::CCC_Type: 1535 break; 1536 1537 case CodeCompletionContext::CCC_EnumTag: 1538 case CodeCompletionContext::CCC_UnionTag: 1539 case CodeCompletionContext::CCC_ClassOrStructTag: 1540 OnlyTagNames = true; 1541 break; 1542 1543 case CodeCompletionContext::CCC_ObjCProtocolName: 1544 // If we're just looking for protocol names, nothing can hide them. 1545 return; 1546 } 1547 1548 typedef CodeCompleteConsumer::Result Result; 1549 for (unsigned I = 0; I != NumResults; ++I) { 1550 if (Results[I].Kind != Result::RK_Declaration) 1551 continue; 1552 1553 unsigned IDNS 1554 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace(); 1555 1556 bool Hiding = false; 1557 if (OnlyTagNames) 1558 Hiding = (IDNS & Decl::IDNS_Tag); 1559 else { 1560 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | 1561 Decl::IDNS_Namespace | Decl::IDNS_Ordinary | 1562 Decl::IDNS_NonMemberOperator); 1563 if (Ctx.getLangOptions().CPlusPlus) 1564 HiddenIDNS |= Decl::IDNS_Tag; 1565 Hiding = (IDNS & HiddenIDNS); 1566 } 1567 1568 if (!Hiding) 1569 continue; 1570 1571 DeclarationName Name = Results[I].Declaration->getDeclName(); 1572 if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo()) 1573 HiddenNames.insert(Identifier->getName()); 1574 else 1575 HiddenNames.insert(Name.getAsString()); 1576 } 1577} 1578 1579 1580void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, 1581 CodeCompletionContext Context, 1582 Result *Results, 1583 unsigned NumResults) { 1584 // Merge the results we were given with the results we cached. 1585 bool AddedResult = false; 1586 unsigned InContexts 1587 = (Context.getKind() == CodeCompletionContext::CCC_Other? NormalContexts 1588 : (1 << (Context.getKind() - 1))); 1589 1590 // Contains the set of names that are hidden by "local" completion results. 1591 llvm::StringSet<> HiddenNames; 1592 1593 typedef CodeCompleteConsumer::Result Result; 1594 llvm::SmallVector<Result, 8> AllResults; 1595 for (ASTUnit::cached_completion_iterator 1596 C = AST.cached_completion_begin(), 1597 CEnd = AST.cached_completion_end(); 1598 C != CEnd; ++C) { 1599 // If the context we are in matches any of the contexts we are 1600 // interested in, we'll add this result. 1601 if ((C->ShowInContexts & InContexts) == 0) 1602 continue; 1603 1604 // If we haven't added any results previously, do so now. 1605 if (!AddedResult) { 1606 CalculateHiddenNames(Context, Results, NumResults, S.Context, 1607 HiddenNames); 1608 AllResults.insert(AllResults.end(), Results, Results + NumResults); 1609 AddedResult = true; 1610 } 1611 1612 // Determine whether this global completion result is hidden by a local 1613 // completion result. If so, skip it. 1614 if (C->Kind != CXCursor_MacroDefinition && 1615 HiddenNames.count(C->Completion->getTypedText())) 1616 continue; 1617 1618 // Adjust priority based on similar type classes. 1619 unsigned Priority = C->Priority; 1620 if (!Context.getPreferredType().isNull()) { 1621 if (C->Kind == CXCursor_MacroDefinition) { 1622 Priority = getMacroUsagePriority(C->Completion->getTypedText(), 1623 Context.getPreferredType()->isAnyPointerType()); 1624 } else if (C->Type) { 1625 CanQualType Expected 1626 = S.Context.getCanonicalType( 1627 Context.getPreferredType().getUnqualifiedType()); 1628 SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected); 1629 if (ExpectedSTC == C->TypeClass) { 1630 // We know this type is similar; check for an exact match. 1631 llvm::StringMap<unsigned> &CachedCompletionTypes 1632 = AST.getCachedCompletionTypes(); 1633 llvm::StringMap<unsigned>::iterator Pos 1634 = CachedCompletionTypes.find(QualType(Expected).getAsString()); 1635 if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type) 1636 Priority /= CCF_ExactTypeMatch; 1637 else 1638 Priority /= CCF_SimilarTypeMatch; 1639 } 1640 } 1641 } 1642 1643 AllResults.push_back(Result(C->Completion, Priority, C->Kind)); 1644 } 1645 1646 // If we did not add any cached completion results, just forward the 1647 // results we were given to the next consumer. 1648 if (!AddedResult) { 1649 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); 1650 return; 1651 } 1652 1653 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(), 1654 AllResults.size()); 1655} 1656 1657 1658 1659void ASTUnit::CodeComplete(llvm::StringRef File, unsigned Line, unsigned Column, 1660 RemappedFile *RemappedFiles, 1661 unsigned NumRemappedFiles, 1662 bool IncludeMacros, 1663 bool IncludeCodePatterns, 1664 CodeCompleteConsumer &Consumer, 1665 Diagnostic &Diag, LangOptions &LangOpts, 1666 SourceManager &SourceMgr, FileManager &FileMgr, 1667 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics, 1668 llvm::SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) { 1669 if (!Invocation.get()) 1670 return; 1671 1672 llvm::Timer *CompletionTimer = 0; 1673 if (TimerGroup.get()) { 1674 llvm::SmallString<128> TimerName; 1675 llvm::raw_svector_ostream TimerNameOut(TimerName); 1676 TimerNameOut << "Code completion @ " << File << ":" << Line << ":" 1677 << Column; 1678 CompletionTimer = new llvm::Timer(TimerNameOut.str(), *TimerGroup); 1679 CompletionTimer->startTimer(); 1680 Timers.push_back(CompletionTimer); 1681 } 1682 1683 CompilerInvocation CCInvocation(*Invocation); 1684 FrontendOptions &FrontendOpts = CCInvocation.getFrontendOpts(); 1685 PreprocessorOptions &PreprocessorOpts = CCInvocation.getPreprocessorOpts(); 1686 1687 FrontendOpts.ShowMacrosInCodeCompletion 1688 = IncludeMacros && CachedCompletionResults.empty(); 1689 FrontendOpts.ShowCodePatternsInCodeCompletion = IncludeCodePatterns; 1690 FrontendOpts.ShowGlobalSymbolsInCodeCompletion 1691 = CachedCompletionResults.empty(); 1692 FrontendOpts.CodeCompletionAt.FileName = File; 1693 FrontendOpts.CodeCompletionAt.Line = Line; 1694 FrontendOpts.CodeCompletionAt.Column = Column; 1695 1696 // Turn on spell-checking when performing code completion. It leads 1697 // to better results. 1698 unsigned SpellChecking = CCInvocation.getLangOpts().SpellChecking; 1699 CCInvocation.getLangOpts().SpellChecking = 1; 1700 1701 // Set the language options appropriately. 1702 LangOpts = CCInvocation.getLangOpts(); 1703 1704 CompilerInstance Clang; 1705 Clang.setInvocation(&CCInvocation); 1706 OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second; 1707 1708 // Set up diagnostics, capturing any diagnostics produced. 1709 Clang.setDiagnostics(&Diag); 1710 CaptureDroppedDiagnostics Capture(true, 1711 Clang.getDiagnostics(), 1712 StoredDiagnostics); 1713 1714 // Create the target instance. 1715 Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(), 1716 Clang.getTargetOpts())); 1717 if (!Clang.hasTarget()) { 1718 Clang.takeInvocation(); 1719 CCInvocation.getLangOpts().SpellChecking = SpellChecking; 1720 return; 1721 } 1722 1723 // Inform the target of the language options. 1724 // 1725 // FIXME: We shouldn't need to do this, the target should be immutable once 1726 // created. This complexity should be lifted elsewhere. 1727 Clang.getTarget().setForcedLangOptions(Clang.getLangOpts()); 1728 1729 assert(Clang.getFrontendOpts().Inputs.size() == 1 && 1730 "Invocation must have exactly one source file!"); 1731 assert(Clang.getFrontendOpts().Inputs[0].first != IK_AST && 1732 "FIXME: AST inputs not yet supported here!"); 1733 assert(Clang.getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 1734 "IR inputs not support here!"); 1735 1736 1737 // Use the source and file managers that we were given. 1738 Clang.setFileManager(&FileMgr); 1739 Clang.setSourceManager(&SourceMgr); 1740 1741 // Remap files. 1742 PreprocessorOpts.clearRemappedFiles(); 1743 PreprocessorOpts.RetainRemappedFileBuffers = true; 1744 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 1745 PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, 1746 RemappedFiles[I].second); 1747 OwnedBuffers.push_back(RemappedFiles[I].second); 1748 } 1749 1750 // Use the code completion consumer we were given, but adding any cached 1751 // code-completion results. 1752 AugmentedCodeCompleteConsumer 1753 AugmentedConsumer(*this, Consumer, FrontendOpts.ShowMacrosInCodeCompletion, 1754 FrontendOpts.ShowCodePatternsInCodeCompletion, 1755 FrontendOpts.ShowGlobalSymbolsInCodeCompletion); 1756 Clang.setCodeCompletionConsumer(&AugmentedConsumer); 1757 1758 // If we have a precompiled preamble, try to use it. We only allow 1759 // the use of the precompiled preamble if we're if the completion 1760 // point is within the main file, after the end of the precompiled 1761 // preamble. 1762 llvm::MemoryBuffer *OverrideMainBuffer = 0; 1763 if (!PreambleFile.empty()) { 1764 using llvm::sys::FileStatus; 1765 llvm::sys::PathWithStatus CompleteFilePath(File); 1766 llvm::sys::PathWithStatus MainPath(OriginalSourceFile); 1767 if (const FileStatus *CompleteFileStatus = CompleteFilePath.getFileStatus()) 1768 if (const FileStatus *MainStatus = MainPath.getFileStatus()) 1769 if (CompleteFileStatus->getUniqueID() == MainStatus->getUniqueID()) 1770 OverrideMainBuffer 1771 = getMainBufferWithPrecompiledPreamble(CCInvocation, false, Line); 1772 } 1773 1774 // If the main file has been overridden due to the use of a preamble, 1775 // make that override happen and introduce the preamble. 1776 if (OverrideMainBuffer) { 1777 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); 1778 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); 1779 PreprocessorOpts.PrecompiledPreambleBytes.second 1780 = PreambleEndsAtStartOfLine; 1781 PreprocessorOpts.ImplicitPCHInclude = PreambleFile; 1782 PreprocessorOpts.DisablePCHValidation = true; 1783 1784 // The stored diagnostics have the old source manager. Copy them 1785 // to our output set of stored diagnostics, updating the source 1786 // manager to the one we were given. 1787 for (unsigned I = 0, N = this->StoredDiagnostics.size(); I != N; ++I) { 1788 StoredDiagnostics.push_back(this->StoredDiagnostics[I]); 1789 FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SourceMgr); 1790 StoredDiagnostics[I].setLocation(Loc); 1791 } 1792 1793 OwnedBuffers.push_back(OverrideMainBuffer); 1794 } else { 1795 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 1796 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 1797 } 1798 1799 llvm::OwningPtr<SyntaxOnlyAction> Act; 1800 Act.reset(new SyntaxOnlyAction); 1801 if (Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second, 1802 Clang.getFrontendOpts().Inputs[0].first)) { 1803 Act->Execute(); 1804 Act->EndSourceFile(); 1805 } 1806 1807 if (CompletionTimer) 1808 CompletionTimer->stopTimer(); 1809 1810 // Steal back our resources. 1811 Clang.takeFileManager(); 1812 Clang.takeSourceManager(); 1813 Clang.takeInvocation(); 1814 Clang.takeCodeCompletionConsumer(); 1815 CCInvocation.getLangOpts().SpellChecking = SpellChecking; 1816} 1817 1818bool ASTUnit::Save(llvm::StringRef File) { 1819 if (getDiagnostics().hasErrorOccurred()) 1820 return true; 1821 1822 // FIXME: Can we somehow regenerate the stat cache here, or do we need to 1823 // unconditionally create a stat cache when we parse the file? 1824 std::string ErrorInfo; 1825 llvm::raw_fd_ostream Out(File.str().c_str(), ErrorInfo, 1826 llvm::raw_fd_ostream::F_Binary); 1827 if (!ErrorInfo.empty() || Out.has_error()) 1828 return true; 1829 1830 std::vector<unsigned char> Buffer; 1831 llvm::BitstreamWriter Stream(Buffer); 1832 ASTWriter Writer(Stream); 1833 Writer.WriteAST(getSema(), 0, 0); 1834 1835 // Write the generated bitstream to "Out". 1836 if (!Buffer.empty()) 1837 Out.write((char *)&Buffer.front(), Buffer.size()); 1838 Out.close(); 1839 return Out.has_error(); 1840} 1841