contrib/llvm/tools/clang/lib/Frontend/CompilerInstance.cpp

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