1 //===--- CompilerInstance.cpp ---------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "clang/Frontend/CompilerInstance.h" 11 #include "clang/AST/ASTConsumer.h" 12 #include "clang/AST/ASTContext.h" 13 #include "clang/AST/Decl.h" 14 #include "clang/Basic/Diagnostic.h" 15 #include "clang/Basic/FileManager.h" 16 #include "clang/Basic/SourceManager.h" 17 #include "clang/Basic/TargetInfo.h" 18 #include "clang/Basic/Version.h" 19 #include "clang/Frontend/ChainedDiagnosticConsumer.h" 20 #include "clang/Frontend/FrontendAction.h" 21 #include "clang/Frontend/FrontendActions.h" 22 #include "clang/Frontend/FrontendDiagnostic.h" 23 #include "clang/Frontend/LogDiagnosticPrinter.h" 24 #include "clang/Frontend/SerializedDiagnosticPrinter.h" 25 #include "clang/Frontend/TextDiagnosticPrinter.h" 26 #include "clang/Frontend/Utils.h" 27 #include "clang/Frontend/VerifyDiagnosticConsumer.h" 28 #include "clang/Lex/HeaderSearch.h" 29 #include "clang/Lex/PTHManager.h" 30 #include "clang/Lex/Preprocessor.h" 31 #include "clang/Sema/CodeCompleteConsumer.h" 32 #include "clang/Sema/Sema.h" 33 #include "clang/Serialization/ASTReader.h" 34 #include "llvm/ADT/Statistic.h" 35 #include "llvm/Config/config.h" 36 #include "llvm/Support/CrashRecoveryContext.h" 37 #include "llvm/Support/FileSystem.h" 38 #include "llvm/Support/Host.h" 39 #include "llvm/Support/LockFileManager.h" 40 #include "llvm/Support/MemoryBuffer.h" 41 #include "llvm/Support/Path.h" 42 #include "llvm/Support/Program.h" 43 #include "llvm/Support/Signals.h" 44 #include "llvm/Support/Timer.h" 45 #include "llvm/Support/raw_ostream.h" 46 #include "llvm/Support/system_error.h" 47 48 using namespace clang; 49 50 CompilerInstance::CompilerInstance() 51 : Invocation(new CompilerInvocation()), ModuleManager(0), 52 BuildGlobalModuleIndex(false), ModuleBuildFailed(false) { 53 } 54 55 CompilerInstance::~CompilerInstance() { 56 assert(OutputFiles.empty() && "Still output files in flight?"); 57 } 58 59 void CompilerInstance::setInvocation(CompilerInvocation *Value) { 60 Invocation = Value; 61 } 62 63 bool CompilerInstance::shouldBuildGlobalModuleIndex() const { 64 return (BuildGlobalModuleIndex || 65 (ModuleManager && ModuleManager->isGlobalIndexUnavailable())) && 66 !ModuleBuildFailed; 67 } 68 69 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) { 70 Diagnostics = Value; 71 } 72 73 void CompilerInstance::setTarget(TargetInfo *Value) { 74 Target = Value; 75 } 76 77 void CompilerInstance::setFileManager(FileManager *Value) { 78 FileMgr = Value; 79 } 80 81 void CompilerInstance::setSourceManager(SourceManager *Value) { 82 SourceMgr = Value; 83 } 84 85 void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; } 86 87 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; } 88 89 void CompilerInstance::setSema(Sema *S) { 90 TheSema.reset(S); 91 } 92 93 void CompilerInstance::setASTConsumer(ASTConsumer *Value) { 94 Consumer.reset(Value); 95 } 96 97 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) { 98 CompletionConsumer.reset(Value); 99 } 100 101 // Diagnostics 102 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, 103 const CodeGenOptions *CodeGenOpts, 104 DiagnosticsEngine &Diags) { 105 std::string ErrorInfo; 106 bool OwnsStream = false; 107 raw_ostream *OS = &llvm::errs(); 108 if (DiagOpts->DiagnosticLogFile != "-") { 109 // Create the output stream. 110 llvm::raw_fd_ostream *FileOS( 111 new llvm::raw_fd_ostream(DiagOpts->DiagnosticLogFile.c_str(), 112 ErrorInfo, llvm::raw_fd_ostream::F_Append)); 113 if (!ErrorInfo.empty()) { 114 Diags.Report(diag::warn_fe_cc_log_diagnostics_failure) 115 << DiagOpts->DiagnosticLogFile << ErrorInfo; 116 } else { 117 FileOS->SetUnbuffered(); 118 FileOS->SetUseAtomicWrites(true); 119 OS = FileOS; 120 OwnsStream = true; 121 } 122 } 123 124 // Chain in the diagnostic client which will log the diagnostics. 125 LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts, 126 OwnsStream); 127 if (CodeGenOpts) 128 Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags); 129 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger)); 130 } 131 132 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, 133 DiagnosticsEngine &Diags, 134 StringRef OutputFile) { 135 std::string ErrorInfo; 136 OwningPtr<llvm::raw_fd_ostream> OS; 137 OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo, 138 llvm::raw_fd_ostream::F_Binary)); 139 140 if (!ErrorInfo.empty()) { 141 Diags.Report(diag::warn_fe_serialized_diag_failure) 142 << OutputFile << ErrorInfo; 143 return; 144 } 145 146 DiagnosticConsumer *SerializedConsumer = 147 clang::serialized_diags::create(OS.take(), DiagOpts); 148 149 150 Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), 151 SerializedConsumer)); 152 } 153 154 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client, 155 bool ShouldOwnClient, 156 bool ShouldCloneClient) { 157 Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client, 158 ShouldOwnClient, ShouldCloneClient, 159 &getCodeGenOpts()); 160 } 161 162 IntrusiveRefCntPtr<DiagnosticsEngine> 163 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts, 164 DiagnosticConsumer *Client, 165 bool ShouldOwnClient, 166 bool ShouldCloneClient, 167 const CodeGenOptions *CodeGenOpts) { 168 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 169 IntrusiveRefCntPtr<DiagnosticsEngine> 170 Diags(new DiagnosticsEngine(DiagID, Opts)); 171 172 // Create the diagnostic client for reporting errors or for 173 // implementing -verify. 174 if (Client) { 175 if (ShouldCloneClient) 176 Diags->setClient(Client->clone(*Diags), ShouldOwnClient); 177 else 178 Diags->setClient(Client, ShouldOwnClient); 179 } else 180 Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts)); 181 182 // Chain in -verify checker, if requested. 183 if (Opts->VerifyDiagnostics) 184 Diags->setClient(new VerifyDiagnosticConsumer(*Diags)); 185 186 // Chain in -diagnostic-log-file dumper, if requested. 187 if (!Opts->DiagnosticLogFile.empty()) 188 SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags); 189 190 if (!Opts->DiagnosticSerializationFile.empty()) 191 SetupSerializedDiagnostics(Opts, *Diags, 192 Opts->DiagnosticSerializationFile); 193 194 // Configure our handling of diagnostics. 195 ProcessWarningOptions(*Diags, *Opts); 196 197 return Diags; 198 } 199 200 // File Manager 201 202 void CompilerInstance::createFileManager() { 203 FileMgr = new FileManager(getFileSystemOpts()); 204 } 205 206 // Source Manager 207 208 void CompilerInstance::createSourceManager(FileManager &FileMgr) { 209 SourceMgr = new SourceManager(getDiagnostics(), FileMgr); 210 } 211 212 // Preprocessor 213 214 void CompilerInstance::createPreprocessor() { 215 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 216 217 // Create a PTH manager if we are using some form of a token cache. 218 PTHManager *PTHMgr = 0; 219 if (!PPOpts.TokenCache.empty()) 220 PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics()); 221 222 // Create the Preprocessor. 223 HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(), 224 getFileManager(), 225 getDiagnostics(), 226 getLangOpts(), 227 &getTarget()); 228 PP = new Preprocessor(&getPreprocessorOpts(), 229 getDiagnostics(), getLangOpts(), &getTarget(), 230 getSourceManager(), *HeaderInfo, *this, PTHMgr, 231 /*OwnsHeaderSearch=*/true); 232 233 // Note that this is different then passing PTHMgr to Preprocessor's ctor. 234 // That argument is used as the IdentifierInfoLookup argument to 235 // IdentifierTable's ctor. 236 if (PTHMgr) { 237 PTHMgr->setPreprocessor(&*PP); 238 PP->setPTHManager(PTHMgr); 239 } 240 241 if (PPOpts.DetailedRecord) 242 PP->createPreprocessingRecord(); 243 244 InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts()); 245 246 // Set up the module path, including the hash for the 247 // module-creation options. 248 SmallString<256> SpecificModuleCache( 249 getHeaderSearchOpts().ModuleCachePath); 250 if (!getHeaderSearchOpts().DisableModuleHash) 251 llvm::sys::path::append(SpecificModuleCache, 252 getInvocation().getModuleHash()); 253 PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache); 254 255 // Handle generating dependencies, if requested. 256 const DependencyOutputOptions &DepOpts = getDependencyOutputOpts(); 257 if (!DepOpts.OutputFile.empty()) 258 AttachDependencyFileGen(*PP, DepOpts); 259 if (!DepOpts.DOTOutputFile.empty()) 260 AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile, 261 getHeaderSearchOpts().Sysroot); 262 263 264 // Handle generating header include information, if requested. 265 if (DepOpts.ShowHeaderIncludes) 266 AttachHeaderIncludeGen(*PP); 267 if (!DepOpts.HeaderIncludeOutputFile.empty()) { 268 StringRef OutputPath = DepOpts.HeaderIncludeOutputFile; 269 if (OutputPath == "-") 270 OutputPath = ""; 271 AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath, 272 /*ShowDepth=*/false); 273 } 274 } 275 276 // ASTContext 277 278 void CompilerInstance::createASTContext() { 279 Preprocessor &PP = getPreprocessor(); 280 Context = new ASTContext(getLangOpts(), PP.getSourceManager(), 281 &getTarget(), PP.getIdentifierTable(), 282 PP.getSelectorTable(), PP.getBuiltinInfo(), 283 /*size_reserve=*/ 0); 284 } 285 286 // ExternalASTSource 287 288 void CompilerInstance::createPCHExternalASTSource(StringRef Path, 289 bool DisablePCHValidation, 290 bool AllowPCHWithCompilerErrors, 291 void *DeserializationListener){ 292 OwningPtr<ExternalASTSource> Source; 293 bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0; 294 Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot, 295 DisablePCHValidation, 296 AllowPCHWithCompilerErrors, 297 getPreprocessor(), getASTContext(), 298 DeserializationListener, 299 Preamble, 300 getFrontendOpts().UseGlobalModuleIndex)); 301 ModuleManager = static_cast<ASTReader*>(Source.get()); 302 getASTContext().setExternalSource(Source); 303 } 304 305 ExternalASTSource * 306 CompilerInstance::createPCHExternalASTSource(StringRef Path, 307 const std::string &Sysroot, 308 bool DisablePCHValidation, 309 bool AllowPCHWithCompilerErrors, 310 Preprocessor &PP, 311 ASTContext &Context, 312 void *DeserializationListener, 313 bool Preamble, 314 bool UseGlobalModuleIndex) { 315 OwningPtr<ASTReader> Reader; 316 Reader.reset(new ASTReader(PP, Context, 317 Sysroot.empty() ? "" : Sysroot.c_str(), 318 DisablePCHValidation, 319 AllowPCHWithCompilerErrors, 320 UseGlobalModuleIndex)); 321 322 Reader->setDeserializationListener( 323 static_cast<ASTDeserializationListener *>(DeserializationListener)); 324 switch (Reader->ReadAST(Path, 325 Preamble ? serialization::MK_Preamble 326 : serialization::MK_PCH, 327 SourceLocation(), 328 ASTReader::ARR_None)) { 329 case ASTReader::Success: 330 // Set the predefines buffer as suggested by the PCH reader. Typically, the 331 // predefines buffer will be empty. 332 PP.setPredefines(Reader->getSuggestedPredefines()); 333 return Reader.take(); 334 335 case ASTReader::Failure: 336 // Unrecoverable failure: don't even try to process the input file. 337 break; 338 339 case ASTReader::OutOfDate: 340 case ASTReader::VersionMismatch: 341 case ASTReader::ConfigurationMismatch: 342 case ASTReader::HadErrors: 343 // No suitable PCH file could be found. Return an error. 344 break; 345 } 346 347 return 0; 348 } 349 350 // Code Completion 351 352 static bool EnableCodeCompletion(Preprocessor &PP, 353 const std::string &Filename, 354 unsigned Line, 355 unsigned Column) { 356 // Tell the source manager to chop off the given file at a specific 357 // line and column. 358 const FileEntry *Entry = PP.getFileManager().getFile(Filename); 359 if (!Entry) { 360 PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file) 361 << Filename; 362 return true; 363 } 364 365 // Truncate the named file at the given line/column. 366 PP.SetCodeCompletionPoint(Entry, Line, Column); 367 return false; 368 } 369 370 void CompilerInstance::createCodeCompletionConsumer() { 371 const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt; 372 if (!CompletionConsumer) { 373 setCodeCompletionConsumer( 374 createCodeCompletionConsumer(getPreprocessor(), 375 Loc.FileName, Loc.Line, Loc.Column, 376 getFrontendOpts().CodeCompleteOpts, 377 llvm::outs())); 378 if (!CompletionConsumer) 379 return; 380 } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName, 381 Loc.Line, Loc.Column)) { 382 setCodeCompletionConsumer(0); 383 return; 384 } 385 386 if (CompletionConsumer->isOutputBinary() && 387 llvm::sys::Program::ChangeStdoutToBinary()) { 388 getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); 389 setCodeCompletionConsumer(0); 390 } 391 } 392 393 void CompilerInstance::createFrontendTimer() { 394 FrontendTimer.reset(new llvm::Timer("Clang front-end timer")); 395 } 396 397 CodeCompleteConsumer * 398 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, 399 const std::string &Filename, 400 unsigned Line, 401 unsigned Column, 402 const CodeCompleteOptions &Opts, 403 raw_ostream &OS) { 404 if (EnableCodeCompletion(PP, Filename, Line, Column)) 405 return 0; 406 407 // Set up the creation routine for code-completion. 408 return new PrintingCodeCompleteConsumer(Opts, OS); 409 } 410 411 void CompilerInstance::createSema(TranslationUnitKind TUKind, 412 CodeCompleteConsumer *CompletionConsumer) { 413 TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), 414 TUKind, CompletionConsumer)); 415 } 416 417 // Output Files 418 419 void CompilerInstance::addOutputFile(const OutputFile &OutFile) { 420 assert(OutFile.OS && "Attempt to add empty stream to output list!"); 421 OutputFiles.push_back(OutFile); 422 } 423 424 void CompilerInstance::clearOutputFiles(bool EraseFiles) { 425 for (std::list<OutputFile>::iterator 426 it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) { 427 delete it->OS; 428 if (!it->TempFilename.empty()) { 429 if (EraseFiles) { 430 bool existed; 431 llvm::sys::fs::remove(it->TempFilename, existed); 432 } else { 433 SmallString<128> NewOutFile(it->Filename); 434 435 // If '-working-directory' was passed, the output filename should be 436 // relative to that. 437 FileMgr->FixupRelativePath(NewOutFile); 438 if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename, 439 NewOutFile.str())) { 440 getDiagnostics().Report(diag::err_unable_to_rename_temp) 441 << it->TempFilename << it->Filename << ec.message(); 442 443 bool existed; 444 llvm::sys::fs::remove(it->TempFilename, existed); 445 } 446 } 447 } else if (!it->Filename.empty() && EraseFiles) 448 llvm::sys::Path(it->Filename).eraseFromDisk(); 449 450 } 451 OutputFiles.clear(); 452 } 453 454 llvm::raw_fd_ostream * 455 CompilerInstance::createDefaultOutputFile(bool Binary, 456 StringRef InFile, 457 StringRef Extension) { 458 return createOutputFile(getFrontendOpts().OutputFile, Binary, 459 /*RemoveFileOnSignal=*/true, InFile, Extension, 460 /*UseTemporary=*/true); 461 } 462 463 llvm::raw_fd_ostream * 464 CompilerInstance::createOutputFile(StringRef OutputPath, 465 bool Binary, bool RemoveFileOnSignal, 466 StringRef InFile, 467 StringRef Extension, 468 bool UseTemporary, 469 bool CreateMissingDirectories) { 470 std::string Error, OutputPathName, TempPathName; 471 llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary, 472 RemoveFileOnSignal, 473 InFile, Extension, 474 UseTemporary, 475 CreateMissingDirectories, 476 &OutputPathName, 477 &TempPathName); 478 if (!OS) { 479 getDiagnostics().Report(diag::err_fe_unable_to_open_output) 480 << OutputPath << Error; 481 return 0; 482 } 483 484 // Add the output file -- but don't try to remove "-", since this means we are 485 // using stdin. 486 addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "", 487 TempPathName, OS)); 488 489 return OS; 490 } 491 492 llvm::raw_fd_ostream * 493 CompilerInstance::createOutputFile(StringRef OutputPath, 494 std::string &Error, 495 bool Binary, 496 bool RemoveFileOnSignal, 497 StringRef InFile, 498 StringRef Extension, 499 bool UseTemporary, 500 bool CreateMissingDirectories, 501 std::string *ResultPathName, 502 std::string *TempPathName) { 503 assert((!CreateMissingDirectories || UseTemporary) && 504 "CreateMissingDirectories is only allowed when using temporary files"); 505 506 std::string OutFile, TempFile; 507 if (!OutputPath.empty()) { 508 OutFile = OutputPath; 509 } else if (InFile == "-") { 510 OutFile = "-"; 511 } else if (!Extension.empty()) { 512 llvm::sys::Path Path(InFile); 513 Path.eraseSuffix(); 514 Path.appendSuffix(Extension); 515 OutFile = Path.str(); 516 } else { 517 OutFile = "-"; 518 } 519 520 OwningPtr<llvm::raw_fd_ostream> OS; 521 std::string OSFile; 522 523 if (UseTemporary && OutFile != "-") { 524 // Only create the temporary if the parent directory exists (or create 525 // missing directories is true) and we can actually write to OutPath, 526 // otherwise we want to fail early. 527 SmallString<256> AbsPath(OutputPath); 528 llvm::sys::fs::make_absolute(AbsPath); 529 llvm::sys::Path OutPath(AbsPath); 530 bool ParentExists = false; 531 if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()), 532 ParentExists)) 533 ParentExists = false; 534 bool Exists; 535 if ((CreateMissingDirectories || ParentExists) && 536 ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) || 537 (OutPath.isRegularFile() && OutPath.canWrite()))) { 538 // Create a temporary file. 539 SmallString<128> TempPath; 540 TempPath = OutFile; 541 TempPath += "-%%%%%%%%"; 542 int fd; 543 if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath, 544 /*makeAbsolute=*/false, 0664) 545 == llvm::errc::success) { 546 OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); 547 OSFile = TempFile = TempPath.str(); 548 } 549 } 550 } 551 552 if (!OS) { 553 OSFile = OutFile; 554 OS.reset( 555 new llvm::raw_fd_ostream(OSFile.c_str(), Error, 556 (Binary ? llvm::raw_fd_ostream::F_Binary : 0))); 557 if (!Error.empty()) 558 return 0; 559 } 560 561 // Make sure the out stream file gets removed if we crash. 562 if (RemoveFileOnSignal) 563 llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile)); 564 565 if (ResultPathName) 566 *ResultPathName = OutFile; 567 if (TempPathName) 568 *TempPathName = TempFile; 569 570 return OS.take(); 571 } 572 573 // Initialization Utilities 574 575 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){ 576 return InitializeSourceManager(Input, getDiagnostics(), 577 getFileManager(), getSourceManager(), 578 getFrontendOpts()); 579 } 580 581 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input, 582 DiagnosticsEngine &Diags, 583 FileManager &FileMgr, 584 SourceManager &SourceMgr, 585 const FrontendOptions &Opts) { 586 SrcMgr::CharacteristicKind 587 Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User; 588 589 if (Input.isBuffer()) { 590 SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind); 591 assert(!SourceMgr.getMainFileID().isInvalid() && 592 "Couldn't establish MainFileID!"); 593 return true; 594 } 595 596 StringRef InputFile = Input.getFile(); 597 598 // Figure out where to get and map in the main file. 599 if (InputFile != "-") { 600 const FileEntry *File = FileMgr.getFile(InputFile); 601 if (!File) { 602 Diags.Report(diag::err_fe_error_reading) << InputFile; 603 return false; 604 } 605 606 // The natural SourceManager infrastructure can't currently handle named 607 // pipes, but we would at least like to accept them for the main 608 // file. Detect them here, read them with the more generic MemoryBuffer 609 // function, and simply override their contents as we do for STDIN. 610 if (File->isNamedPipe()) { 611 OwningPtr<llvm::MemoryBuffer> MB; 612 if (llvm::error_code ec = llvm::MemoryBuffer::getFile(InputFile, MB)) { 613 Diags.Report(diag::err_cannot_open_file) << InputFile << ec.message(); 614 return false; 615 } 616 617 // Create a new virtual file that will have the correct size. 618 File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0); 619 SourceMgr.overrideFileContents(File, MB.take()); 620 } 621 622 SourceMgr.createMainFileID(File, Kind); 623 } else { 624 OwningPtr<llvm::MemoryBuffer> SB; 625 if (llvm::MemoryBuffer::getSTDIN(SB)) { 626 // FIXME: Give ec.message() in this diag. 627 Diags.Report(diag::err_fe_error_reading_stdin); 628 return false; 629 } 630 const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(), 631 SB->getBufferSize(), 0); 632 SourceMgr.createMainFileID(File, Kind); 633 SourceMgr.overrideFileContents(File, SB.take()); 634 } 635 636 assert(!SourceMgr.getMainFileID().isInvalid() && 637 "Couldn't establish MainFileID!"); 638 return true; 639 } 640 641 // High-Level Operations 642 643 bool CompilerInstance::ExecuteAction(FrontendAction &Act) { 644 assert(hasDiagnostics() && "Diagnostics engine is not initialized!"); 645 assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!"); 646 assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!"); 647 648 // FIXME: Take this as an argument, once all the APIs we used have moved to 649 // taking it as an input instead of hard-coding llvm::errs. 650 raw_ostream &OS = llvm::errs(); 651 652 // Create the target instance. 653 setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts())); 654 if (!hasTarget()) 655 return false; 656 657 // Inform the target of the language options. 658 // 659 // FIXME: We shouldn't need to do this, the target should be immutable once 660 // created. This complexity should be lifted elsewhere. 661 getTarget().setForcedLangOptions(getLangOpts()); 662 663 // rewriter project will change target built-in bool type from its default. 664 if (getFrontendOpts().ProgramAction == frontend::RewriteObjC) 665 getTarget().noSignedCharForObjCBool(); 666 667 // Validate/process some options. 668 if (getHeaderSearchOpts().Verbose) 669 OS << "clang -cc1 version " CLANG_VERSION_STRING 670 << " based upon " << PACKAGE_STRING 671 << " default target " << llvm::sys::getDefaultTargetTriple() << "\n"; 672 673 if (getFrontendOpts().ShowTimers) 674 createFrontendTimer(); 675 676 if (getFrontendOpts().ShowStats) 677 llvm::EnableStatistics(); 678 679 for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) { 680 // Reset the ID tables if we are reusing the SourceManager. 681 if (hasSourceManager()) 682 getSourceManager().clearIDTables(); 683 684 if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) { 685 Act.Execute(); 686 Act.EndSourceFile(); 687 } 688 } 689 690 // Notify the diagnostic client that all files were processed. 691 getDiagnostics().getClient()->finish(); 692 693 if (getDiagnosticOpts().ShowCarets) { 694 // We can have multiple diagnostics sharing one diagnostic client. 695 // Get the total number of warnings/errors from the client. 696 unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings(); 697 unsigned NumErrors = getDiagnostics().getClient()->getNumErrors(); 698 699 if (NumWarnings) 700 OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s"); 701 if (NumWarnings && NumErrors) 702 OS << " and "; 703 if (NumErrors) 704 OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s"); 705 if (NumWarnings || NumErrors) 706 OS << " generated.\n"; 707 } 708 709 if (getFrontendOpts().ShowStats && hasFileManager()) { 710 getFileManager().PrintStats(); 711 OS << "\n"; 712 } 713 714 return !getDiagnostics().getClient()->getNumErrors(); 715 } 716 717 /// \brief Determine the appropriate source input kind based on language 718 /// options. 719 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) { 720 if (LangOpts.OpenCL) 721 return IK_OpenCL; 722 if (LangOpts.CUDA) 723 return IK_CUDA; 724 if (LangOpts.ObjC1) 725 return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC; 726 return LangOpts.CPlusPlus? IK_CXX : IK_C; 727 } 728 729 namespace { 730 struct CompileModuleMapData { 731 CompilerInstance &Instance; 732 GenerateModuleAction &CreateModuleAction; 733 }; 734 } 735 736 /// \brief Helper function that executes the module-generating action under 737 /// a crash recovery context. 738 static void doCompileMapModule(void *UserData) { 739 CompileModuleMapData &Data 740 = *reinterpret_cast<CompileModuleMapData *>(UserData); 741 Data.Instance.ExecuteAction(Data.CreateModuleAction); 742 } 743 744 /// \brief Compile a module file for the given module, using the options 745 /// provided by the importing compiler instance. 746 static void compileModule(CompilerInstance &ImportingInstance, 747 SourceLocation ImportLoc, 748 Module *Module, 749 StringRef ModuleFileName) { 750 llvm::LockFileManager Locked(ModuleFileName); 751 switch (Locked) { 752 case llvm::LockFileManager::LFS_Error: 753 return; 754 755 case llvm::LockFileManager::LFS_Owned: 756 // We're responsible for building the module ourselves. Do so below. 757 break; 758 759 case llvm::LockFileManager::LFS_Shared: 760 // Someone else is responsible for building the module. Wait for them to 761 // finish. 762 Locked.waitForUnlock(); 763 return; 764 } 765 766 ModuleMap &ModMap 767 = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 768 769 // Construct a compiler invocation for creating this module. 770 IntrusiveRefCntPtr<CompilerInvocation> Invocation 771 (new CompilerInvocation(ImportingInstance.getInvocation())); 772 773 PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); 774 775 // For any options that aren't intended to affect how a module is built, 776 // reset them to their default values. 777 Invocation->getLangOpts()->resetNonModularOptions(); 778 PPOpts.resetNonModularOptions(); 779 780 // Note the name of the module we're building. 781 Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName(); 782 783 // Make sure that the failed-module structure has been allocated in 784 // the importing instance, and propagate the pointer to the newly-created 785 // instance. 786 PreprocessorOptions &ImportingPPOpts 787 = ImportingInstance.getInvocation().getPreprocessorOpts(); 788 if (!ImportingPPOpts.FailedModules) 789 ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet; 790 PPOpts.FailedModules = ImportingPPOpts.FailedModules; 791 792 // If there is a module map file, build the module using the module map. 793 // Set up the inputs/outputs so that we build the module from its umbrella 794 // header. 795 FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); 796 FrontendOpts.OutputFile = ModuleFileName.str(); 797 FrontendOpts.DisableFree = false; 798 FrontendOpts.GenerateGlobalModuleIndex = false; 799 FrontendOpts.Inputs.clear(); 800 InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts()); 801 802 // Get or create the module map that we'll use to build this module. 803 SmallString<128> TempModuleMapFileName; 804 if (const FileEntry *ModuleMapFile 805 = ModMap.getContainingModuleMapFile(Module)) { 806 // Use the module map where this module resides. 807 FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(), 808 IK)); 809 } else { 810 // Create a temporary module map file. 811 TempModuleMapFileName = Module->Name; 812 TempModuleMapFileName += "-%%%%%%%%.map"; 813 int FD; 814 if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD, 815 TempModuleMapFileName, 816 /*makeAbsolute=*/true) 817 != llvm::errc::success) { 818 ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file) 819 << TempModuleMapFileName; 820 return; 821 } 822 // Print the module map to this file. 823 llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true); 824 Module->print(OS); 825 FrontendOpts.Inputs.push_back( 826 FrontendInputFile(TempModuleMapFileName.str().str(), IK)); 827 } 828 829 // Don't free the remapped file buffers; they are owned by our caller. 830 PPOpts.RetainRemappedFileBuffers = true; 831 832 Invocation->getDiagnosticOpts().VerifyDiagnostics = 0; 833 assert(ImportingInstance.getInvocation().getModuleHash() == 834 Invocation->getModuleHash() && "Module hash mismatch!"); 835 836 // Construct a compiler instance that will be used to actually create the 837 // module. 838 CompilerInstance Instance; 839 Instance.setInvocation(&*Invocation); 840 Instance.createDiagnostics(&ImportingInstance.getDiagnosticClient(), 841 /*ShouldOwnClient=*/true, 842 /*ShouldCloneClient=*/true); 843 844 // Note that this module is part of the module build stack, so that we 845 // can detect cycles in the module graph. 846 Instance.createFileManager(); // FIXME: Adopt file manager from importer? 847 Instance.createSourceManager(Instance.getFileManager()); 848 SourceManager &SourceMgr = Instance.getSourceManager(); 849 SourceMgr.setModuleBuildStack( 850 ImportingInstance.getSourceManager().getModuleBuildStack()); 851 SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(), 852 FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager())); 853 854 855 // Construct a module-generating action. 856 GenerateModuleAction CreateModuleAction; 857 858 // Execute the action to actually build the module in-place. Use a separate 859 // thread so that we get a stack large enough. 860 const unsigned ThreadStackSize = 8 << 20; 861 llvm::CrashRecoveryContext CRC; 862 CompileModuleMapData Data = { Instance, CreateModuleAction }; 863 CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize); 864 865 // Delete the temporary module map file. 866 // FIXME: Even though we're executing under crash protection, it would still 867 // be nice to do this with RemoveFileOnSignal when we can. However, that 868 // doesn't make sense for all clients, so clean this up manually. 869 Instance.clearOutputFiles(/*EraseFiles=*/true); 870 if (!TempModuleMapFileName.empty()) 871 llvm::sys::Path(TempModuleMapFileName).eraseFromDisk(); 872 873 // We've rebuilt a module. If we're allowed to generate or update the global 874 // module index, record that fact in the importing compiler instance. 875 if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) { 876 ImportingInstance.setBuildGlobalModuleIndex(true); 877 } 878 } 879 880 ModuleLoadResult 881 CompilerInstance::loadModule(SourceLocation ImportLoc, 882 ModuleIdPath Path, 883 Module::NameVisibilityKind Visibility, 884 bool IsInclusionDirective) { 885 // If we've already handled this import, just return the cached result. 886 // This one-element cache is important to eliminate redundant diagnostics 887 // when both the preprocessor and parser see the same import declaration. 888 if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) { 889 // Make the named module visible. 890 if (LastModuleImportResult) 891 ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility); 892 return LastModuleImportResult; 893 } 894 895 // Determine what file we're searching from. 896 StringRef ModuleName = Path[0].first->getName(); 897 SourceLocation ModuleNameLoc = Path[0].second; 898 899 clang::Module *Module = 0; 900 901 // If we don't already have information on this module, load the module now. 902 llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known 903 = KnownModules.find(Path[0].first); 904 if (Known != KnownModules.end()) { 905 // Retrieve the cached top-level module. 906 Module = Known->second; 907 } else if (ModuleName == getLangOpts().CurrentModule) { 908 // This is the module we're building. 909 Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName); 910 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; 911 } else { 912 // Search for a module with the given name. 913 Module = PP->getHeaderSearchInfo().lookupModule(ModuleName); 914 std::string ModuleFileName; 915 if (Module) 916 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module); 917 else 918 ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName); 919 920 if (ModuleFileName.empty()) { 921 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found) 922 << ModuleName 923 << SourceRange(ImportLoc, ModuleNameLoc); 924 LastModuleImportLoc = ImportLoc; 925 LastModuleImportResult = ModuleLoadResult(); 926 return LastModuleImportResult; 927 } 928 929 const FileEntry *ModuleFile 930 = getFileManager().getFile(ModuleFileName, /*OpenFile=*/false, 931 /*CacheFailure=*/false); 932 bool BuildingModule = false; 933 if (!ModuleFile && Module) { 934 // The module is not cached, but we have a module map from which we can 935 // build the module. 936 937 // Check whether there is a cycle in the module graph. 938 ModuleBuildStack Path = getSourceManager().getModuleBuildStack(); 939 ModuleBuildStack::iterator Pos = Path.begin(), PosEnd = Path.end(); 940 for (; Pos != PosEnd; ++Pos) { 941 if (Pos->first == ModuleName) 942 break; 943 } 944 945 if (Pos != PosEnd) { 946 SmallString<256> CyclePath; 947 for (; Pos != PosEnd; ++Pos) { 948 CyclePath += Pos->first; 949 CyclePath += " -> "; 950 } 951 CyclePath += ModuleName; 952 953 getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle) 954 << ModuleName << CyclePath; 955 return ModuleLoadResult(); 956 } 957 958 // Check whether we have already attempted to build this module (but 959 // failed). 960 if (getPreprocessorOpts().FailedModules && 961 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { 962 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) 963 << ModuleName 964 << SourceRange(ImportLoc, ModuleNameLoc); 965 ModuleBuildFailed = true; 966 return ModuleLoadResult(); 967 } 968 969 BuildingModule = true; 970 compileModule(*this, ModuleNameLoc, Module, ModuleFileName); 971 ModuleFile = FileMgr->getFile(ModuleFileName); 972 973 if (!ModuleFile && getPreprocessorOpts().FailedModules) 974 getPreprocessorOpts().FailedModules->addFailed(ModuleName); 975 } 976 977 if (!ModuleFile) { 978 getDiagnostics().Report(ModuleNameLoc, 979 BuildingModule? diag::err_module_not_built 980 : diag::err_module_not_found) 981 << ModuleName 982 << SourceRange(ImportLoc, ModuleNameLoc); 983 ModuleBuildFailed = true; 984 return ModuleLoadResult(); 985 } 986 987 // If we don't already have an ASTReader, create one now. 988 if (!ModuleManager) { 989 if (!hasASTContext()) 990 createASTContext(); 991 992 std::string Sysroot = getHeaderSearchOpts().Sysroot; 993 const PreprocessorOptions &PPOpts = getPreprocessorOpts(); 994 ModuleManager = new ASTReader(getPreprocessor(), *Context, 995 Sysroot.empty() ? "" : Sysroot.c_str(), 996 PPOpts.DisablePCHValidation, 997 /*AllowASTWithCompilerErrors=*/false, 998 getFrontendOpts().UseGlobalModuleIndex); 999 if (hasASTConsumer()) { 1000 ModuleManager->setDeserializationListener( 1001 getASTConsumer().GetASTDeserializationListener()); 1002 getASTContext().setASTMutationListener( 1003 getASTConsumer().GetASTMutationListener()); 1004 getPreprocessor().setPPMutationListener( 1005 getASTConsumer().GetPPMutationListener()); 1006 } 1007 OwningPtr<ExternalASTSource> Source; 1008 Source.reset(ModuleManager); 1009 getASTContext().setExternalSource(Source); 1010 if (hasSema()) 1011 ModuleManager->InitializeSema(getSema()); 1012 if (hasASTConsumer()) 1013 ModuleManager->StartTranslationUnit(&getASTConsumer()); 1014 } 1015 1016 // Try to load the module we found. 1017 unsigned ARRFlags = ASTReader::ARR_None; 1018 if (Module) 1019 ARRFlags |= ASTReader::ARR_OutOfDate; 1020 switch (ModuleManager->ReadAST(ModuleFile->getName(), 1021 serialization::MK_Module, ImportLoc, 1022 ARRFlags)) { 1023 case ASTReader::Success: 1024 break; 1025 1026 case ASTReader::OutOfDate: { 1027 // The module file is out-of-date. Rebuild it. 1028 getFileManager().invalidateCache(ModuleFile); 1029 bool Existed; 1030 llvm::sys::fs::remove(ModuleFileName, Existed); 1031 1032 // Check whether we have already attempted to build this module (but 1033 // failed). 1034 if (getPreprocessorOpts().FailedModules && 1035 getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) { 1036 getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built) 1037 << ModuleName 1038 << SourceRange(ImportLoc, ModuleNameLoc); 1039 ModuleBuildFailed = true; 1040 1041 return ModuleLoadResult(); 1042 } 1043 1044 compileModule(*this, ModuleNameLoc, Module, ModuleFileName); 1045 1046 // Try loading the module again. 1047 ModuleFile = FileMgr->getFile(ModuleFileName); 1048 if (!ModuleFile || 1049 ModuleManager->ReadAST(ModuleFileName, 1050 serialization::MK_Module, ImportLoc, 1051 ASTReader::ARR_None) != ASTReader::Success) { 1052 if (getPreprocessorOpts().FailedModules) 1053 getPreprocessorOpts().FailedModules->addFailed(ModuleName); 1054 KnownModules[Path[0].first] = 0; 1055 ModuleBuildFailed = true; 1056 return ModuleLoadResult(); 1057 } 1058 1059 // Okay, we've rebuilt and now loaded the module. 1060 break; 1061 } 1062 1063 case ASTReader::VersionMismatch: 1064 case ASTReader::ConfigurationMismatch: 1065 case ASTReader::HadErrors: 1066 // FIXME: The ASTReader will already have complained, but can we showhorn 1067 // that diagnostic information into a more useful form? 1068 KnownModules[Path[0].first] = 0; 1069 return ModuleLoadResult(); 1070 1071 case ASTReader::Failure: 1072 // Already complained, but note now that we failed. 1073 KnownModules[Path[0].first] = 0; 1074 ModuleBuildFailed = true; 1075 return ModuleLoadResult(); 1076 } 1077 1078 if (!Module) { 1079 // If we loaded the module directly, without finding a module map first, 1080 // we'll have loaded the module's information from the module itself. 1081 Module = PP->getHeaderSearchInfo().getModuleMap() 1082 .findModule((Path[0].first->getName())); 1083 } 1084 1085 if (Module) 1086 Module->setASTFile(ModuleFile); 1087 1088 // Cache the result of this top-level module lookup for later. 1089 Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first; 1090 } 1091 1092 // If we never found the module, fail. 1093 if (!Module) 1094 return ModuleLoadResult(); 1095 1096 // Verify that the rest of the module path actually corresponds to 1097 // a submodule. 1098 if (Path.size() > 1) { 1099 for (unsigned I = 1, N = Path.size(); I != N; ++I) { 1100 StringRef Name = Path[I].first->getName(); 1101 clang::Module *Sub = Module->findSubmodule(Name); 1102 1103 if (!Sub) { 1104 // Attempt to perform typo correction to find a module name that works. 1105 SmallVector<StringRef, 2> Best; 1106 unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)(); 1107 1108 for (clang::Module::submodule_iterator J = Module->submodule_begin(), 1109 JEnd = Module->submodule_end(); 1110 J != JEnd; ++J) { 1111 unsigned ED = Name.edit_distance((*J)->Name, 1112 /*AllowReplacements=*/true, 1113 BestEditDistance); 1114 if (ED <= BestEditDistance) { 1115 if (ED < BestEditDistance) { 1116 Best.clear(); 1117 BestEditDistance = ED; 1118 } 1119 1120 Best.push_back((*J)->Name); 1121 } 1122 } 1123 1124 // If there was a clear winner, user it. 1125 if (Best.size() == 1) { 1126 getDiagnostics().Report(Path[I].second, 1127 diag::err_no_submodule_suggest) 1128 << Path[I].first << Module->getFullModuleName() << Best[0] 1129 << SourceRange(Path[0].second, Path[I-1].second) 1130 << FixItHint::CreateReplacement(SourceRange(Path[I].second), 1131 Best[0]); 1132 1133 Sub = Module->findSubmodule(Best[0]); 1134 } 1135 } 1136 1137 if (!Sub) { 1138 // No submodule by this name. Complain, and don't look for further 1139 // submodules. 1140 getDiagnostics().Report(Path[I].second, diag::err_no_submodule) 1141 << Path[I].first << Module->getFullModuleName() 1142 << SourceRange(Path[0].second, Path[I-1].second); 1143 break; 1144 } 1145 1146 Module = Sub; 1147 } 1148 } 1149 1150 // Make the named module visible, if it's not already part of the module 1151 // we are parsing. 1152 if (ModuleName != getLangOpts().CurrentModule) { 1153 if (!Module->IsFromModuleFile) { 1154 // We have an umbrella header or directory that doesn't actually include 1155 // all of the headers within the directory it covers. Complain about 1156 // this missing submodule and recover by forgetting that we ever saw 1157 // this submodule. 1158 // FIXME: Should we detect this at module load time? It seems fairly 1159 // expensive (and rare). 1160 getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule) 1161 << Module->getFullModuleName() 1162 << SourceRange(Path.front().second, Path.back().second); 1163 1164 return ModuleLoadResult(0, true); 1165 } 1166 1167 // Check whether this module is available. 1168 StringRef Feature; 1169 if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) { 1170 getDiagnostics().Report(ImportLoc, diag::err_module_unavailable) 1171 << Module->getFullModuleName() 1172 << Feature 1173 << SourceRange(Path.front().second, Path.back().second); 1174 LastModuleImportLoc = ImportLoc; 1175 LastModuleImportResult = ModuleLoadResult(); 1176 return ModuleLoadResult(); 1177 } 1178 1179 ModuleManager->makeModuleVisible(Module, Visibility); 1180 } 1181 1182 // If this module import was due to an inclusion directive, create an 1183 // implicit import declaration to capture it in the AST. 1184 if (IsInclusionDirective && hasASTContext()) { 1185 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 1186 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 1187 ImportLoc, Module, 1188 Path.back().second); 1189 TU->addDecl(ImportD); 1190 if (Consumer) 1191 Consumer->HandleImplicitImportDecl(ImportD); 1192 } 1193 1194 LastModuleImportLoc = ImportLoc; 1195 LastModuleImportResult = ModuleLoadResult(Module, false); 1196 return LastModuleImportResult; 1197 } 1198 1199 void CompilerInstance::makeModuleVisible(Module *Mod, 1200 Module::NameVisibilityKind Visibility){ 1201 ModuleManager->makeModuleVisible(Mod, Visibility); 1202 } 1203 1204