ASTUnit.cpp revision 39c411fa229b2a6747b92f945d1702ee674d3470
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/ArgList.h" 24#include "clang/Driver/Options.h" 25#include "clang/Driver/Tool.h" 26#include "clang/Frontend/CompilerInstance.h" 27#include "clang/Frontend/FrontendActions.h" 28#include "clang/Frontend/FrontendDiagnostic.h" 29#include "clang/Frontend/FrontendOptions.h" 30#include "clang/Frontend/Utils.h" 31#include "clang/Serialization/ASTReader.h" 32#include "clang/Serialization/ASTSerializationListener.h" 33#include "clang/Serialization/ASTWriter.h" 34#include "clang/Lex/HeaderSearch.h" 35#include "clang/Lex/Preprocessor.h" 36#include "clang/Basic/TargetOptions.h" 37#include "clang/Basic/TargetInfo.h" 38#include "clang/Basic/Diagnostic.h" 39#include "llvm/ADT/ArrayRef.h" 40#include "llvm/ADT/StringExtras.h" 41#include "llvm/ADT/StringSet.h" 42#include "llvm/Support/Atomic.h" 43#include "llvm/Support/MemoryBuffer.h" 44#include "llvm/Support/Host.h" 45#include "llvm/Support/Path.h" 46#include "llvm/Support/raw_ostream.h" 47#include "llvm/Support/Timer.h" 48#include "llvm/Support/CrashRecoveryContext.h" 49#include <cstdlib> 50#include <cstdio> 51#include <sys/stat.h> 52using namespace clang; 53 54using llvm::TimeRecord; 55 56namespace { 57 class SimpleTimer { 58 bool WantTiming; 59 TimeRecord Start; 60 std::string Output; 61 62 public: 63 explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) { 64 if (WantTiming) 65 Start = TimeRecord::getCurrentTime(); 66 } 67 68 void setOutput(const llvm::Twine &Output) { 69 if (WantTiming) 70 this->Output = Output.str(); 71 } 72 73 ~SimpleTimer() { 74 if (WantTiming) { 75 TimeRecord Elapsed = TimeRecord::getCurrentTime(); 76 Elapsed -= Start; 77 llvm::errs() << Output << ':'; 78 Elapsed.print(Elapsed, llvm::errs()); 79 llvm::errs() << '\n'; 80 } 81 } 82 }; 83} 84 85/// \brief After failing to build a precompiled preamble (due to 86/// errors in the source that occurs in the preamble), the number of 87/// reparses during which we'll skip even trying to precompile the 88/// preamble. 89const unsigned DefaultPreambleRebuildInterval = 5; 90 91/// \brief Tracks the number of ASTUnit objects that are currently active. 92/// 93/// Used for debugging purposes only. 94static llvm::sys::cas_flag ActiveASTUnitObjects; 95 96ASTUnit::ASTUnit(bool _MainFileIsAST) 97 : OnlyLocalDecls(false), CaptureDiagnostics(false), 98 MainFileIsAST(_MainFileIsAST), 99 CompleteTranslationUnit(true), WantTiming(getenv("LIBCLANG_TIMING")), 100 OwnsRemappedFileBuffers(true), 101 NumStoredDiagnosticsFromDriver(0), 102 ConcurrencyCheckValue(CheckUnlocked), 103 PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0), 104 ShouldCacheCodeCompletionResults(false), 105 NestedMacroInstantiations(true), 106 CompletionCacheTopLevelHashValue(0), 107 PreambleTopLevelHashValue(0), 108 CurrentTopLevelHashValue(0), 109 UnsafeToFree(false) { 110 if (getenv("LIBCLANG_OBJTRACKING")) { 111 llvm::sys::AtomicIncrement(&ActiveASTUnitObjects); 112 fprintf(stderr, "+++ %d translation units\n", ActiveASTUnitObjects); 113 } 114} 115 116ASTUnit::~ASTUnit() { 117 ConcurrencyCheckValue = CheckLocked; 118 CleanTemporaryFiles(); 119 if (!PreambleFile.empty()) 120 llvm::sys::Path(PreambleFile).eraseFromDisk(); 121 122 // Free the buffers associated with remapped files. We are required to 123 // perform this operation here because we explicitly request that the 124 // compiler instance *not* free these buffers for each invocation of the 125 // parser. 126 if (Invocation.getPtr() && OwnsRemappedFileBuffers) { 127 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 128 for (PreprocessorOptions::remapped_file_buffer_iterator 129 FB = PPOpts.remapped_file_buffer_begin(), 130 FBEnd = PPOpts.remapped_file_buffer_end(); 131 FB != FBEnd; 132 ++FB) 133 delete FB->second; 134 } 135 136 delete SavedMainFileBuffer; 137 delete PreambleBuffer; 138 139 ClearCachedCompletionResults(); 140 141 if (getenv("LIBCLANG_OBJTRACKING")) { 142 llvm::sys::AtomicDecrement(&ActiveASTUnitObjects); 143 fprintf(stderr, "--- %d translation units\n", ActiveASTUnitObjects); 144 } 145} 146 147void ASTUnit::CleanTemporaryFiles() { 148 for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) 149 TemporaryFiles[I].eraseFromDisk(); 150 TemporaryFiles.clear(); 151} 152 153/// \brief Determine the set of code-completion contexts in which this 154/// declaration should be shown. 155static unsigned getDeclShowContexts(NamedDecl *ND, 156 const LangOptions &LangOpts, 157 bool &IsNestedNameSpecifier) { 158 IsNestedNameSpecifier = false; 159 160 if (isa<UsingShadowDecl>(ND)) 161 ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl()); 162 if (!ND) 163 return 0; 164 165 unsigned Contexts = 0; 166 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) || 167 isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) { 168 // Types can appear in these contexts. 169 if (LangOpts.CPlusPlus || !isa<TagDecl>(ND)) 170 Contexts |= (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 171 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 172 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1)) 173 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 174 | (1 << (CodeCompletionContext::CCC_Type - 1)) 175 | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1)); 176 177 // In C++, types can appear in expressions contexts (for functional casts). 178 if (LangOpts.CPlusPlus) 179 Contexts |= (1 << (CodeCompletionContext::CCC_Expression - 1)); 180 181 // In Objective-C, message sends can send interfaces. In Objective-C++, 182 // all types are available due to functional casts. 183 if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND)) 184 Contexts |= (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)); 185 186 // Deal with tag names. 187 if (isa<EnumDecl>(ND)) { 188 Contexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1)); 189 190 // Part of the nested-name-specifier in C++0x. 191 if (LangOpts.CPlusPlus0x) 192 IsNestedNameSpecifier = true; 193 } else if (RecordDecl *Record = dyn_cast<RecordDecl>(ND)) { 194 if (Record->isUnion()) 195 Contexts |= (1 << (CodeCompletionContext::CCC_UnionTag - 1)); 196 else 197 Contexts |= (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1)); 198 199 if (LangOpts.CPlusPlus) 200 IsNestedNameSpecifier = true; 201 } else if (isa<ClassTemplateDecl>(ND)) 202 IsNestedNameSpecifier = true; 203 } else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 204 // Values can appear in these contexts. 205 Contexts = (1 << (CodeCompletionContext::CCC_Statement - 1)) 206 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 207 | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1)) 208 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)); 209 } else if (isa<ObjCProtocolDecl>(ND)) { 210 Contexts = (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1)); 211 } else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) { 212 Contexts = (1 << (CodeCompletionContext::CCC_Namespace - 1)); 213 214 // Part of the nested-name-specifier. 215 IsNestedNameSpecifier = true; 216 } 217 218 return Contexts; 219} 220 221void ASTUnit::CacheCodeCompletionResults() { 222 if (!TheSema) 223 return; 224 225 SimpleTimer Timer(WantTiming); 226 Timer.setOutput("Cache global code completions for " + getMainFileName()); 227 228 // Clear out the previous results. 229 ClearCachedCompletionResults(); 230 231 // Gather the set of global code completions. 232 typedef CodeCompletionResult Result; 233 llvm::SmallVector<Result, 8> Results; 234 CachedCompletionAllocator = new GlobalCodeCompletionAllocator; 235 TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, Results); 236 237 // Translate global code completions into cached completions. 238 llvm::DenseMap<CanQualType, unsigned> CompletionTypes; 239 240 for (unsigned I = 0, N = Results.size(); I != N; ++I) { 241 switch (Results[I].Kind) { 242 case Result::RK_Declaration: { 243 bool IsNestedNameSpecifier = false; 244 CachedCodeCompletionResult CachedResult; 245 CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema, 246 *CachedCompletionAllocator); 247 CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration, 248 Ctx->getLangOptions(), 249 IsNestedNameSpecifier); 250 CachedResult.Priority = Results[I].Priority; 251 CachedResult.Kind = Results[I].CursorKind; 252 CachedResult.Availability = Results[I].Availability; 253 254 // Keep track of the type of this completion in an ASTContext-agnostic 255 // way. 256 QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration); 257 if (UsageType.isNull()) { 258 CachedResult.TypeClass = STC_Void; 259 CachedResult.Type = 0; 260 } else { 261 CanQualType CanUsageType 262 = Ctx->getCanonicalType(UsageType.getUnqualifiedType()); 263 CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType); 264 265 // Determine whether we have already seen this type. If so, we save 266 // ourselves the work of formatting the type string by using the 267 // temporary, CanQualType-based hash table to find the associated value. 268 unsigned &TypeValue = CompletionTypes[CanUsageType]; 269 if (TypeValue == 0) { 270 TypeValue = CompletionTypes.size(); 271 CachedCompletionTypes[QualType(CanUsageType).getAsString()] 272 = TypeValue; 273 } 274 275 CachedResult.Type = TypeValue; 276 } 277 278 CachedCompletionResults.push_back(CachedResult); 279 280 /// Handle nested-name-specifiers in C++. 281 if (TheSema->Context.getLangOptions().CPlusPlus && 282 IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) { 283 // The contexts in which a nested-name-specifier can appear in C++. 284 unsigned NNSContexts 285 = (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 286 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 287 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1)) 288 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 289 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 290 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)) 291 | (1 << (CodeCompletionContext::CCC_EnumTag - 1)) 292 | (1 << (CodeCompletionContext::CCC_UnionTag - 1)) 293 | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1)) 294 | (1 << (CodeCompletionContext::CCC_Type - 1)) 295 | (1 << (CodeCompletionContext::CCC_PotentiallyQualifiedName - 1)) 296 | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1)); 297 298 if (isa<NamespaceDecl>(Results[I].Declaration) || 299 isa<NamespaceAliasDecl>(Results[I].Declaration)) 300 NNSContexts |= (1 << (CodeCompletionContext::CCC_Namespace - 1)); 301 302 if (unsigned RemainingContexts 303 = NNSContexts & ~CachedResult.ShowInContexts) { 304 // If there any contexts where this completion can be a 305 // nested-name-specifier but isn't already an option, create a 306 // nested-name-specifier completion. 307 Results[I].StartsNestedNameSpecifier = true; 308 CachedResult.Completion 309 = Results[I].CreateCodeCompletionString(*TheSema, 310 *CachedCompletionAllocator); 311 CachedResult.ShowInContexts = RemainingContexts; 312 CachedResult.Priority = CCP_NestedNameSpecifier; 313 CachedResult.TypeClass = STC_Void; 314 CachedResult.Type = 0; 315 CachedCompletionResults.push_back(CachedResult); 316 } 317 } 318 break; 319 } 320 321 case Result::RK_Keyword: 322 case Result::RK_Pattern: 323 // Ignore keywords and patterns; we don't care, since they are so 324 // easily regenerated. 325 break; 326 327 case Result::RK_Macro: { 328 CachedCodeCompletionResult CachedResult; 329 CachedResult.Completion 330 = Results[I].CreateCodeCompletionString(*TheSema, 331 *CachedCompletionAllocator); 332 CachedResult.ShowInContexts 333 = (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 334 | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1)) 335 | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1)) 336 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 337 | (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1)) 338 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 339 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 340 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)) 341 | (1 << (CodeCompletionContext::CCC_MacroNameUse - 1)) 342 | (1 << (CodeCompletionContext::CCC_PreprocessorExpression - 1)) 343 | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1)) 344 | (1 << (CodeCompletionContext::CCC_OtherWithMacros - 1)); 345 346 CachedResult.Priority = Results[I].Priority; 347 CachedResult.Kind = Results[I].CursorKind; 348 CachedResult.Availability = Results[I].Availability; 349 CachedResult.TypeClass = STC_Void; 350 CachedResult.Type = 0; 351 CachedCompletionResults.push_back(CachedResult); 352 break; 353 } 354 } 355 } 356 357 // Save the current top-level hash value. 358 CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue; 359} 360 361void ASTUnit::ClearCachedCompletionResults() { 362 CachedCompletionResults.clear(); 363 CachedCompletionTypes.clear(); 364 CachedCompletionAllocator = 0; 365} 366 367namespace { 368 369/// \brief Gathers information from ASTReader that will be used to initialize 370/// a Preprocessor. 371class ASTInfoCollector : public ASTReaderListener { 372 LangOptions &LangOpt; 373 HeaderSearch &HSI; 374 std::string &TargetTriple; 375 std::string &Predefines; 376 unsigned &Counter; 377 378 unsigned NumHeaderInfos; 379 380public: 381 ASTInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI, 382 std::string &TargetTriple, std::string &Predefines, 383 unsigned &Counter) 384 : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple), 385 Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {} 386 387 virtual bool ReadLanguageOptions(const LangOptions &LangOpts) { 388 LangOpt = LangOpts; 389 return false; 390 } 391 392 virtual bool ReadTargetTriple(llvm::StringRef Triple) { 393 TargetTriple = Triple; 394 return false; 395 } 396 397 virtual bool ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 398 llvm::StringRef OriginalFileName, 399 std::string &SuggestedPredefines, 400 FileManager &FileMgr) { 401 Predefines = Buffers[0].Data; 402 for (unsigned I = 1, N = Buffers.size(); I != N; ++I) { 403 Predefines += Buffers[I].Data; 404 } 405 return false; 406 } 407 408 virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) { 409 HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++); 410 } 411 412 virtual void ReadCounter(unsigned Value) { 413 Counter = Value; 414 } 415}; 416 417class StoredDiagnosticClient : public DiagnosticClient { 418 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags; 419 420public: 421 explicit StoredDiagnosticClient( 422 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags) 423 : StoredDiags(StoredDiags) { } 424 425 virtual void HandleDiagnostic(Diagnostic::Level Level, 426 const DiagnosticInfo &Info); 427}; 428 429/// \brief RAII object that optionally captures diagnostics, if 430/// there is no diagnostic client to capture them already. 431class CaptureDroppedDiagnostics { 432 Diagnostic &Diags; 433 StoredDiagnosticClient Client; 434 DiagnosticClient *PreviousClient; 435 436public: 437 CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags, 438 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags) 439 : Diags(Diags), Client(StoredDiags), PreviousClient(0) 440 { 441 if (RequestCapture || Diags.getClient() == 0) { 442 PreviousClient = Diags.takeClient(); 443 Diags.setClient(&Client); 444 } 445 } 446 447 ~CaptureDroppedDiagnostics() { 448 if (Diags.getClient() == &Client) { 449 Diags.takeClient(); 450 Diags.setClient(PreviousClient); 451 } 452 } 453}; 454 455} // anonymous namespace 456 457void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level, 458 const DiagnosticInfo &Info) { 459 // Default implementation (Warnings/errors count). 460 DiagnosticClient::HandleDiagnostic(Level, Info); 461 462 StoredDiags.push_back(StoredDiagnostic(Level, Info)); 463} 464 465const std::string &ASTUnit::getOriginalSourceFileName() { 466 return OriginalSourceFile; 467} 468 469const std::string &ASTUnit::getASTFileName() { 470 assert(isMainFileAST() && "Not an ASTUnit from an AST file!"); 471 return static_cast<ASTReader *>(Ctx->getExternalSource())->getFileName(); 472} 473 474llvm::MemoryBuffer *ASTUnit::getBufferForFile(llvm::StringRef Filename, 475 std::string *ErrorStr) { 476 assert(FileMgr); 477 return FileMgr->getBufferForFile(Filename, ErrorStr); 478} 479 480/// \brief Configure the diagnostics object for use with ASTUnit. 481void ASTUnit::ConfigureDiags(llvm::IntrusiveRefCntPtr<Diagnostic> &Diags, 482 const char **ArgBegin, const char **ArgEnd, 483 ASTUnit &AST, bool CaptureDiagnostics) { 484 if (!Diags.getPtr()) { 485 // No diagnostics engine was provided, so create our own diagnostics object 486 // with the default options. 487 DiagnosticOptions DiagOpts; 488 DiagnosticClient *Client = 0; 489 if (CaptureDiagnostics) 490 Client = new StoredDiagnosticClient(AST.StoredDiagnostics); 491 Diags = CompilerInstance::createDiagnostics(DiagOpts, ArgEnd- ArgBegin, 492 ArgBegin, Client); 493 } else if (CaptureDiagnostics) { 494 Diags->setClient(new StoredDiagnosticClient(AST.StoredDiagnostics)); 495 } 496} 497 498ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename, 499 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 500 const FileSystemOptions &FileSystemOpts, 501 bool OnlyLocalDecls, 502 RemappedFile *RemappedFiles, 503 unsigned NumRemappedFiles, 504 bool CaptureDiagnostics) { 505 llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true)); 506 507 // Recover resources if we crash before exiting this method. 508 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 509 ASTUnitCleanup(AST.get()); 510 llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic, 511 llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> > 512 DiagCleanup(Diags.getPtr()); 513 514 ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); 515 516 AST->OnlyLocalDecls = OnlyLocalDecls; 517 AST->CaptureDiagnostics = CaptureDiagnostics; 518 AST->Diagnostics = Diags; 519 AST->FileMgr = new FileManager(FileSystemOpts); 520 AST->SourceMgr = new SourceManager(AST->getDiagnostics(), 521 AST->getFileManager()); 522 AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager())); 523 524 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 525 FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; 526 if (const llvm::MemoryBuffer * 527 memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) { 528 // Create the file entry for the file that we're mapping from. 529 const FileEntry *FromFile 530 = AST->getFileManager().getVirtualFile(RemappedFiles[I].first, 531 memBuf->getBufferSize(), 532 0); 533 if (!FromFile) { 534 AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file) 535 << RemappedFiles[I].first; 536 delete memBuf; 537 continue; 538 } 539 540 // Override the contents of the "from" file with the contents of 541 // the "to" file. 542 AST->getSourceManager().overrideFileContents(FromFile, memBuf); 543 544 } else { 545 const char *fname = fileOrBuf.get<const char *>(); 546 const FileEntry *ToFile = AST->FileMgr->getFile(fname); 547 if (!ToFile) { 548 AST->getDiagnostics().Report(diag::err_fe_remap_missing_to_file) 549 << RemappedFiles[I].first << fname; 550 continue; 551 } 552 553 // Create the file entry for the file that we're mapping from. 554 const FileEntry *FromFile 555 = AST->getFileManager().getVirtualFile(RemappedFiles[I].first, 556 ToFile->getSize(), 557 0); 558 if (!FromFile) { 559 AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file) 560 << RemappedFiles[I].first; 561 delete memBuf; 562 continue; 563 } 564 565 // Override the contents of the "from" file with the contents of 566 // the "to" file. 567 AST->getSourceManager().overrideFileContents(FromFile, ToFile); 568 } 569 } 570 571 // Gather Info for preprocessor construction later on. 572 573 LangOptions LangInfo; 574 HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); 575 std::string TargetTriple; 576 std::string Predefines; 577 unsigned Counter; 578 579 llvm::OwningPtr<ASTReader> Reader; 580 581 Reader.reset(new ASTReader(AST->getSourceManager(), AST->getFileManager(), 582 AST->getDiagnostics())); 583 584 // Recover resources if we crash before exiting this method. 585 llvm::CrashRecoveryContextCleanupRegistrar<ASTReader> 586 ReaderCleanup(Reader.get()); 587 588 Reader->setListener(new ASTInfoCollector(LangInfo, HeaderInfo, TargetTriple, 589 Predefines, Counter)); 590 591 switch (Reader->ReadAST(Filename, ASTReader::MainFile)) { 592 case ASTReader::Success: 593 break; 594 595 case ASTReader::Failure: 596 case ASTReader::IgnorePCH: 597 AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch); 598 return NULL; 599 } 600 601 AST->OriginalSourceFile = Reader->getOriginalSourceFile(); 602 603 // AST file loaded successfully. Now create the preprocessor. 604 605 // Get information about the target being compiled for. 606 // 607 // FIXME: This is broken, we should store the TargetOptions in the AST file. 608 TargetOptions TargetOpts; 609 TargetOpts.ABI = ""; 610 TargetOpts.CXXABI = ""; 611 TargetOpts.CPU = ""; 612 TargetOpts.Features.clear(); 613 TargetOpts.Triple = TargetTriple; 614 AST->Target = TargetInfo::CreateTargetInfo(AST->getDiagnostics(), 615 TargetOpts); 616 AST->PP = new Preprocessor(AST->getDiagnostics(), LangInfo, *AST->Target, 617 AST->getSourceManager(), HeaderInfo); 618 Preprocessor &PP = *AST->PP; 619 620 PP.setPredefines(Reader->getSuggestedPredefines()); 621 PP.setCounterValue(Counter); 622 Reader->setPreprocessor(PP); 623 624 // Create and initialize the ASTContext. 625 626 AST->Ctx = new ASTContext(LangInfo, 627 AST->getSourceManager(), 628 *AST->Target, 629 PP.getIdentifierTable(), 630 PP.getSelectorTable(), 631 PP.getBuiltinInfo(), 632 /* size_reserve = */0); 633 ASTContext &Context = *AST->Ctx; 634 635 Reader->InitializeContext(Context); 636 637 // Attach the AST reader to the AST context as an external AST 638 // source, so that declarations will be deserialized from the 639 // AST file as needed. 640 ASTReader *ReaderPtr = Reader.get(); 641 llvm::OwningPtr<ExternalASTSource> Source(Reader.take()); 642 643 // Unregister the cleanup for ASTReader. It will get cleaned up 644 // by the ASTUnit cleanup. 645 ReaderCleanup.unregister(); 646 647 Context.setExternalSource(Source); 648 649 // Create an AST consumer, even though it isn't used. 650 AST->Consumer.reset(new ASTConsumer); 651 652 // Create a semantic analysis object and tell the AST reader about it. 653 AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); 654 AST->TheSema->Initialize(); 655 ReaderPtr->InitializeSema(*AST->TheSema); 656 657 return AST.take(); 658} 659 660namespace { 661 662/// \brief Preprocessor callback class that updates a hash value with the names 663/// of all macros that have been defined by the translation unit. 664class MacroDefinitionTrackerPPCallbacks : public PPCallbacks { 665 unsigned &Hash; 666 667public: 668 explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { } 669 670 virtual void MacroDefined(const Token &MacroNameTok, const MacroInfo *MI) { 671 Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash); 672 } 673}; 674 675/// \brief Add the given declaration to the hash of all top-level entities. 676void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) { 677 if (!D) 678 return; 679 680 DeclContext *DC = D->getDeclContext(); 681 if (!DC) 682 return; 683 684 if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit())) 685 return; 686 687 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) { 688 if (ND->getIdentifier()) 689 Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash); 690 else if (DeclarationName Name = ND->getDeclName()) { 691 std::string NameStr = Name.getAsString(); 692 Hash = llvm::HashString(NameStr, Hash); 693 } 694 return; 695 } 696 697 if (ObjCForwardProtocolDecl *Forward 698 = dyn_cast<ObjCForwardProtocolDecl>(D)) { 699 for (ObjCForwardProtocolDecl::protocol_iterator 700 P = Forward->protocol_begin(), 701 PEnd = Forward->protocol_end(); 702 P != PEnd; ++P) 703 AddTopLevelDeclarationToHash(*P, Hash); 704 return; 705 } 706 707 if (ObjCClassDecl *Class = llvm::dyn_cast<ObjCClassDecl>(D)) { 708 for (ObjCClassDecl::iterator I = Class->begin(), IEnd = Class->end(); 709 I != IEnd; ++I) 710 AddTopLevelDeclarationToHash(I->getInterface(), Hash); 711 return; 712 } 713} 714 715class TopLevelDeclTrackerConsumer : public ASTConsumer { 716 ASTUnit &Unit; 717 unsigned &Hash; 718 719public: 720 TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash) 721 : Unit(_Unit), Hash(Hash) { 722 Hash = 0; 723 } 724 725 void HandleTopLevelDecl(DeclGroupRef D) { 726 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { 727 Decl *D = *it; 728 // FIXME: Currently ObjC method declarations are incorrectly being 729 // reported as top-level declarations, even though their DeclContext 730 // is the containing ObjC @interface/@implementation. This is a 731 // fundamental problem in the parser right now. 732 if (isa<ObjCMethodDecl>(D)) 733 continue; 734 735 AddTopLevelDeclarationToHash(D, Hash); 736 Unit.addTopLevelDecl(D); 737 } 738 } 739 740 // We're not interested in "interesting" decls. 741 void HandleInterestingDecl(DeclGroupRef) {} 742}; 743 744class TopLevelDeclTrackerAction : public ASTFrontendAction { 745public: 746 ASTUnit &Unit; 747 748 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, 749 llvm::StringRef InFile) { 750 CI.getPreprocessor().addPPCallbacks( 751 new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue())); 752 return new TopLevelDeclTrackerConsumer(Unit, 753 Unit.getCurrentTopLevelHashValue()); 754 } 755 756public: 757 TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {} 758 759 virtual bool hasCodeCompletionSupport() const { return false; } 760 virtual bool usesCompleteTranslationUnit() { 761 return Unit.isCompleteTranslationUnit(); 762 } 763}; 764 765class PrecompilePreambleConsumer : public PCHGenerator, 766 public ASTSerializationListener { 767 ASTUnit &Unit; 768 unsigned &Hash; 769 std::vector<Decl *> TopLevelDecls; 770 771public: 772 PrecompilePreambleConsumer(ASTUnit &Unit, 773 const Preprocessor &PP, bool Chaining, 774 const char *isysroot, llvm::raw_ostream *Out) 775 : PCHGenerator(PP, "", Chaining, isysroot, Out), Unit(Unit), 776 Hash(Unit.getCurrentTopLevelHashValue()) { 777 Hash = 0; 778 } 779 780 virtual void HandleTopLevelDecl(DeclGroupRef D) { 781 for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) { 782 Decl *D = *it; 783 // FIXME: Currently ObjC method declarations are incorrectly being 784 // reported as top-level declarations, even though their DeclContext 785 // is the containing ObjC @interface/@implementation. This is a 786 // fundamental problem in the parser right now. 787 if (isa<ObjCMethodDecl>(D)) 788 continue; 789 AddTopLevelDeclarationToHash(D, Hash); 790 TopLevelDecls.push_back(D); 791 } 792 } 793 794 virtual void HandleTranslationUnit(ASTContext &Ctx) { 795 PCHGenerator::HandleTranslationUnit(Ctx); 796 if (!Unit.getDiagnostics().hasErrorOccurred()) { 797 // Translate the top-level declarations we captured during 798 // parsing into declaration IDs in the precompiled 799 // preamble. This will allow us to deserialize those top-level 800 // declarations when requested. 801 for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I) 802 Unit.addTopLevelDeclFromPreamble( 803 getWriter().getDeclID(TopLevelDecls[I])); 804 } 805 } 806 807 virtual void SerializedPreprocessedEntity(PreprocessedEntity *Entity, 808 uint64_t Offset) { 809 Unit.addPreprocessedEntityFromPreamble(Offset); 810 } 811 812 virtual ASTSerializationListener *GetASTSerializationListener() { 813 return this; 814 } 815}; 816 817class PrecompilePreambleAction : public ASTFrontendAction { 818 ASTUnit &Unit; 819 820public: 821 explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit) {} 822 823 virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI, 824 llvm::StringRef InFile) { 825 std::string Sysroot; 826 std::string OutputFile; 827 llvm::raw_ostream *OS = 0; 828 bool Chaining; 829 if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot, 830 OutputFile, 831 OS, Chaining)) 832 return 0; 833 834 const char *isysroot = CI.getFrontendOpts().RelocatablePCH ? 835 Sysroot.c_str() : 0; 836 CI.getPreprocessor().addPPCallbacks( 837 new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue())); 838 return new PrecompilePreambleConsumer(Unit, CI.getPreprocessor(), Chaining, 839 isysroot, OS); 840 } 841 842 virtual bool hasCodeCompletionSupport() const { return false; } 843 virtual bool hasASTFileSupport() const { return false; } 844 virtual bool usesCompleteTranslationUnit() { return false; } 845}; 846 847} 848 849/// Parse the source file into a translation unit using the given compiler 850/// invocation, replacing the current translation unit. 851/// 852/// \returns True if a failure occurred that causes the ASTUnit not to 853/// contain any translation-unit information, false otherwise. 854bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) { 855 delete SavedMainFileBuffer; 856 SavedMainFileBuffer = 0; 857 858 if (!Invocation) { 859 delete OverrideMainBuffer; 860 return true; 861 } 862 863 // Create the compiler instance to use for building the AST. 864 llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance()); 865 866 // Recover resources if we crash before exiting this method. 867 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 868 CICleanup(Clang.get()); 869 870 Clang->setInvocation(&*Invocation); 871 OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second; 872 873 // Set up diagnostics, capturing any diagnostics that would 874 // otherwise be dropped. 875 Clang->setDiagnostics(&getDiagnostics()); 876 877 // Create the target instance. 878 Clang->getTargetOpts().Features = TargetFeatures; 879 Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), 880 Clang->getTargetOpts())); 881 if (!Clang->hasTarget()) { 882 delete OverrideMainBuffer; 883 return true; 884 } 885 886 // Inform the target of the language options. 887 // 888 // FIXME: We shouldn't need to do this, the target should be immutable once 889 // created. This complexity should be lifted elsewhere. 890 Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); 891 892 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 893 "Invocation must have exactly one source file!"); 894 assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST && 895 "FIXME: AST inputs not yet supported here!"); 896 assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 897 "IR inputs not support here!"); 898 899 // Configure the various subsystems. 900 // FIXME: Should we retain the previous file manager? 901 FileSystemOpts = Clang->getFileSystemOpts(); 902 FileMgr = new FileManager(FileSystemOpts); 903 SourceMgr = new SourceManager(getDiagnostics(), *FileMgr); 904 TheSema.reset(); 905 Ctx = 0; 906 PP = 0; 907 908 // Clear out old caches and data. 909 TopLevelDecls.clear(); 910 PreprocessedEntities.clear(); 911 CleanTemporaryFiles(); 912 PreprocessedEntitiesByFile.clear(); 913 914 if (!OverrideMainBuffer) { 915 StoredDiagnostics.erase( 916 StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver, 917 StoredDiagnostics.end()); 918 TopLevelDeclsInPreamble.clear(); 919 PreprocessedEntitiesInPreamble.clear(); 920 } 921 922 // Create a file manager object to provide access to and cache the filesystem. 923 Clang->setFileManager(&getFileManager()); 924 925 // Create the source manager. 926 Clang->setSourceManager(&getSourceManager()); 927 928 // If the main file has been overridden due to the use of a preamble, 929 // make that override happen and introduce the preamble. 930 PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts(); 931 PreprocessorOpts.DetailedRecordIncludesNestedMacroInstantiations 932 = NestedMacroInstantiations; 933 std::string PriorImplicitPCHInclude; 934 if (OverrideMainBuffer) { 935 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); 936 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); 937 PreprocessorOpts.PrecompiledPreambleBytes.second 938 = PreambleEndsAtStartOfLine; 939 PriorImplicitPCHInclude = PreprocessorOpts.ImplicitPCHInclude; 940 PreprocessorOpts.ImplicitPCHInclude = PreambleFile; 941 PreprocessorOpts.DisablePCHValidation = true; 942 943 // The stored diagnostic has the old source manager in it; update 944 // the locations to refer into the new source manager. Since we've 945 // been careful to make sure that the source manager's state 946 // before and after are identical, so that we can reuse the source 947 // location itself. 948 for (unsigned I = NumStoredDiagnosticsFromDriver, 949 N = StoredDiagnostics.size(); 950 I < N; ++I) { 951 FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), 952 getSourceManager()); 953 StoredDiagnostics[I].setLocation(Loc); 954 } 955 956 // Keep track of the override buffer; 957 SavedMainFileBuffer = OverrideMainBuffer; 958 } else { 959 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 960 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 961 } 962 963 llvm::OwningPtr<TopLevelDeclTrackerAction> Act( 964 new TopLevelDeclTrackerAction(*this)); 965 966 // Recover resources if we crash before exiting this method. 967 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction> 968 ActCleanup(Act.get()); 969 970 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second, 971 Clang->getFrontendOpts().Inputs[0].first)) 972 goto error; 973 974 Act->Execute(); 975 976 // Steal the created target, context, and preprocessor. 977 TheSema.reset(Clang->takeSema()); 978 Consumer.reset(Clang->takeASTConsumer()); 979 Ctx = &Clang->getASTContext(); 980 PP = &Clang->getPreprocessor(); 981 Clang->setSourceManager(0); 982 Clang->setFileManager(0); 983 Target = &Clang->getTarget(); 984 985 Act->EndSourceFile(); 986 987 // Remove the overridden buffer we used for the preamble. 988 if (OverrideMainBuffer) { 989 PreprocessorOpts.eraseRemappedFile( 990 PreprocessorOpts.remapped_file_buffer_end() - 1); 991 PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude; 992 } 993 994 return false; 995 996error: 997 // Remove the overridden buffer we used for the preamble. 998 if (OverrideMainBuffer) { 999 PreprocessorOpts.eraseRemappedFile( 1000 PreprocessorOpts.remapped_file_buffer_end() - 1); 1001 PreprocessorOpts.ImplicitPCHInclude = PriorImplicitPCHInclude; 1002 delete OverrideMainBuffer; 1003 SavedMainFileBuffer = 0; 1004 } 1005 1006 StoredDiagnostics.clear(); 1007 return true; 1008} 1009 1010/// \brief Simple function to retrieve a path for a preamble precompiled header. 1011static std::string GetPreamblePCHPath() { 1012 // FIXME: This is lame; sys::Path should provide this function (in particular, 1013 // it should know how to find the temporary files dir). 1014 // FIXME: This is really lame. I copied this code from the Driver! 1015 // FIXME: This is a hack so that we can override the preamble file during 1016 // crash-recovery testing, which is the only case where the preamble files 1017 // are not necessarily cleaned up. 1018 const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE"); 1019 if (TmpFile) 1020 return TmpFile; 1021 1022 std::string Error; 1023 const char *TmpDir = ::getenv("TMPDIR"); 1024 if (!TmpDir) 1025 TmpDir = ::getenv("TEMP"); 1026 if (!TmpDir) 1027 TmpDir = ::getenv("TMP"); 1028#ifdef LLVM_ON_WIN32 1029 if (!TmpDir) 1030 TmpDir = ::getenv("USERPROFILE"); 1031#endif 1032 if (!TmpDir) 1033 TmpDir = "/tmp"; 1034 llvm::sys::Path P(TmpDir); 1035 P.createDirectoryOnDisk(true); 1036 P.appendComponent("preamble"); 1037 P.appendSuffix("pch"); 1038 if (P.createTemporaryFileOnDisk()) 1039 return std::string(); 1040 1041 return P.str(); 1042} 1043 1044/// \brief Compute the preamble for the main file, providing the source buffer 1045/// that corresponds to the main file along with a pair (bytes, start-of-line) 1046/// that describes the preamble. 1047std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > 1048ASTUnit::ComputePreamble(CompilerInvocation &Invocation, 1049 unsigned MaxLines, bool &CreatedBuffer) { 1050 FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); 1051 PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts(); 1052 CreatedBuffer = false; 1053 1054 // Try to determine if the main file has been remapped, either from the 1055 // command line (to another file) or directly through the compiler invocation 1056 // (to a memory buffer). 1057 llvm::MemoryBuffer *Buffer = 0; 1058 llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second); 1059 if (const llvm::sys::FileStatus *MainFileStatus = MainFilePath.getFileStatus()) { 1060 // Check whether there is a file-file remapping of the main file 1061 for (PreprocessorOptions::remapped_file_iterator 1062 M = PreprocessorOpts.remapped_file_begin(), 1063 E = PreprocessorOpts.remapped_file_end(); 1064 M != E; 1065 ++M) { 1066 llvm::sys::PathWithStatus MPath(M->first); 1067 if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) { 1068 if (MainFileStatus->uniqueID == MStatus->uniqueID) { 1069 // We found a remapping. Try to load the resulting, remapped source. 1070 if (CreatedBuffer) { 1071 delete Buffer; 1072 CreatedBuffer = false; 1073 } 1074 1075 Buffer = getBufferForFile(M->second); 1076 if (!Buffer) 1077 return std::make_pair((llvm::MemoryBuffer*)0, 1078 std::make_pair(0, true)); 1079 CreatedBuffer = true; 1080 } 1081 } 1082 } 1083 1084 // Check whether there is a file-buffer remapping. It supercedes the 1085 // file-file remapping. 1086 for (PreprocessorOptions::remapped_file_buffer_iterator 1087 M = PreprocessorOpts.remapped_file_buffer_begin(), 1088 E = PreprocessorOpts.remapped_file_buffer_end(); 1089 M != E; 1090 ++M) { 1091 llvm::sys::PathWithStatus MPath(M->first); 1092 if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) { 1093 if (MainFileStatus->uniqueID == MStatus->uniqueID) { 1094 // We found a remapping. 1095 if (CreatedBuffer) { 1096 delete Buffer; 1097 CreatedBuffer = false; 1098 } 1099 1100 Buffer = const_cast<llvm::MemoryBuffer *>(M->second); 1101 } 1102 } 1103 } 1104 } 1105 1106 // If the main source file was not remapped, load it now. 1107 if (!Buffer) { 1108 Buffer = getBufferForFile(FrontendOpts.Inputs[0].second); 1109 if (!Buffer) 1110 return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true)); 1111 1112 CreatedBuffer = true; 1113 } 1114 1115 return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer, MaxLines)); 1116} 1117 1118static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old, 1119 unsigned NewSize, 1120 llvm::StringRef NewName) { 1121 llvm::MemoryBuffer *Result 1122 = llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName); 1123 memcpy(const_cast<char*>(Result->getBufferStart()), 1124 Old->getBufferStart(), Old->getBufferSize()); 1125 memset(const_cast<char*>(Result->getBufferStart()) + Old->getBufferSize(), 1126 ' ', NewSize - Old->getBufferSize() - 1); 1127 const_cast<char*>(Result->getBufferEnd())[-1] = '\n'; 1128 1129 return Result; 1130} 1131 1132/// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing 1133/// the source file. 1134/// 1135/// This routine will compute the preamble of the main source file. If a 1136/// non-trivial preamble is found, it will precompile that preamble into a 1137/// precompiled header so that the precompiled preamble can be used to reduce 1138/// reparsing time. If a precompiled preamble has already been constructed, 1139/// this routine will determine if it is still valid and, if so, avoid 1140/// rebuilding the precompiled preamble. 1141/// 1142/// \param AllowRebuild When true (the default), this routine is 1143/// allowed to rebuild the precompiled preamble if it is found to be 1144/// out-of-date. 1145/// 1146/// \param MaxLines When non-zero, the maximum number of lines that 1147/// can occur within the preamble. 1148/// 1149/// \returns If the precompiled preamble can be used, returns a newly-allocated 1150/// buffer that should be used in place of the main file when doing so. 1151/// Otherwise, returns a NULL pointer. 1152llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble( 1153 const CompilerInvocation &PreambleInvocationIn, 1154 bool AllowRebuild, 1155 unsigned MaxLines) { 1156 1157 llvm::IntrusiveRefCntPtr<CompilerInvocation> 1158 PreambleInvocation(new CompilerInvocation(PreambleInvocationIn)); 1159 FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); 1160 PreprocessorOptions &PreprocessorOpts 1161 = PreambleInvocation->getPreprocessorOpts(); 1162 1163 bool CreatedPreambleBuffer = false; 1164 std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > NewPreamble 1165 = ComputePreamble(*PreambleInvocation, MaxLines, CreatedPreambleBuffer); 1166 1167 // If ComputePreamble() Take ownership of the 1168 llvm::OwningPtr<llvm::MemoryBuffer> OwnedPreambleBuffer; 1169 if (CreatedPreambleBuffer) 1170 OwnedPreambleBuffer.reset(NewPreamble.first); 1171 1172 if (!NewPreamble.second.first) { 1173 // We couldn't find a preamble in the main source. Clear out the current 1174 // preamble, if we have one. It's obviously no good any more. 1175 Preamble.clear(); 1176 if (!PreambleFile.empty()) { 1177 llvm::sys::Path(PreambleFile).eraseFromDisk(); 1178 PreambleFile.clear(); 1179 } 1180 1181 // The next time we actually see a preamble, precompile it. 1182 PreambleRebuildCounter = 1; 1183 return 0; 1184 } 1185 1186 if (!Preamble.empty()) { 1187 // We've previously computed a preamble. Check whether we have the same 1188 // preamble now that we did before, and that there's enough space in 1189 // the main-file buffer within the precompiled preamble to fit the 1190 // new main file. 1191 if (Preamble.size() == NewPreamble.second.first && 1192 PreambleEndsAtStartOfLine == NewPreamble.second.second && 1193 NewPreamble.first->getBufferSize() < PreambleReservedSize-2 && 1194 memcmp(&Preamble[0], NewPreamble.first->getBufferStart(), 1195 NewPreamble.second.first) == 0) { 1196 // The preamble has not changed. We may be able to re-use the precompiled 1197 // preamble. 1198 1199 // Check that none of the files used by the preamble have changed. 1200 bool AnyFileChanged = false; 1201 1202 // First, make a record of those files that have been overridden via 1203 // remapping or unsaved_files. 1204 llvm::StringMap<std::pair<off_t, time_t> > OverriddenFiles; 1205 for (PreprocessorOptions::remapped_file_iterator 1206 R = PreprocessorOpts.remapped_file_begin(), 1207 REnd = PreprocessorOpts.remapped_file_end(); 1208 !AnyFileChanged && R != REnd; 1209 ++R) { 1210 struct stat StatBuf; 1211 if (FileMgr->getNoncachedStatValue(R->second, StatBuf)) { 1212 // If we can't stat the file we're remapping to, assume that something 1213 // horrible happened. 1214 AnyFileChanged = true; 1215 break; 1216 } 1217 1218 OverriddenFiles[R->first] = std::make_pair(StatBuf.st_size, 1219 StatBuf.st_mtime); 1220 } 1221 for (PreprocessorOptions::remapped_file_buffer_iterator 1222 R = PreprocessorOpts.remapped_file_buffer_begin(), 1223 REnd = PreprocessorOpts.remapped_file_buffer_end(); 1224 !AnyFileChanged && R != REnd; 1225 ++R) { 1226 // FIXME: Should we actually compare the contents of file->buffer 1227 // remappings? 1228 OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(), 1229 0); 1230 } 1231 1232 // Check whether anything has changed. 1233 for (llvm::StringMap<std::pair<off_t, time_t> >::iterator 1234 F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end(); 1235 !AnyFileChanged && F != FEnd; 1236 ++F) { 1237 llvm::StringMap<std::pair<off_t, time_t> >::iterator Overridden 1238 = OverriddenFiles.find(F->first()); 1239 if (Overridden != OverriddenFiles.end()) { 1240 // This file was remapped; check whether the newly-mapped file 1241 // matches up with the previous mapping. 1242 if (Overridden->second != F->second) 1243 AnyFileChanged = true; 1244 continue; 1245 } 1246 1247 // The file was not remapped; check whether it has changed on disk. 1248 struct stat StatBuf; 1249 if (FileMgr->getNoncachedStatValue(F->first(), StatBuf)) { 1250 // If we can't stat the file, assume that something horrible happened. 1251 AnyFileChanged = true; 1252 } else if (StatBuf.st_size != F->second.first || 1253 StatBuf.st_mtime != F->second.second) 1254 AnyFileChanged = true; 1255 } 1256 1257 if (!AnyFileChanged) { 1258 // Okay! We can re-use the precompiled preamble. 1259 1260 // Set the state of the diagnostic object to mimic its state 1261 // after parsing the preamble. 1262 // FIXME: This won't catch any #pragma push warning changes that 1263 // have occurred in the preamble. 1264 getDiagnostics().Reset(); 1265 ProcessWarningOptions(getDiagnostics(), 1266 PreambleInvocation->getDiagnosticOpts()); 1267 getDiagnostics().setNumWarnings(NumWarningsInPreamble); 1268 if (StoredDiagnostics.size() > NumStoredDiagnosticsInPreamble) 1269 StoredDiagnostics.erase( 1270 StoredDiagnostics.begin() + NumStoredDiagnosticsInPreamble, 1271 StoredDiagnostics.end()); 1272 1273 // Create a version of the main file buffer that is padded to 1274 // buffer size we reserved when creating the preamble. 1275 return CreatePaddedMainFileBuffer(NewPreamble.first, 1276 PreambleReservedSize, 1277 FrontendOpts.Inputs[0].second); 1278 } 1279 } 1280 1281 // If we aren't allowed to rebuild the precompiled preamble, just 1282 // return now. 1283 if (!AllowRebuild) 1284 return 0; 1285 1286 // We can't reuse the previously-computed preamble. Build a new one. 1287 Preamble.clear(); 1288 llvm::sys::Path(PreambleFile).eraseFromDisk(); 1289 PreambleRebuildCounter = 1; 1290 } else if (!AllowRebuild) { 1291 // We aren't allowed to rebuild the precompiled preamble; just 1292 // return now. 1293 return 0; 1294 } 1295 1296 // If the preamble rebuild counter > 1, it's because we previously 1297 // failed to build a preamble and we're not yet ready to try 1298 // again. Decrement the counter and return a failure. 1299 if (PreambleRebuildCounter > 1) { 1300 --PreambleRebuildCounter; 1301 return 0; 1302 } 1303 1304 // Create a temporary file for the precompiled preamble. In rare 1305 // circumstances, this can fail. 1306 std::string PreamblePCHPath = GetPreamblePCHPath(); 1307 if (PreamblePCHPath.empty()) { 1308 // Try again next time. 1309 PreambleRebuildCounter = 1; 1310 return 0; 1311 } 1312 1313 // We did not previously compute a preamble, or it can't be reused anyway. 1314 SimpleTimer PreambleTimer(WantTiming); 1315 PreambleTimer.setOutput("Precompiling preamble"); 1316 1317 // Create a new buffer that stores the preamble. The buffer also contains 1318 // extra space for the original contents of the file (which will be present 1319 // when we actually parse the file) along with more room in case the file 1320 // grows. 1321 PreambleReservedSize = NewPreamble.first->getBufferSize(); 1322 if (PreambleReservedSize < 4096) 1323 PreambleReservedSize = 8191; 1324 else 1325 PreambleReservedSize *= 2; 1326 1327 // Save the preamble text for later; we'll need to compare against it for 1328 // subsequent reparses. 1329 Preamble.assign(NewPreamble.first->getBufferStart(), 1330 NewPreamble.first->getBufferStart() 1331 + NewPreamble.second.first); 1332 PreambleEndsAtStartOfLine = NewPreamble.second.second; 1333 1334 delete PreambleBuffer; 1335 PreambleBuffer 1336 = llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize, 1337 FrontendOpts.Inputs[0].second); 1338 memcpy(const_cast<char*>(PreambleBuffer->getBufferStart()), 1339 NewPreamble.first->getBufferStart(), Preamble.size()); 1340 memset(const_cast<char*>(PreambleBuffer->getBufferStart()) + Preamble.size(), 1341 ' ', PreambleReservedSize - Preamble.size() - 1); 1342 const_cast<char*>(PreambleBuffer->getBufferEnd())[-1] = '\n'; 1343 1344 // Remap the main source file to the preamble buffer. 1345 llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second); 1346 PreprocessorOpts.addRemappedFile(MainFilePath.str(), PreambleBuffer); 1347 1348 // Tell the compiler invocation to generate a temporary precompiled header. 1349 FrontendOpts.ProgramAction = frontend::GeneratePCH; 1350 FrontendOpts.ChainedPCH = true; 1351 // FIXME: Generate the precompiled header into memory? 1352 FrontendOpts.OutputFile = PreamblePCHPath; 1353 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 1354 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 1355 1356 // Create the compiler instance to use for building the precompiled preamble. 1357 llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance()); 1358 1359 // Recover resources if we crash before exiting this method. 1360 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 1361 CICleanup(Clang.get()); 1362 1363 Clang->setInvocation(&*PreambleInvocation); 1364 OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second; 1365 1366 // Set up diagnostics, capturing all of the diagnostics produced. 1367 Clang->setDiagnostics(&getDiagnostics()); 1368 1369 // Create the target instance. 1370 Clang->getTargetOpts().Features = TargetFeatures; 1371 Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), 1372 Clang->getTargetOpts())); 1373 if (!Clang->hasTarget()) { 1374 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk(); 1375 Preamble.clear(); 1376 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1377 PreprocessorOpts.eraseRemappedFile( 1378 PreprocessorOpts.remapped_file_buffer_end() - 1); 1379 return 0; 1380 } 1381 1382 // Inform the target of the language options. 1383 // 1384 // FIXME: We shouldn't need to do this, the target should be immutable once 1385 // created. This complexity should be lifted elsewhere. 1386 Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); 1387 1388 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 1389 "Invocation must have exactly one source file!"); 1390 assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST && 1391 "FIXME: AST inputs not yet supported here!"); 1392 assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 1393 "IR inputs not support here!"); 1394 1395 // Clear out old caches and data. 1396 getDiagnostics().Reset(); 1397 ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts()); 1398 StoredDiagnostics.erase( 1399 StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver, 1400 StoredDiagnostics.end()); 1401 TopLevelDecls.clear(); 1402 TopLevelDeclsInPreamble.clear(); 1403 PreprocessedEntities.clear(); 1404 PreprocessedEntitiesInPreamble.clear(); 1405 1406 // Create a file manager object to provide access to and cache the filesystem. 1407 Clang->setFileManager(new FileManager(Clang->getFileSystemOpts())); 1408 1409 // Create the source manager. 1410 Clang->setSourceManager(new SourceManager(getDiagnostics(), 1411 Clang->getFileManager())); 1412 1413 llvm::OwningPtr<PrecompilePreambleAction> Act; 1414 Act.reset(new PrecompilePreambleAction(*this)); 1415 if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second, 1416 Clang->getFrontendOpts().Inputs[0].first)) { 1417 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk(); 1418 Preamble.clear(); 1419 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1420 PreprocessorOpts.eraseRemappedFile( 1421 PreprocessorOpts.remapped_file_buffer_end() - 1); 1422 return 0; 1423 } 1424 1425 Act->Execute(); 1426 Act->EndSourceFile(); 1427 1428 if (Diagnostics->hasErrorOccurred()) { 1429 // There were errors parsing the preamble, so no precompiled header was 1430 // generated. Forget that we even tried. 1431 // FIXME: Should we leave a note for ourselves to try again? 1432 llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk(); 1433 Preamble.clear(); 1434 TopLevelDeclsInPreamble.clear(); 1435 PreprocessedEntities.clear(); 1436 PreprocessedEntitiesInPreamble.clear(); 1437 PreambleRebuildCounter = DefaultPreambleRebuildInterval; 1438 PreprocessorOpts.eraseRemappedFile( 1439 PreprocessorOpts.remapped_file_buffer_end() - 1); 1440 return 0; 1441 } 1442 1443 // Keep track of the preamble we precompiled. 1444 PreambleFile = FrontendOpts.OutputFile; 1445 NumStoredDiagnosticsInPreamble = StoredDiagnostics.size(); 1446 NumWarningsInPreamble = getDiagnostics().getNumWarnings(); 1447 1448 // Keep track of all of the files that the source manager knows about, 1449 // so we can verify whether they have changed or not. 1450 FilesInPreamble.clear(); 1451 SourceManager &SourceMgr = Clang->getSourceManager(); 1452 const llvm::MemoryBuffer *MainFileBuffer 1453 = SourceMgr.getBuffer(SourceMgr.getMainFileID()); 1454 for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(), 1455 FEnd = SourceMgr.fileinfo_end(); 1456 F != FEnd; 1457 ++F) { 1458 const FileEntry *File = F->second->OrigEntry; 1459 if (!File || F->second->getRawBuffer() == MainFileBuffer) 1460 continue; 1461 1462 FilesInPreamble[File->getName()] 1463 = std::make_pair(F->second->getSize(), File->getModificationTime()); 1464 } 1465 1466 PreambleRebuildCounter = 1; 1467 PreprocessorOpts.eraseRemappedFile( 1468 PreprocessorOpts.remapped_file_buffer_end() - 1); 1469 1470 // If the hash of top-level entities differs from the hash of the top-level 1471 // entities the last time we rebuilt the preamble, clear out the completion 1472 // cache. 1473 if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) { 1474 CompletionCacheTopLevelHashValue = 0; 1475 PreambleTopLevelHashValue = CurrentTopLevelHashValue; 1476 } 1477 1478 return CreatePaddedMainFileBuffer(NewPreamble.first, 1479 PreambleReservedSize, 1480 FrontendOpts.Inputs[0].second); 1481} 1482 1483void ASTUnit::RealizeTopLevelDeclsFromPreamble() { 1484 std::vector<Decl *> Resolved; 1485 Resolved.reserve(TopLevelDeclsInPreamble.size()); 1486 ExternalASTSource &Source = *getASTContext().getExternalSource(); 1487 for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) { 1488 // Resolve the declaration ID to an actual declaration, possibly 1489 // deserializing the declaration in the process. 1490 Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]); 1491 if (D) 1492 Resolved.push_back(D); 1493 } 1494 TopLevelDeclsInPreamble.clear(); 1495 TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end()); 1496} 1497 1498void ASTUnit::RealizePreprocessedEntitiesFromPreamble() { 1499 if (!PP) 1500 return; 1501 1502 PreprocessingRecord *PPRec = PP->getPreprocessingRecord(); 1503 if (!PPRec) 1504 return; 1505 1506 ExternalPreprocessingRecordSource *External = PPRec->getExternalSource(); 1507 if (!External) 1508 return; 1509 1510 for (unsigned I = 0, N = PreprocessedEntitiesInPreamble.size(); I != N; ++I) { 1511 if (PreprocessedEntity *PE 1512 = External->ReadPreprocessedEntityAtOffset( 1513 PreprocessedEntitiesInPreamble[I])) 1514 PreprocessedEntities.push_back(PE); 1515 } 1516 1517 if (PreprocessedEntities.empty()) 1518 return; 1519 1520 PreprocessedEntities.insert(PreprocessedEntities.end(), 1521 PPRec->begin(true), PPRec->end(true)); 1522} 1523 1524ASTUnit::pp_entity_iterator ASTUnit::pp_entity_begin() { 1525 if (!PreprocessedEntitiesInPreamble.empty() && 1526 PreprocessedEntities.empty()) 1527 RealizePreprocessedEntitiesFromPreamble(); 1528 1529 if (PreprocessedEntities.empty()) 1530 if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord()) 1531 return PPRec->begin(true); 1532 1533 return PreprocessedEntities.begin(); 1534} 1535 1536ASTUnit::pp_entity_iterator ASTUnit::pp_entity_end() { 1537 if (!PreprocessedEntitiesInPreamble.empty() && 1538 PreprocessedEntities.empty()) 1539 RealizePreprocessedEntitiesFromPreamble(); 1540 1541 if (PreprocessedEntities.empty()) 1542 if (PreprocessingRecord *PPRec = PP->getPreprocessingRecord()) 1543 return PPRec->end(true); 1544 1545 return PreprocessedEntities.end(); 1546} 1547 1548unsigned ASTUnit::getMaxPCHLevel() const { 1549 if (!getOnlyLocalDecls()) 1550 return Decl::MaxPCHLevel; 1551 1552 return 0; 1553} 1554 1555llvm::StringRef ASTUnit::getMainFileName() const { 1556 return Invocation->getFrontendOpts().Inputs[0].second; 1557} 1558 1559ASTUnit *ASTUnit::create(CompilerInvocation *CI, 1560 llvm::IntrusiveRefCntPtr<Diagnostic> Diags) { 1561 llvm::OwningPtr<ASTUnit> AST; 1562 AST.reset(new ASTUnit(false)); 1563 ConfigureDiags(Diags, 0, 0, *AST, /*CaptureDiagnostics=*/false); 1564 AST->Diagnostics = Diags; 1565 AST->Invocation = CI; 1566 AST->FileSystemOpts = CI->getFileSystemOpts(); 1567 AST->FileMgr = new FileManager(AST->FileSystemOpts); 1568 AST->SourceMgr = new SourceManager(*Diags, *AST->FileMgr); 1569 1570 return AST.take(); 1571} 1572 1573ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(CompilerInvocation *CI, 1574 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 1575 ASTFrontendAction *Action) { 1576 assert(CI && "A CompilerInvocation is required"); 1577 1578 // Create the AST unit. 1579 llvm::OwningPtr<ASTUnit> AST; 1580 AST.reset(new ASTUnit(false)); 1581 ConfigureDiags(Diags, 0, 0, *AST, /*CaptureDiagnostics*/false); 1582 AST->Diagnostics = Diags; 1583 AST->OnlyLocalDecls = false; 1584 AST->CaptureDiagnostics = false; 1585 AST->CompleteTranslationUnit = Action ? Action->usesCompleteTranslationUnit() 1586 : true; 1587 AST->ShouldCacheCodeCompletionResults = false; 1588 AST->Invocation = CI; 1589 1590 // Recover resources if we crash before exiting this method. 1591 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 1592 ASTUnitCleanup(AST.get()); 1593 llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic, 1594 llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> > 1595 DiagCleanup(Diags.getPtr()); 1596 1597 // We'll manage file buffers ourselves. 1598 CI->getPreprocessorOpts().RetainRemappedFileBuffers = true; 1599 CI->getFrontendOpts().DisableFree = false; 1600 ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts()); 1601 1602 // Save the target features. 1603 AST->TargetFeatures = CI->getTargetOpts().Features; 1604 1605 // Create the compiler instance to use for building the AST. 1606 llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance()); 1607 1608 // Recover resources if we crash before exiting this method. 1609 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 1610 CICleanup(Clang.get()); 1611 1612 Clang->setInvocation(CI); 1613 AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second; 1614 1615 // Set up diagnostics, capturing any diagnostics that would 1616 // otherwise be dropped. 1617 Clang->setDiagnostics(&AST->getDiagnostics()); 1618 1619 // Create the target instance. 1620 Clang->getTargetOpts().Features = AST->TargetFeatures; 1621 Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), 1622 Clang->getTargetOpts())); 1623 if (!Clang->hasTarget()) 1624 return 0; 1625 1626 // Inform the target of the language options. 1627 // 1628 // FIXME: We shouldn't need to do this, the target should be immutable once 1629 // created. This complexity should be lifted elsewhere. 1630 Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); 1631 1632 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 1633 "Invocation must have exactly one source file!"); 1634 assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST && 1635 "FIXME: AST inputs not yet supported here!"); 1636 assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 1637 "IR inputs not supported here!"); 1638 1639 // Configure the various subsystems. 1640 AST->FileSystemOpts = Clang->getFileSystemOpts(); 1641 AST->FileMgr = new FileManager(AST->FileSystemOpts); 1642 AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr); 1643 AST->TheSema.reset(); 1644 AST->Ctx = 0; 1645 AST->PP = 0; 1646 1647 // Create a file manager object to provide access to and cache the filesystem. 1648 Clang->setFileManager(&AST->getFileManager()); 1649 1650 // Create the source manager. 1651 Clang->setSourceManager(&AST->getSourceManager()); 1652 1653 ASTFrontendAction *Act = Action; 1654 1655 llvm::OwningPtr<TopLevelDeclTrackerAction> TrackerAct; 1656 if (!Act) { 1657 TrackerAct.reset(new TopLevelDeclTrackerAction(*AST)); 1658 Act = TrackerAct.get(); 1659 } 1660 1661 // Recover resources if we crash before exiting this method. 1662 llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction> 1663 ActCleanup(TrackerAct.get()); 1664 1665 if (!Act->BeginSourceFile(*Clang.get(), 1666 Clang->getFrontendOpts().Inputs[0].second, 1667 Clang->getFrontendOpts().Inputs[0].first)) 1668 return 0; 1669 1670 Act->Execute(); 1671 1672 // Steal the created target, context, and preprocessor. 1673 AST->TheSema.reset(Clang->takeSema()); 1674 AST->Consumer.reset(Clang->takeASTConsumer()); 1675 AST->Ctx = &Clang->getASTContext(); 1676 AST->PP = &Clang->getPreprocessor(); 1677 Clang->setSourceManager(0); 1678 Clang->setFileManager(0); 1679 AST->Target = &Clang->getTarget(); 1680 1681 Act->EndSourceFile(); 1682 1683 return AST.take(); 1684} 1685 1686bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) { 1687 if (!Invocation) 1688 return true; 1689 1690 // We'll manage file buffers ourselves. 1691 Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true; 1692 Invocation->getFrontendOpts().DisableFree = false; 1693 ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); 1694 1695 // Save the target features. 1696 TargetFeatures = Invocation->getTargetOpts().Features; 1697 1698 llvm::MemoryBuffer *OverrideMainBuffer = 0; 1699 if (PrecompilePreamble) { 1700 PreambleRebuildCounter = 2; 1701 OverrideMainBuffer 1702 = getMainBufferWithPrecompiledPreamble(*Invocation); 1703 } 1704 1705 SimpleTimer ParsingTimer(WantTiming); 1706 ParsingTimer.setOutput("Parsing " + getMainFileName()); 1707 1708 // Recover resources if we crash before exiting this method. 1709 llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer> 1710 MemBufferCleanup(OverrideMainBuffer); 1711 1712 return Parse(OverrideMainBuffer); 1713} 1714 1715ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI, 1716 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 1717 bool OnlyLocalDecls, 1718 bool CaptureDiagnostics, 1719 bool PrecompilePreamble, 1720 bool CompleteTranslationUnit, 1721 bool CacheCodeCompletionResults, 1722 bool NestedMacroInstantiations) { 1723 // Create the AST unit. 1724 llvm::OwningPtr<ASTUnit> AST; 1725 AST.reset(new ASTUnit(false)); 1726 ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics); 1727 AST->Diagnostics = Diags; 1728 AST->OnlyLocalDecls = OnlyLocalDecls; 1729 AST->CaptureDiagnostics = CaptureDiagnostics; 1730 AST->CompleteTranslationUnit = CompleteTranslationUnit; 1731 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; 1732 AST->Invocation = CI; 1733 AST->NestedMacroInstantiations = NestedMacroInstantiations; 1734 1735 // Recover resources if we crash before exiting this method. 1736 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 1737 ASTUnitCleanup(AST.get()); 1738 llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic, 1739 llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> > 1740 DiagCleanup(Diags.getPtr()); 1741 1742 return AST->LoadFromCompilerInvocation(PrecompilePreamble)? 0 : AST.take(); 1743} 1744 1745ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin, 1746 const char **ArgEnd, 1747 llvm::IntrusiveRefCntPtr<Diagnostic> Diags, 1748 llvm::StringRef ResourceFilesPath, 1749 bool OnlyLocalDecls, 1750 bool CaptureDiagnostics, 1751 RemappedFile *RemappedFiles, 1752 unsigned NumRemappedFiles, 1753 bool RemappedFilesKeepOriginalName, 1754 bool PrecompilePreamble, 1755 bool CompleteTranslationUnit, 1756 bool CacheCodeCompletionResults, 1757 bool CXXPrecompilePreamble, 1758 bool CXXChainedPCH, 1759 bool NestedMacroInstantiations) { 1760 if (!Diags.getPtr()) { 1761 // No diagnostics engine was provided, so create our own diagnostics object 1762 // with the default options. 1763 DiagnosticOptions DiagOpts; 1764 Diags = CompilerInstance::createDiagnostics(DiagOpts, ArgEnd - ArgBegin, 1765 ArgBegin); 1766 } 1767 1768 llvm::SmallVector<StoredDiagnostic, 4> StoredDiagnostics; 1769 1770 llvm::IntrusiveRefCntPtr<CompilerInvocation> CI; 1771 1772 { 1773 CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags, 1774 StoredDiagnostics); 1775 1776 CI = clang::createInvocationFromCommandLine( 1777 llvm::ArrayRef<const char *>(ArgBegin, ArgEnd-ArgBegin), 1778 Diags); 1779 if (!CI) 1780 return 0; 1781 } 1782 1783 // Override any files that need remapping 1784 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 1785 FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; 1786 if (const llvm::MemoryBuffer * 1787 memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) { 1788 CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, memBuf); 1789 } else { 1790 const char *fname = fileOrBuf.get<const char *>(); 1791 CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, fname); 1792 } 1793 } 1794 CI->getPreprocessorOpts().RemappedFilesKeepOriginalName = 1795 RemappedFilesKeepOriginalName; 1796 1797 // Override the resources path. 1798 CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath; 1799 1800 // Check whether we should precompile the preamble and/or use chained PCH. 1801 // FIXME: This is a temporary hack while we debug C++ chained PCH. 1802 if (CI->getLangOpts().CPlusPlus) { 1803 PrecompilePreamble = PrecompilePreamble && CXXPrecompilePreamble; 1804 1805 if (PrecompilePreamble && !CXXChainedPCH && 1806 !CI->getPreprocessorOpts().ImplicitPCHInclude.empty()) 1807 PrecompilePreamble = false; 1808 } 1809 1810 // Create the AST unit. 1811 llvm::OwningPtr<ASTUnit> AST; 1812 AST.reset(new ASTUnit(false)); 1813 ConfigureDiags(Diags, ArgBegin, ArgEnd, *AST, CaptureDiagnostics); 1814 AST->Diagnostics = Diags; 1815 1816 AST->FileSystemOpts = CI->getFileSystemOpts(); 1817 AST->FileMgr = new FileManager(AST->FileSystemOpts); 1818 AST->OnlyLocalDecls = OnlyLocalDecls; 1819 AST->CaptureDiagnostics = CaptureDiagnostics; 1820 AST->CompleteTranslationUnit = CompleteTranslationUnit; 1821 AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; 1822 AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); 1823 AST->NumStoredDiagnosticsInPreamble = StoredDiagnostics.size(); 1824 AST->StoredDiagnostics.swap(StoredDiagnostics); 1825 AST->Invocation = CI; 1826 AST->NestedMacroInstantiations = NestedMacroInstantiations; 1827 1828 // Recover resources if we crash before exiting this method. 1829 llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> 1830 ASTUnitCleanup(AST.get()); 1831 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation, 1832 llvm::CrashRecoveryContextReleaseRefCleanup<CompilerInvocation> > 1833 CICleanup(CI.getPtr()); 1834 llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic, 1835 llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> > 1836 DiagCleanup(Diags.getPtr()); 1837 1838 return AST->LoadFromCompilerInvocation(PrecompilePreamble) ? 0 : AST.take(); 1839} 1840 1841bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) { 1842 if (!Invocation) 1843 return true; 1844 1845 SimpleTimer ParsingTimer(WantTiming); 1846 ParsingTimer.setOutput("Reparsing " + getMainFileName()); 1847 1848 // Remap files. 1849 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 1850 PPOpts.DisableStatCache = true; 1851 for (PreprocessorOptions::remapped_file_buffer_iterator 1852 R = PPOpts.remapped_file_buffer_begin(), 1853 REnd = PPOpts.remapped_file_buffer_end(); 1854 R != REnd; 1855 ++R) { 1856 delete R->second; 1857 } 1858 Invocation->getPreprocessorOpts().clearRemappedFiles(); 1859 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 1860 FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; 1861 if (const llvm::MemoryBuffer * 1862 memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) { 1863 Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, 1864 memBuf); 1865 } else { 1866 const char *fname = fileOrBuf.get<const char *>(); 1867 Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, 1868 fname); 1869 } 1870 } 1871 1872 // If we have a preamble file lying around, or if we might try to 1873 // build a precompiled preamble, do so now. 1874 llvm::MemoryBuffer *OverrideMainBuffer = 0; 1875 if (!PreambleFile.empty() || PreambleRebuildCounter > 0) 1876 OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation); 1877 1878 // Clear out the diagnostics state. 1879 if (!OverrideMainBuffer) { 1880 getDiagnostics().Reset(); 1881 ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts()); 1882 } 1883 1884 // Parse the sources 1885 bool Result = Parse(OverrideMainBuffer); 1886 1887 // If we're caching global code-completion results, and the top-level 1888 // declarations have changed, clear out the code-completion cache. 1889 if (!Result && ShouldCacheCodeCompletionResults && 1890 CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue) 1891 CacheCodeCompletionResults(); 1892 1893 return Result; 1894} 1895 1896//----------------------------------------------------------------------------// 1897// Code completion 1898//----------------------------------------------------------------------------// 1899 1900namespace { 1901 /// \brief Code completion consumer that combines the cached code-completion 1902 /// results from an ASTUnit with the code-completion results provided to it, 1903 /// then passes the result on to 1904 class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer { 1905 unsigned NormalContexts; 1906 ASTUnit &AST; 1907 CodeCompleteConsumer &Next; 1908 1909 public: 1910 AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next, 1911 bool IncludeMacros, bool IncludeCodePatterns, 1912 bool IncludeGlobals) 1913 : CodeCompleteConsumer(IncludeMacros, IncludeCodePatterns, IncludeGlobals, 1914 Next.isOutputBinary()), AST(AST), Next(Next) 1915 { 1916 // Compute the set of contexts in which we will look when we don't have 1917 // any information about the specific context. 1918 NormalContexts 1919 = (1 << (CodeCompletionContext::CCC_TopLevel - 1)) 1920 | (1 << (CodeCompletionContext::CCC_ObjCInterface - 1)) 1921 | (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1)) 1922 | (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1)) 1923 | (1 << (CodeCompletionContext::CCC_Statement - 1)) 1924 | (1 << (CodeCompletionContext::CCC_Expression - 1)) 1925 | (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1)) 1926 | (1 << (CodeCompletionContext::CCC_MemberAccess - 1)) 1927 | (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1)) 1928 | (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1)) 1929 | (1 << (CodeCompletionContext::CCC_Recovery - 1)); 1930 1931 if (AST.getASTContext().getLangOptions().CPlusPlus) 1932 NormalContexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1)) 1933 | (1 << (CodeCompletionContext::CCC_UnionTag - 1)) 1934 | (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1)); 1935 } 1936 1937 virtual void ProcessCodeCompleteResults(Sema &S, 1938 CodeCompletionContext Context, 1939 CodeCompletionResult *Results, 1940 unsigned NumResults); 1941 1942 virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 1943 OverloadCandidate *Candidates, 1944 unsigned NumCandidates) { 1945 Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates); 1946 } 1947 1948 virtual CodeCompletionAllocator &getAllocator() { 1949 return Next.getAllocator(); 1950 } 1951 }; 1952} 1953 1954/// \brief Helper function that computes which global names are hidden by the 1955/// local code-completion results. 1956static void CalculateHiddenNames(const CodeCompletionContext &Context, 1957 CodeCompletionResult *Results, 1958 unsigned NumResults, 1959 ASTContext &Ctx, 1960 llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){ 1961 bool OnlyTagNames = false; 1962 switch (Context.getKind()) { 1963 case CodeCompletionContext::CCC_Recovery: 1964 case CodeCompletionContext::CCC_TopLevel: 1965 case CodeCompletionContext::CCC_ObjCInterface: 1966 case CodeCompletionContext::CCC_ObjCImplementation: 1967 case CodeCompletionContext::CCC_ObjCIvarList: 1968 case CodeCompletionContext::CCC_ClassStructUnion: 1969 case CodeCompletionContext::CCC_Statement: 1970 case CodeCompletionContext::CCC_Expression: 1971 case CodeCompletionContext::CCC_ObjCMessageReceiver: 1972 case CodeCompletionContext::CCC_MemberAccess: 1973 case CodeCompletionContext::CCC_Namespace: 1974 case CodeCompletionContext::CCC_Type: 1975 case CodeCompletionContext::CCC_Name: 1976 case CodeCompletionContext::CCC_PotentiallyQualifiedName: 1977 case CodeCompletionContext::CCC_ParenthesizedExpression: 1978 break; 1979 1980 case CodeCompletionContext::CCC_EnumTag: 1981 case CodeCompletionContext::CCC_UnionTag: 1982 case CodeCompletionContext::CCC_ClassOrStructTag: 1983 OnlyTagNames = true; 1984 break; 1985 1986 case CodeCompletionContext::CCC_ObjCProtocolName: 1987 case CodeCompletionContext::CCC_MacroName: 1988 case CodeCompletionContext::CCC_MacroNameUse: 1989 case CodeCompletionContext::CCC_PreprocessorExpression: 1990 case CodeCompletionContext::CCC_PreprocessorDirective: 1991 case CodeCompletionContext::CCC_NaturalLanguage: 1992 case CodeCompletionContext::CCC_SelectorName: 1993 case CodeCompletionContext::CCC_TypeQualifiers: 1994 case CodeCompletionContext::CCC_Other: 1995 case CodeCompletionContext::CCC_OtherWithMacros: 1996 // We're looking for nothing, or we're looking for names that cannot 1997 // be hidden. 1998 return; 1999 } 2000 2001 typedef CodeCompletionResult Result; 2002 for (unsigned I = 0; I != NumResults; ++I) { 2003 if (Results[I].Kind != Result::RK_Declaration) 2004 continue; 2005 2006 unsigned IDNS 2007 = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace(); 2008 2009 bool Hiding = false; 2010 if (OnlyTagNames) 2011 Hiding = (IDNS & Decl::IDNS_Tag); 2012 else { 2013 unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member | 2014 Decl::IDNS_Namespace | Decl::IDNS_Ordinary | 2015 Decl::IDNS_NonMemberOperator); 2016 if (Ctx.getLangOptions().CPlusPlus) 2017 HiddenIDNS |= Decl::IDNS_Tag; 2018 Hiding = (IDNS & HiddenIDNS); 2019 } 2020 2021 if (!Hiding) 2022 continue; 2023 2024 DeclarationName Name = Results[I].Declaration->getDeclName(); 2025 if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo()) 2026 HiddenNames.insert(Identifier->getName()); 2027 else 2028 HiddenNames.insert(Name.getAsString()); 2029 } 2030} 2031 2032 2033void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S, 2034 CodeCompletionContext Context, 2035 CodeCompletionResult *Results, 2036 unsigned NumResults) { 2037 // Merge the results we were given with the results we cached. 2038 bool AddedResult = false; 2039 unsigned InContexts 2040 = (Context.getKind() == CodeCompletionContext::CCC_Recovery? NormalContexts 2041 : (1 << (Context.getKind() - 1))); 2042 2043 // Contains the set of names that are hidden by "local" completion results. 2044 llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames; 2045 typedef CodeCompletionResult Result; 2046 llvm::SmallVector<Result, 8> AllResults; 2047 for (ASTUnit::cached_completion_iterator 2048 C = AST.cached_completion_begin(), 2049 CEnd = AST.cached_completion_end(); 2050 C != CEnd; ++C) { 2051 // If the context we are in matches any of the contexts we are 2052 // interested in, we'll add this result. 2053 if ((C->ShowInContexts & InContexts) == 0) 2054 continue; 2055 2056 // If we haven't added any results previously, do so now. 2057 if (!AddedResult) { 2058 CalculateHiddenNames(Context, Results, NumResults, S.Context, 2059 HiddenNames); 2060 AllResults.insert(AllResults.end(), Results, Results + NumResults); 2061 AddedResult = true; 2062 } 2063 2064 // Determine whether this global completion result is hidden by a local 2065 // completion result. If so, skip it. 2066 if (C->Kind != CXCursor_MacroDefinition && 2067 HiddenNames.count(C->Completion->getTypedText())) 2068 continue; 2069 2070 // Adjust priority based on similar type classes. 2071 unsigned Priority = C->Priority; 2072 CXCursorKind CursorKind = C->Kind; 2073 CodeCompletionString *Completion = C->Completion; 2074 if (!Context.getPreferredType().isNull()) { 2075 if (C->Kind == CXCursor_MacroDefinition) { 2076 Priority = getMacroUsagePriority(C->Completion->getTypedText(), 2077 S.getLangOptions(), 2078 Context.getPreferredType()->isAnyPointerType()); 2079 } else if (C->Type) { 2080 CanQualType Expected 2081 = S.Context.getCanonicalType( 2082 Context.getPreferredType().getUnqualifiedType()); 2083 SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected); 2084 if (ExpectedSTC == C->TypeClass) { 2085 // We know this type is similar; check for an exact match. 2086 llvm::StringMap<unsigned> &CachedCompletionTypes 2087 = AST.getCachedCompletionTypes(); 2088 llvm::StringMap<unsigned>::iterator Pos 2089 = CachedCompletionTypes.find(QualType(Expected).getAsString()); 2090 if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type) 2091 Priority /= CCF_ExactTypeMatch; 2092 else 2093 Priority /= CCF_SimilarTypeMatch; 2094 } 2095 } 2096 } 2097 2098 // Adjust the completion string, if required. 2099 if (C->Kind == CXCursor_MacroDefinition && 2100 Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) { 2101 // Create a new code-completion string that just contains the 2102 // macro name, without its arguments. 2103 CodeCompletionBuilder Builder(getAllocator(), CCP_CodePattern, 2104 C->Availability); 2105 Builder.AddTypedTextChunk(C->Completion->getTypedText()); 2106 CursorKind = CXCursor_NotImplemented; 2107 Priority = CCP_CodePattern; 2108 Completion = Builder.TakeString(); 2109 } 2110 2111 AllResults.push_back(Result(Completion, Priority, CursorKind, 2112 C->Availability)); 2113 } 2114 2115 // If we did not add any cached completion results, just forward the 2116 // results we were given to the next consumer. 2117 if (!AddedResult) { 2118 Next.ProcessCodeCompleteResults(S, Context, Results, NumResults); 2119 return; 2120 } 2121 2122 Next.ProcessCodeCompleteResults(S, Context, AllResults.data(), 2123 AllResults.size()); 2124} 2125 2126 2127 2128void ASTUnit::CodeComplete(llvm::StringRef File, unsigned Line, unsigned Column, 2129 RemappedFile *RemappedFiles, 2130 unsigned NumRemappedFiles, 2131 bool IncludeMacros, 2132 bool IncludeCodePatterns, 2133 CodeCompleteConsumer &Consumer, 2134 Diagnostic &Diag, LangOptions &LangOpts, 2135 SourceManager &SourceMgr, FileManager &FileMgr, 2136 llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics, 2137 llvm::SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) { 2138 if (!Invocation) 2139 return; 2140 2141 SimpleTimer CompletionTimer(WantTiming); 2142 CompletionTimer.setOutput("Code completion @ " + File + ":" + 2143 llvm::Twine(Line) + ":" + llvm::Twine(Column)); 2144 2145 llvm::IntrusiveRefCntPtr<CompilerInvocation> 2146 CCInvocation(new CompilerInvocation(*Invocation)); 2147 2148 FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts(); 2149 PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts(); 2150 2151 FrontendOpts.ShowMacrosInCodeCompletion 2152 = IncludeMacros && CachedCompletionResults.empty(); 2153 FrontendOpts.ShowCodePatternsInCodeCompletion = IncludeCodePatterns; 2154 FrontendOpts.ShowGlobalSymbolsInCodeCompletion 2155 = CachedCompletionResults.empty(); 2156 FrontendOpts.CodeCompletionAt.FileName = File; 2157 FrontendOpts.CodeCompletionAt.Line = Line; 2158 FrontendOpts.CodeCompletionAt.Column = Column; 2159 2160 // Set the language options appropriately. 2161 LangOpts = CCInvocation->getLangOpts(); 2162 2163 llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance()); 2164 2165 // Recover resources if we crash before exiting this method. 2166 llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> 2167 CICleanup(Clang.get()); 2168 2169 Clang->setInvocation(&*CCInvocation); 2170 OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second; 2171 2172 // Set up diagnostics, capturing any diagnostics produced. 2173 Clang->setDiagnostics(&Diag); 2174 ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts()); 2175 CaptureDroppedDiagnostics Capture(true, 2176 Clang->getDiagnostics(), 2177 StoredDiagnostics); 2178 2179 // Create the target instance. 2180 Clang->getTargetOpts().Features = TargetFeatures; 2181 Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(), 2182 Clang->getTargetOpts())); 2183 if (!Clang->hasTarget()) { 2184 Clang->setInvocation(0); 2185 return; 2186 } 2187 2188 // Inform the target of the language options. 2189 // 2190 // FIXME: We shouldn't need to do this, the target should be immutable once 2191 // created. This complexity should be lifted elsewhere. 2192 Clang->getTarget().setForcedLangOptions(Clang->getLangOpts()); 2193 2194 assert(Clang->getFrontendOpts().Inputs.size() == 1 && 2195 "Invocation must have exactly one source file!"); 2196 assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST && 2197 "FIXME: AST inputs not yet supported here!"); 2198 assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR && 2199 "IR inputs not support here!"); 2200 2201 2202 // Use the source and file managers that we were given. 2203 Clang->setFileManager(&FileMgr); 2204 Clang->setSourceManager(&SourceMgr); 2205 2206 // Remap files. 2207 PreprocessorOpts.clearRemappedFiles(); 2208 PreprocessorOpts.RetainRemappedFileBuffers = true; 2209 for (unsigned I = 0; I != NumRemappedFiles; ++I) { 2210 FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second; 2211 if (const llvm::MemoryBuffer * 2212 memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) { 2213 PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, memBuf); 2214 OwnedBuffers.push_back(memBuf); 2215 } else { 2216 const char *fname = fileOrBuf.get<const char *>(); 2217 PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, fname); 2218 } 2219 } 2220 2221 // Use the code completion consumer we were given, but adding any cached 2222 // code-completion results. 2223 AugmentedCodeCompleteConsumer *AugmentedConsumer 2224 = new AugmentedCodeCompleteConsumer(*this, Consumer, 2225 FrontendOpts.ShowMacrosInCodeCompletion, 2226 FrontendOpts.ShowCodePatternsInCodeCompletion, 2227 FrontendOpts.ShowGlobalSymbolsInCodeCompletion); 2228 Clang->setCodeCompletionConsumer(AugmentedConsumer); 2229 2230 // If we have a precompiled preamble, try to use it. We only allow 2231 // the use of the precompiled preamble if we're if the completion 2232 // point is within the main file, after the end of the precompiled 2233 // preamble. 2234 llvm::MemoryBuffer *OverrideMainBuffer = 0; 2235 if (!PreambleFile.empty()) { 2236 using llvm::sys::FileStatus; 2237 llvm::sys::PathWithStatus CompleteFilePath(File); 2238 llvm::sys::PathWithStatus MainPath(OriginalSourceFile); 2239 if (const FileStatus *CompleteFileStatus = CompleteFilePath.getFileStatus()) 2240 if (const FileStatus *MainStatus = MainPath.getFileStatus()) 2241 if (CompleteFileStatus->getUniqueID() == MainStatus->getUniqueID()) 2242 OverrideMainBuffer 2243 = getMainBufferWithPrecompiledPreamble(*CCInvocation, false, 2244 Line - 1); 2245 } 2246 2247 // If the main file has been overridden due to the use of a preamble, 2248 // make that override happen and introduce the preamble. 2249 PreprocessorOpts.DisableStatCache = true; 2250 StoredDiagnostics.insert(StoredDiagnostics.end(), 2251 this->StoredDiagnostics.begin(), 2252 this->StoredDiagnostics.begin() + NumStoredDiagnosticsFromDriver); 2253 if (OverrideMainBuffer) { 2254 PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer); 2255 PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size(); 2256 PreprocessorOpts.PrecompiledPreambleBytes.second 2257 = PreambleEndsAtStartOfLine; 2258 PreprocessorOpts.ImplicitPCHInclude = PreambleFile; 2259 PreprocessorOpts.DisablePCHValidation = true; 2260 2261 // The stored diagnostics have the old source manager. Copy them 2262 // to our output set of stored diagnostics, updating the source 2263 // manager to the one we were given. 2264 for (unsigned I = NumStoredDiagnosticsFromDriver, 2265 N = this->StoredDiagnostics.size(); 2266 I < N; ++I) { 2267 StoredDiagnostics.push_back(this->StoredDiagnostics[I]); 2268 FullSourceLoc Loc(StoredDiagnostics[I].getLocation(), SourceMgr); 2269 StoredDiagnostics[I].setLocation(Loc); 2270 } 2271 2272 OwnedBuffers.push_back(OverrideMainBuffer); 2273 } else { 2274 PreprocessorOpts.PrecompiledPreambleBytes.first = 0; 2275 PreprocessorOpts.PrecompiledPreambleBytes.second = false; 2276 } 2277 2278 // Disable the preprocessing record 2279 PreprocessorOpts.DetailedRecord = false; 2280 2281 llvm::OwningPtr<SyntaxOnlyAction> Act; 2282 Act.reset(new SyntaxOnlyAction); 2283 if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second, 2284 Clang->getFrontendOpts().Inputs[0].first)) { 2285 Act->Execute(); 2286 Act->EndSourceFile(); 2287 } 2288} 2289 2290CXSaveError ASTUnit::Save(llvm::StringRef File) { 2291 if (getDiagnostics().hasErrorOccurred()) 2292 return CXSaveError_TranslationErrors; 2293 2294 // FIXME: Can we somehow regenerate the stat cache here, or do we need to 2295 // unconditionally create a stat cache when we parse the file? 2296 std::string ErrorInfo; 2297 llvm::raw_fd_ostream Out(File.str().c_str(), ErrorInfo, 2298 llvm::raw_fd_ostream::F_Binary); 2299 if (!ErrorInfo.empty() || Out.has_error()) 2300 return CXSaveError_Unknown; 2301 2302 serialize(Out); 2303 Out.close(); 2304 return Out.has_error()? CXSaveError_Unknown : CXSaveError_None; 2305} 2306 2307bool ASTUnit::serialize(llvm::raw_ostream &OS) { 2308 if (getDiagnostics().hasErrorOccurred()) 2309 return true; 2310 2311 std::vector<unsigned char> Buffer; 2312 llvm::BitstreamWriter Stream(Buffer); 2313 ASTWriter Writer(Stream); 2314 Writer.WriteAST(getSema(), 0, std::string(), 0); 2315 2316 // Write the generated bitstream to "Out". 2317 if (!Buffer.empty()) 2318 OS.write((char *)&Buffer.front(), Buffer.size()); 2319 2320 return false; 2321} 2322