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/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().ShowMacrosInCodeCompletion,
 391                              getFrontendOpts().ShowCodePatternsInCodeCompletion,
 392                            getFrontendOpts().ShowGlobalSymbolsInCodeCompletion,
 393                                    llvm::outs()));
 394     if (!CompletionConsumer)
 395       return;
 396   } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
 397                                   Loc.Line, Loc.Column)) {
 398     setCodeCompletionConsumer(0);
 399     return;
 400   }
 401
 402   if (CompletionConsumer->isOutputBinary() &&
 403       llvm::sys::Program::ChangeStdoutToBinary()) {
 404     getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
 405     setCodeCompletionConsumer(0);
 406   }
 407 }
 408
 409 void CompilerInstance::createFrontendTimer() {
 410   FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
 411 }
 412
 413 CodeCompleteConsumer *
 414 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
 415                                                const std::string &Filename,
 416                                                unsigned Line,
 417                                                unsigned Column,
 418                                                bool ShowMacros,
 419                                                bool ShowCodePatterns,
 420                                                bool ShowGlobals,
 421                                                raw_ostream &OS) {
 422   if (EnableCodeCompletion(PP, Filename, Line, Column))
 423     return 0;
 424
 425   // Set up the creation routine for code-completion.
 426   return new PrintingCodeCompleteConsumer(ShowMacros, ShowCodePatterns,
 427                                           ShowGlobals, OS);
 428 }
 429
 430 void CompilerInstance::createSema(TranslationUnitKind TUKind,
 431                                   CodeCompleteConsumer *CompletionConsumer) {
 432   TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
 433                          TUKind, CompletionConsumer));
 434 }
 435
 436 // Output Files
 437
 438 void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
 439   assert(OutFile.OS && "Attempt to add empty stream to output list!");
 440   OutputFiles.push_back(OutFile);
 441 }
 442
 443 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
 444   for (std::list<OutputFile>::iterator
 445          it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
 446     delete it->OS;
 447     if (!it->TempFilename.empty()) {
 448       if (EraseFiles) {
 449         bool existed;
 450         llvm::sys::fs::remove(it->TempFilename, existed);
 451       } else {
 452         SmallString<128> NewOutFile(it->Filename);
 453
 454         // If '-working-directory' was passed, the output filename should be
 455         // relative to that.
 456         FileMgr->FixupRelativePath(NewOutFile);
 457         if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
 458                                                         NewOutFile.str())) {
 459           getDiagnostics().Report(diag::err_fe_unable_to_rename_temp)
 460             << it->TempFilename << it->Filename << ec.message();
 461
 462           bool existed;
 463           llvm::sys::fs::remove(it->TempFilename, existed);
 464         }
 465       }
 466     } else if (!it->Filename.empty() && EraseFiles)
 467       llvm::sys::Path(it->Filename).eraseFromDisk();
 468
 469   }
 470   OutputFiles.clear();
 471 }
 472
 473 llvm::raw_fd_ostream *
 474 CompilerInstance::createDefaultOutputFile(bool Binary,
 475                                           StringRef InFile,
 476                                           StringRef Extension) {
 477   return createOutputFile(getFrontendOpts().OutputFile, Binary,
 478                           /*RemoveFileOnSignal=*/true, InFile, Extension,
 479                           /*UseTemporary=*/true);
 480 }
 481
 482 llvm::raw_fd_ostream *
 483 CompilerInstance::createOutputFile(StringRef OutputPath,
 484                                    bool Binary, bool RemoveFileOnSignal,
 485                                    StringRef InFile,
 486                                    StringRef Extension,
 487                                    bool UseTemporary,
 488                                    bool CreateMissingDirectories) {
 489   std::string Error, OutputPathName, TempPathName;
 490   llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
 491                                               RemoveFileOnSignal,
 492                                               InFile, Extension,
 493                                               UseTemporary,
 494                                               CreateMissingDirectories,
 495                                               &OutputPathName,
 496                                               &TempPathName);
 497   if (!OS) {
 498     getDiagnostics().Report(diag::err_fe_unable_to_open_output)
 499       << OutputPath << Error;
 500     return 0;
 501   }
 502
 503   // Add the output file -- but don't try to remove "-", since this means we are
 504   // using stdin.
 505   addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
 506                 TempPathName, OS));
 507
 508   return OS;
 509 }
 510
 511 llvm::raw_fd_ostream *
 512 CompilerInstance::createOutputFile(StringRef OutputPath,
 513                                    std::string &Error,
 514                                    bool Binary,
 515                                    bool RemoveFileOnSignal,
 516                                    StringRef InFile,
 517                                    StringRef Extension,
 518                                    bool UseTemporary,
 519                                    bool CreateMissingDirectories,
 520                                    std::string *ResultPathName,
 521                                    std::string *TempPathName) {
 522   assert((!CreateMissingDirectories || UseTemporary) &&
 523          "CreateMissingDirectories is only allowed when using temporary files");
 524
 525   std::string OutFile, TempFile;
 526   if (!OutputPath.empty()) {
 527     OutFile = OutputPath;
 528   } else if (InFile == "-") {
 529     OutFile = "-";
 530   } else if (!Extension.empty()) {
 531     llvm::sys::Path Path(InFile);
 532     Path.eraseSuffix();
 533     Path.appendSuffix(Extension);
 534     OutFile = Path.str();
 535   } else {
 536     OutFile = "-";
 537   }
 538
 539   OwningPtr<llvm::raw_fd_ostream> OS;
 540   std::string OSFile;
 541
 542   if (UseTemporary && OutFile != "-") {
 543     // Only create the temporary if the parent directory exists (or create
 544     // missing directories is true) and we can actually write to OutPath,
 545     // otherwise we want to fail early.
 546     SmallString<256> AbsPath(OutputPath);
 547     llvm::sys::fs::make_absolute(AbsPath);
 548     llvm::sys::Path OutPath(AbsPath);
 549     bool ParentExists = false;
 550     if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()),
 551                               ParentExists))
 552       ParentExists = false;
 553     bool Exists;
 554     if ((CreateMissingDirectories || ParentExists) &&
 555         ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) ||
 556          (OutPath.isRegularFile() && OutPath.canWrite()))) {
 557       // Create a temporary file.
 558       SmallString<128> TempPath;
 559       TempPath = OutFile;
 560       TempPath += "-%%%%%%%%";
 561       int fd;
 562       if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
 563                                      /*makeAbsolute=*/false, 0664)
 564           == llvm::errc::success) {
 565         OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
 566         OSFile = TempFile = TempPath.str();
 567       }
 568     }
 569   }
 570
 571   if (!OS) {
 572     OSFile = OutFile;
 573     OS.reset(
 574       new llvm::raw_fd_ostream(OSFile.c_str(), Error,
 575                                (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
 576     if (!Error.empty())
 577       return 0;
 578   }
 579
 580   // Make sure the out stream file gets removed if we crash.
 581   if (RemoveFileOnSignal)
 582     llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
 583
 584   if (ResultPathName)
 585     *ResultPathName = OutFile;
 586   if (TempPathName)
 587     *TempPathName = TempFile;
 588
 589   return OS.take();
 590 }
 591
 592 // Initialization Utilities
 593
 594 bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
 595                                                SrcMgr::CharacteristicKind Kind){
 596   return InitializeSourceManager(InputFile, Kind, getDiagnostics(),
 597                                  getFileManager(), getSourceManager(),
 598                                  getFrontendOpts());
 599 }
 600
 601 bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
 602                                                SrcMgr::CharacteristicKind Kind,
 603                                                DiagnosticsEngine &Diags,
 604                                                FileManager &FileMgr,
 605                                                SourceManager &SourceMgr,
 606                                                const FrontendOptions &Opts) {
 607   // Figure out where to get and map in the main file.
 608   if (InputFile != "-") {
 609     const FileEntry *File = FileMgr.getFile(InputFile);
 610     if (!File) {
 611       Diags.Report(diag::err_fe_error_reading) << InputFile;
 612       return false;
 613     }
 614     SourceMgr.createMainFileID(File, Kind);
 615   } else {
 616     OwningPtr<llvm::MemoryBuffer> SB;
 617     if (llvm::MemoryBuffer::getSTDIN(SB)) {
 618       // FIXME: Give ec.message() in this diag.
 619       Diags.Report(diag::err_fe_error_reading_stdin);
 620       return false;
 621     }
 622     const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
 623                                                    SB->getBufferSize(), 0);
 624     SourceMgr.createMainFileID(File, Kind);
 625     SourceMgr.overrideFileContents(File, SB.take());
 626   }
 627
 628   assert(!SourceMgr.getMainFileID().isInvalid() &&
 629          "Couldn't establish MainFileID!");
 630   return true;
 631 }
 632
 633 // High-Level Operations
 634
 635 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
 636   assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
 637   assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
 638   assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
 639
 640   // FIXME: Take this as an argument, once all the APIs we used have moved to
 641   // taking it as an input instead of hard-coding llvm::errs.
 642   raw_ostream &OS = llvm::errs();
 643
 644   // Create the target instance.
 645   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts()));
 646   if (!hasTarget())
 647     return false;
 648
 649   // Inform the target of the language options.
 650   //
 651   // FIXME: We shouldn't need to do this, the target should be immutable once
 652   // created. This complexity should be lifted elsewhere.
 653   getTarget().setForcedLangOptions(getLangOpts());
 654
 655   // rewriter project will change target built-in bool type from its default.
 656   if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
 657     getTarget().noSignedCharForObjCBool();
 658
 659   // Validate/process some options.
 660   if (getHeaderSearchOpts().Verbose)
 661     OS << "clang -cc1 version " CLANG_VERSION_STRING
 662        << " based upon " << PACKAGE_STRING
 663        << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
 664
 665   if (getFrontendOpts().ShowTimers)
 666     createFrontendTimer();
 667
 668   if (getFrontendOpts().ShowStats)
 669     llvm::EnableStatistics();
 670
 671   for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
 672     // Reset the ID tables if we are reusing the SourceManager.
 673     if (hasSourceManager())
 674       getSourceManager().clearIDTables();
 675
 676     if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
 677       Act.Execute();
 678       Act.EndSourceFile();
 679     }
 680   }
 681
 682   // Notify the diagnostic client that all files were processed.
 683   getDiagnostics().getClient()->finish();
 684
 685   if (getDiagnosticOpts().ShowCarets) {
 686     // We can have multiple diagnostics sharing one diagnostic client.
 687     // Get the total number of warnings/errors from the client.
 688     unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
 689     unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
 690
 691     if (NumWarnings)
 692       OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
 693     if (NumWarnings && NumErrors)
 694       OS << " and ";
 695     if (NumErrors)
 696       OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
 697     if (NumWarnings || NumErrors)
 698       OS << " generated.\n";
 699   }
 700
 701   if (getFrontendOpts().ShowStats && hasFileManager()) {
 702     getFileManager().PrintStats();
 703     OS << "\n";
 704   }
 705
 706   return !getDiagnostics().getClient()->getNumErrors();
 707 }
 708
 709 /// \brief Determine the appropriate source input kind based on language
 710 /// options.
 711 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
 712   if (LangOpts.OpenCL)
 713     return IK_OpenCL;
 714   if (LangOpts.CUDA)
 715     return IK_CUDA;
 716   if (LangOpts.ObjC1)
 717     return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
 718   return LangOpts.CPlusPlus? IK_CXX : IK_C;
 719 }
 720
 721 namespace {
 722   struct CompileModuleMapData {
 723     CompilerInstance &Instance;
 724     GenerateModuleAction &CreateModuleAction;
 725   };
 726 }
 727
 728 /// \brief Helper function that executes the module-generating action under
 729 /// a crash recovery context.
 730 static void doCompileMapModule(void *UserData) {
 731   CompileModuleMapData &Data
 732     = *reinterpret_cast<CompileModuleMapData *>(UserData);
 733   Data.Instance.ExecuteAction(Data.CreateModuleAction);
 734 }
 735
 736 /// \brief Compile a module file for the given module, using the options
 737 /// provided by the importing compiler instance.
 738 static void compileModule(CompilerInstance &ImportingInstance,
 739                           Module *Module,
 740                           StringRef ModuleFileName) {
 741   llvm::LockFileManager Locked(ModuleFileName);
 742   switch (Locked) {
 743   case llvm::LockFileManager::LFS_Error:
 744     return;
 745
 746   case llvm::LockFileManager::LFS_Owned:
 747     // We're responsible for building the module ourselves. Do so below.
 748     break;
 749
 750   case llvm::LockFileManager::LFS_Shared:
 751     // Someone else is responsible for building the module. Wait for them to
 752     // finish.
 753     Locked.waitForUnlock();
 754     break;
 755   }
 756
 757   ModuleMap &ModMap
 758     = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
 759
 760   // Construct a compiler invocation for creating this module.
 761   IntrusiveRefCntPtr<CompilerInvocation> Invocation
 762     (new CompilerInvocation(ImportingInstance.getInvocation()));
 763
 764   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
 765
 766   // For any options that aren't intended to affect how a module is built,
 767   // reset them to their default values.
 768   Invocation->getLangOpts()->resetNonModularOptions();
 769   PPOpts.resetNonModularOptions();
 770
 771   // Note the name of the module we're building.
 772   Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
 773
 774   // Note that this module is part of the module build path, so that we
 775   // can detect cycles in the module graph.
 776   PPOpts.ModuleBuildPath.push_back(Module->getTopLevelModuleName());
 777
 778   // If there is a module map file, build the module using the module map.
 779   // Set up the inputs/outputs so that we build the module from its umbrella
 780   // header.
 781   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
 782   FrontendOpts.OutputFile = ModuleFileName.str();
 783   FrontendOpts.DisableFree = false;
 784   FrontendOpts.Inputs.clear();
 785   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
 786
 787   // Get or create the module map that we'll use to build this module.
 788   SmallString<128> TempModuleMapFileName;
 789   if (const FileEntry *ModuleMapFile
 790                                   = ModMap.getContainingModuleMapFile(Module)) {
 791     // Use the module map where this module resides.
 792     FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
 793                                                     IK));
 794   } else {
 795     // Create a temporary module map file.
 796     TempModuleMapFileName = Module->Name;
 797     TempModuleMapFileName += "-%%%%%%%%.map";
 798     int FD;
 799     if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
 800                                    TempModuleMapFileName,
 801                                    /*makeAbsolute=*/true)
 802           != llvm::errc::success) {
 803       ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
 804         << TempModuleMapFileName;
 805       return;
 806     }
 807     // Print the module map to this file.
 808     llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
 809     Module->print(OS);
 810     FrontendOpts.Inputs.push_back(
 811       FrontendInputFile(TempModuleMapFileName.str().str(), IK));
 812   }
 813
 814   // Don't free the remapped file buffers; they are owned by our caller.
 815   PPOpts.RetainRemappedFileBuffers = true;
 816
 817   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
 818   assert(ImportingInstance.getInvocation().getModuleHash() ==
 819          Invocation->getModuleHash() && "Module hash mismatch!");
 820
 821   // Construct a compiler instance that will be used to actually create the
 822   // module.
 823   CompilerInstance Instance;
 824   Instance.setInvocation(&*Invocation);
 825   Instance.createDiagnostics(/*argc=*/0, /*argv=*/0,
 826                              &ImportingInstance.getDiagnosticClient(),
 827                              /*ShouldOwnClient=*/true,
 828                              /*ShouldCloneClient=*/true);
 829
 830   // Construct a module-generating action.
 831   GenerateModuleAction CreateModuleAction;
 832
 833   // Execute the action to actually build the module in-place. Use a separate
 834   // thread so that we get a stack large enough.
 835   const unsigned ThreadStackSize = 8 << 20;
 836   llvm::CrashRecoveryContext CRC;
 837   CompileModuleMapData Data = { Instance, CreateModuleAction };
 838   CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
 839
 840   // Delete the temporary module map file.
 841   // FIXME: Even though we're executing under crash protection, it would still
 842   // be nice to do this with RemoveFileOnSignal when we can. However, that
 843   // doesn't make sense for all clients, so clean this up manually.
 844   if (!TempModuleMapFileName.empty())
 845     llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
 846 }
 847
 848 Module *CompilerInstance::loadModule(SourceLocation ImportLoc,
 849                                      ModuleIdPath Path,
 850                                      Module::NameVisibilityKind Visibility,
 851                                      bool IsInclusionDirective) {
 852   // If we've already handled this import, just return the cached result.
 853   // This one-element cache is important to eliminate redundant diagnostics
 854   // when both the preprocessor and parser see the same import declaration.
 855   if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
 856     // Make the named module visible.
 857     if (LastModuleImportResult)
 858       ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility);
 859     return LastModuleImportResult;
 860   }
 861
 862   // Determine what file we're searching from.
 863   SourceManager &SourceMgr = getSourceManager();
 864   SourceLocation ExpandedImportLoc = SourceMgr.getExpansionLoc(ImportLoc);
 865   const FileEntry *CurFile
 866     = SourceMgr.getFileEntryForID(SourceMgr.getFileID(ExpandedImportLoc));
 867   if (!CurFile)
 868     CurFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
 869
 870   StringRef ModuleName = Path[0].first->getName();
 871   SourceLocation ModuleNameLoc = Path[0].second;
 872
 873   clang::Module *Module = 0;
 874
 875   // If we don't already have information on this module, load the module now.
 876   llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
 877     = KnownModules.find(Path[0].first);
 878   if (Known != KnownModules.end()) {
 879     // Retrieve the cached top-level module.
 880     Module = Known->second;
 881   } else if (ModuleName == getLangOpts().CurrentModule) {
 882     // This is the module we're building.
 883     Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
 884     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
 885   } else {
 886     // Search for a module with the given name.
 887     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
 888     std::string ModuleFileName;
 889     if (Module)
 890       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
 891     else
 892       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
 893
 894     if (ModuleFileName.empty()) {
 895       getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
 896         << ModuleName
 897         << SourceRange(ImportLoc, ModuleNameLoc);
 898       LastModuleImportLoc = ImportLoc;
 899       LastModuleImportResult = 0;
 900       return 0;
 901     }
 902
 903     const FileEntry *ModuleFile
 904       = getFileManager().getFile(ModuleFileName, /*OpenFile=*/false,
 905                                  /*CacheFailure=*/false);
 906     bool BuildingModule = false;
 907     if (!ModuleFile && Module) {
 908       // The module is not cached, but we have a module map from which we can
 909       // build the module.
 910
 911       // Check whether there is a cycle in the module graph.
 912       SmallVectorImpl<std::string> &ModuleBuildPath
 913         = getPreprocessorOpts().ModuleBuildPath;
 914       SmallVectorImpl<std::string>::iterator Pos
 915         = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(), ModuleName);
 916       if (Pos != ModuleBuildPath.end()) {
 917         SmallString<256> CyclePath;
 918         for (; Pos != ModuleBuildPath.end(); ++Pos) {
 919           CyclePath += *Pos;
 920           CyclePath += " -> ";
 921         }
 922         CyclePath += ModuleName;
 923
 924         getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
 925           << ModuleName << CyclePath;
 926         return 0;
 927       }
 928
 929       getDiagnostics().Report(ModuleNameLoc, diag::warn_module_build)
 930         << ModuleName;
 931       BuildingModule = true;
 932       compileModule(*this, Module, ModuleFileName);
 933       ModuleFile = FileMgr->getFile(ModuleFileName);
 934     }
 935
 936     if (!ModuleFile) {
 937       getDiagnostics().Report(ModuleNameLoc,
 938                               BuildingModule? diag::err_module_not_built
 939                                             : diag::err_module_not_found)
 940         << ModuleName
 941         << SourceRange(ImportLoc, ModuleNameLoc);
 942       return 0;
 943     }
 944
 945     // If we don't already have an ASTReader, create one now.
 946     if (!ModuleManager) {
 947       if (!hasASTContext())
 948         createASTContext();
 949
 950       std::string Sysroot = getHeaderSearchOpts().Sysroot;
 951       const PreprocessorOptions &PPOpts = getPreprocessorOpts();
 952       ModuleManager = new ASTReader(getPreprocessor(), *Context,
 953                                     Sysroot.empty() ? "" : Sysroot.c_str(),
 954                                     PPOpts.DisablePCHValidation,
 955                                     PPOpts.DisableStatCache);
 956       if (hasASTConsumer()) {
 957         ModuleManager->setDeserializationListener(
 958           getASTConsumer().GetASTDeserializationListener());
 959         getASTContext().setASTMutationListener(
 960           getASTConsumer().GetASTMutationListener());
 961       }
 962       OwningPtr<ExternalASTSource> Source;
 963       Source.reset(ModuleManager);
 964       getASTContext().setExternalSource(Source);
 965       if (hasSema())
 966         ModuleManager->InitializeSema(getSema());
 967       if (hasASTConsumer())
 968         ModuleManager->StartTranslationUnit(&getASTConsumer());
 969     }
 970
 971     // Try to load the module we found.
 972     switch (ModuleManager->ReadAST(ModuleFile->getName(),
 973                                    serialization::MK_Module)) {
 974     case ASTReader::Success:
 975       break;
 976
 977     case ASTReader::IgnorePCH:
 978       // FIXME: The ASTReader will already have complained, but can we showhorn
 979       // that diagnostic information into a more useful form?
 980       KnownModules[Path[0].first] = 0;
 981       return 0;
 982
 983     case ASTReader::Failure:
 984       // Already complained, but note now that we failed.
 985       KnownModules[Path[0].first] = 0;
 986       return 0;
 987     }
 988
 989     if (!Module) {
 990       // If we loaded the module directly, without finding a module map first,
 991       // we'll have loaded the module's information from the module itself.
 992       Module = PP->getHeaderSearchInfo().getModuleMap()
 993                  .findModule((Path[0].first->getName()));
 994     }
 995
 996     // Cache the result of this top-level module lookup for later.
 997     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
 998   }
 999
1000   // If we never found the module, fail.
1001   if (!Module)
1002     return 0;
1003
1004   // Verify that the rest of the module path actually corresponds to
1005   // a submodule.
1006   if (Path.size() > 1) {
1007     for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1008       StringRef Name = Path[I].first->getName();
1009       clang::Module *Sub = Module->findSubmodule(Name);
1010
1011       if (!Sub) {
1012         // Attempt to perform typo correction to find a module name that works.
1013         llvm::SmallVector<StringRef, 2> Best;
1014         unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1015
1016         for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1017                                             JEnd = Module->submodule_end();
1018              J != JEnd; ++J) {
1019           unsigned ED = Name.edit_distance((*J)->Name,
1020                                            /*AllowReplacements=*/true,
1021                                            BestEditDistance);
1022           if (ED <= BestEditDistance) {
1023             if (ED < BestEditDistance) {
1024               Best.clear();
1025               BestEditDistance = ED;
1026             }
1027
1028             Best.push_back((*J)->Name);
1029           }
1030         }
1031
1032         // If there was a clear winner, user it.
1033         if (Best.size() == 1) {
1034           getDiagnostics().Report(Path[I].second,
1035                                   diag::err_no_submodule_suggest)
1036             << Path[I].first << Module->getFullModuleName() << Best[0]
1037             << SourceRange(Path[0].second, Path[I-1].second)
1038             << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1039                                             Best[0]);
1040
1041           Sub = Module->findSubmodule(Best[0]);
1042         }
1043       }
1044
1045       if (!Sub) {
1046         // No submodule by this name. Complain, and don't look for further
1047         // submodules.
1048         getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1049           << Path[I].first << Module->getFullModuleName()
1050           << SourceRange(Path[0].second, Path[I-1].second);
1051         break;
1052       }
1053
1054       Module = Sub;
1055     }
1056   }
1057
1058   // Make the named module visible, if it's not already part of the module
1059   // we are parsing.
1060   if (ModuleName != getLangOpts().CurrentModule) {
1061     if (!Module->IsFromModuleFile) {
1062       // We have an umbrella header or directory that doesn't actually include
1063       // all of the headers within the directory it covers. Complain about
1064       // this missing submodule and recover by forgetting that we ever saw
1065       // this submodule.
1066       // FIXME: Should we detect this at module load time? It seems fairly
1067       // expensive (and rare).
1068       getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1069         << Module->getFullModuleName()
1070         << SourceRange(Path.front().second, Path.back().second);
1071
1072       return 0;
1073     }
1074
1075     // Check whether this module is available.
1076     StringRef Feature;
1077     if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
1078       getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1079         << Module->getFullModuleName()
1080         << Feature
1081         << SourceRange(Path.front().second, Path.back().second);
1082       LastModuleImportLoc = ImportLoc;
1083       LastModuleImportResult = 0;
1084       return 0;
1085     }
1086
1087     ModuleManager->makeModuleVisible(Module, Visibility);
1088   }
1089
1090   // If this module import was due to an inclusion directive, create an
1091   // implicit import declaration to capture it in the AST.
1092   if (IsInclusionDirective && hasASTContext()) {
1093     TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
1094     TU->addDecl(ImportDecl::CreateImplicit(getASTContext(), TU,
1095                                            ImportLoc, Module,
1096                                            Path.back().second));
1097   }
1098
1099   LastModuleImportLoc = ImportLoc;
1100   LastModuleImportResult = Module;
1101   return Module;
1102 }