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