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