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