granicus.if.org Git - clang/blob - 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/AST/ASTConsumer.h"
  12 #include "clang/AST/ASTContext.h"
  13 #include "clang/AST/Decl.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/Config/config.h"
  20 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
  21 #include "clang/Frontend/FrontendAction.h"
  22 #include "clang/Frontend/FrontendActions.h"
  23 #include "clang/Frontend/FrontendDiagnostic.h"
  24 #include "clang/Frontend/LogDiagnosticPrinter.h"
  25 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
  26 #include "clang/Frontend/TextDiagnosticPrinter.h"
  27 #include "clang/Frontend/Utils.h"
  28 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
  29 #include "clang/Lex/HeaderSearch.h"
  30 #include "clang/Lex/PTHManager.h"
  31 #include "clang/Lex/Preprocessor.h"
  32 #include "clang/Sema/CodeCompleteConsumer.h"
  33 #include "clang/Sema/Sema.h"
  34 #include "clang/Serialization/ASTReader.h"
  35 #include "clang/Serialization/GlobalModuleIndex.h"
  36 #include "llvm/ADT/Statistic.h"
  37 #include "llvm/Support/CrashRecoveryContext.h"
  38 #include "llvm/Support/Errc.h"
  39 #include "llvm/Support/FileSystem.h"
  40 #include "llvm/Support/Host.h"
  41 #include "llvm/Support/LockFileManager.h"
  42 #include "llvm/Support/MemoryBuffer.h"
  43 #include "llvm/Support/Path.h"
  44 #include "llvm/Support/Program.h"
  45 #include "llvm/Support/Signals.h"
  46 #include "llvm/Support/Timer.h"
  47 #include "llvm/Support/raw_ostream.h"
  48 #include <sys/stat.h>
  49 #include <system_error>
  50 #include <time.h>
  51
  52 using namespace clang;
  53
  54 CompilerInstance::CompilerInstance(bool BuildingModule)
  55   : ModuleLoader(BuildingModule),
  56     Invocation(new CompilerInvocation()), ModuleManager(nullptr),
  57     BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false),
  58     ModuleBuildFailed(false) {
  59 }
  60
  61 CompilerInstance::~CompilerInstance() {
  62   assert(OutputFiles.empty() && "Still output files in flight?");
  63 }
  64
  65 void CompilerInstance::setInvocation(CompilerInvocation *Value) {
  66   Invocation = Value;
  67 }
  68
  69 bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
  70   return (BuildGlobalModuleIndex ||
  71           (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
  72            getFrontendOpts().GenerateGlobalModuleIndex)) &&
  73          !ModuleBuildFailed;
  74 }
  75
  76 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
  77   Diagnostics = Value;
  78 }
  79
  80 void CompilerInstance::setTarget(TargetInfo *Value) {
  81   Target = Value;
  82 }
  83
  84 void CompilerInstance::setFileManager(FileManager *Value) {
  85   FileMgr = Value;
  86   if (Value)
  87     VirtualFileSystem = Value->getVirtualFileSystem();
  88   else
  89     VirtualFileSystem.reset();
  90 }
  91
  92 void CompilerInstance::setSourceManager(SourceManager *Value) {
  93   SourceMgr = Value;
  94 }
  95
  96 void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
  97
  98 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
  99
 100 void CompilerInstance::setSema(Sema *S) {
 101   TheSema.reset(S);
 102 }
 103
 104 void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
 105   Consumer = std::move(Value);
 106 }
 107
 108 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
 109   CompletionConsumer.reset(Value);
 110 }
 111
 112 std::unique_ptr<Sema> CompilerInstance::takeSema() {
 113   return std::move(TheSema);
 114 }
 115
 116 IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
 117   return ModuleManager;
 118 }
 119 void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
 120   ModuleManager = Reader;
 121 }
 122
 123 std::shared_ptr<ModuleDependencyCollector>
 124 CompilerInstance::getModuleDepCollector() const {
 125   return ModuleDepCollector;
 126 }
 127
 128 void CompilerInstance::setModuleDepCollector(
 129     std::shared_ptr<ModuleDependencyCollector> Collector) {
 130   ModuleDepCollector = Collector;
 131 }
 132
 133 // Diagnostics
 134 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
 135                                const CodeGenOptions *CodeGenOpts,
 136                                DiagnosticsEngine &Diags) {
 137   std::error_code EC;
 138   std::unique_ptr<raw_ostream> StreamOwner;
 139   raw_ostream *OS = &llvm::errs();
 140   if (DiagOpts->DiagnosticLogFile != "-") {
 141     // Create the output stream.
 142     auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
 143         DiagOpts->DiagnosticLogFile, EC,
 144         llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
 145     if (EC) {
 146       Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
 147           << DiagOpts->DiagnosticLogFile << EC.message();
 148     } else {
 149       FileOS->SetUnbuffered();
 150       FileOS->SetUseAtomicWrites(true);
 151       OS = FileOS.get();
 152       StreamOwner = std::move(FileOS);
 153     }
 154   }
 155
 156   // Chain in the diagnostic client which will log the diagnostics.
 157   auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
 158                                                         std::move(StreamOwner));
 159   if (CodeGenOpts)
 160     Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
 161   assert(Diags.ownsClient());
 162   Diags.setClient(new ChainedDiagnosticConsumer(
 163       std::unique_ptr<DiagnosticConsumer>(Diags.takeClient()),
 164       std::move(Logger)));
 165 }
 166
 167 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
 168                                        DiagnosticsEngine &Diags,
 169                                        StringRef OutputFile) {
 170   std::error_code EC;
 171   auto OS = llvm::make_unique<llvm::raw_fd_ostream>(OutputFile.str(), EC,
 172                                                     llvm::sys::fs::F_None);
 173
 174   if (EC) {
 175     Diags.Report(diag::warn_fe_serialized_diag_failure) << OutputFile
 176                                                         << EC.message();
 177     return;
 178   }
 179
 180   auto SerializedConsumer =
 181       clang::serialized_diags::create(std::move(OS), DiagOpts);
 182
 183   assert(Diags.ownsClient());
 184   Diags.setClient(new ChainedDiagnosticConsumer(
 185       std::unique_ptr<DiagnosticConsumer>(Diags.takeClient()),
 186       std::move(SerializedConsumer)));
 187 }
 188
 189 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
 190                                          bool ShouldOwnClient) {
 191   Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
 192                                   ShouldOwnClient, &getCodeGenOpts());
 193 }
 194
 195 IntrusiveRefCntPtr<DiagnosticsEngine>
 196 CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
 197                                     DiagnosticConsumer *Client,
 198                                     bool ShouldOwnClient,
 199                                     const CodeGenOptions *CodeGenOpts) {
 200   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
 201   IntrusiveRefCntPtr<DiagnosticsEngine>
 202       Diags(new DiagnosticsEngine(DiagID, Opts));
 203
 204   // Create the diagnostic client for reporting errors or for
 205   // implementing -verify.
 206   if (Client) {
 207     Diags->setClient(Client, ShouldOwnClient);
 208   } else
 209     Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
 210
 211   // Chain in -verify checker, if requested.
 212   if (Opts->VerifyDiagnostics)
 213     Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
 214
 215   // Chain in -diagnostic-log-file dumper, if requested.
 216   if (!Opts->DiagnosticLogFile.empty())
 217     SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
 218
 219   if (!Opts->DiagnosticSerializationFile.empty())
 220     SetupSerializedDiagnostics(Opts, *Diags,
 221                                Opts->DiagnosticSerializationFile);
 222
 223   // Configure our handling of diagnostics.
 224   ProcessWarningOptions(*Diags, *Opts);
 225
 226   return Diags;
 227 }
 228
 229 // File Manager
 230
 231 void CompilerInstance::createFileManager() {
 232   if (!hasVirtualFileSystem()) {
 233     // TODO: choose the virtual file system based on the CompilerInvocation.
 234     setVirtualFileSystem(vfs::getRealFileSystem());
 235   }
 236   FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
 237 }
 238
 239 // Source Manager
 240
 241 void CompilerInstance::createSourceManager(FileManager &FileMgr) {
 242   SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
 243 }
 244
 245 // Initialize the remapping of files to alternative contents, e.g.,
 246 // those specified through other files.
 247 static void InitializeFileRemapping(DiagnosticsEngine &Diags,
 248                                     SourceManager &SourceMgr,
 249                                     FileManager &FileMgr,
 250                                     const PreprocessorOptions &InitOpts) {
 251   // Remap files in the source manager (with buffers).
 252   for (const auto &RB : InitOpts.RemappedFileBuffers) {
 253     // Create the file entry for the file that we're mapping from.
 254     const FileEntry *FromFile =
 255         FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
 256     if (!FromFile) {
 257       Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
 258       if (!InitOpts.RetainRemappedFileBuffers)
 259         delete RB.second;
 260       continue;
 261     }
 262
 263     // Override the contents of the "from" file with the contents of
 264     // the "to" file.
 265     SourceMgr.overrideFileContents(FromFile, RB.second,
 266                                    InitOpts.RetainRemappedFileBuffers);
 267   }
 268
 269   // Remap files in the source manager (with other files).
 270   for (const auto &RF : InitOpts.RemappedFiles) {
 271     // Find the file that we're mapping to.
 272     const FileEntry *ToFile = FileMgr.getFile(RF.second);
 273     if (!ToFile) {
 274       Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
 275       continue;
 276     }
 277
 278     // Create the file entry for the file that we're mapping from.
 279     const FileEntry *FromFile =
 280         FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
 281     if (!FromFile) {
 282       Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
 283       continue;
 284     }
 285
 286     // Override the contents of the "from" file with the contents of
 287     // the "to" file.
 288     SourceMgr.overrideFileContents(FromFile, ToFile);
 289   }
 290
 291   SourceMgr.setOverridenFilesKeepOriginalName(
 292       InitOpts.RemappedFilesKeepOriginalName);
 293 }
 294
 295 // Preprocessor
 296
 297 void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
 298   const PreprocessorOptions &PPOpts = getPreprocessorOpts();
 299
 300   // Create a PTH manager if we are using some form of a token cache.
 301   PTHManager *PTHMgr = nullptr;
 302   if (!PPOpts.TokenCache.empty())
 303     PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
 304
 305   // Create the Preprocessor.
 306   HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
 307                                               getSourceManager(),
 308                                               getDiagnostics(),
 309                                               getLangOpts(),
 310                                               &getTarget());
 311   PP = new Preprocessor(&getPreprocessorOpts(), getDiagnostics(), getLangOpts(),
 312                         getSourceManager(), *HeaderInfo, *this, PTHMgr,
 313                         /*OwnsHeaderSearch=*/true, TUKind);
 314   PP->Initialize(getTarget());
 315
 316   // Note that this is different then passing PTHMgr to Preprocessor's ctor.
 317   // That argument is used as the IdentifierInfoLookup argument to
 318   // IdentifierTable's ctor.
 319   if (PTHMgr) {
 320     PTHMgr->setPreprocessor(&*PP);
 321     PP->setPTHManager(PTHMgr);
 322   }
 323
 324   if (PPOpts.DetailedRecord)
 325     PP->createPreprocessingRecord();
 326
 327   // Apply remappings to the source manager.
 328   InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
 329                           PP->getFileManager(), PPOpts);
 330
 331   // Predefine macros and configure the preprocessor.
 332   InitializePreprocessor(*PP, PPOpts, getFrontendOpts());
 333
 334   // Initialize the header search object.
 335   ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
 336                            PP->getLangOpts(), PP->getTargetInfo().getTriple());
 337
 338   PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
 339
 340   // Set up the module path, including the hash for the
 341   // module-creation options.
 342   SmallString<256> SpecificModuleCache(
 343                            getHeaderSearchOpts().ModuleCachePath);
 344   if (!getHeaderSearchOpts().DisableModuleHash)
 345     llvm::sys::path::append(SpecificModuleCache,
 346                             getInvocation().getModuleHash());
 347   PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
 348
 349   // Handle generating dependencies, if requested.
 350   const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
 351   if (!DepOpts.OutputFile.empty())
 352     TheDependencyFileGenerator.reset(
 353         DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
 354   if (!DepOpts.DOTOutputFile.empty())
 355     AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
 356                              getHeaderSearchOpts().Sysroot);
 357
 358   for (auto &Listener : DependencyCollectors)
 359     Listener->attachToPreprocessor(*PP);
 360
 361   // If we don't have a collector, but we are collecting module dependencies,
 362   // then we're the top level compiler instance and need to create one.
 363   if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty())
 364     ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
 365         DepOpts.ModuleDependencyOutputDir);
 366
 367   // Handle generating header include information, if requested.
 368   if (DepOpts.ShowHeaderIncludes)
 369     AttachHeaderIncludeGen(*PP);
 370   if (!DepOpts.HeaderIncludeOutputFile.empty()) {
 371     StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
 372     if (OutputPath == "-")
 373       OutputPath = "";
 374     AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
 375                            /*ShowDepth=*/false);
 376   }
 377
 378   if (DepOpts.PrintShowIncludes) {
 379     AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
 380                            /*ShowDepth=*/true, /*MSStyle=*/true);
 381   }
 382 }
 383
 384 // ASTContext
 385
 386 void CompilerInstance::createASTContext() {
 387   Preprocessor &PP = getPreprocessor();
 388   Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
 389                            PP.getIdentifierTable(), PP.getSelectorTable(),
 390                            PP.getBuiltinInfo());
 391   Context->InitBuiltinTypes(getTarget());
 392 }
 393
 394 // ExternalASTSource
 395
 396 void CompilerInstance::createPCHExternalASTSource(
 397     StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
 398     void *DeserializationListener, bool OwnDeserializationListener) {
 399   IntrusiveRefCntPtr<ExternalASTSource> Source;
 400   bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
 401   Source = createPCHExternalASTSource(
 402       Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
 403       AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
 404       DeserializationListener, OwnDeserializationListener, Preamble,
 405       getFrontendOpts().UseGlobalModuleIndex);
 406   ModuleManager = static_cast<ASTReader*>(Source.get());
 407   getASTContext().setExternalSource(Source);
 408 }
 409
 410 ExternalASTSource *CompilerInstance::createPCHExternalASTSource(
 411     StringRef Path, const std::string &Sysroot, bool DisablePCHValidation,
 412     bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
 413     void *DeserializationListener, bool OwnDeserializationListener,
 414     bool Preamble, bool UseGlobalModuleIndex) {
 415   HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
 416
 417   std::unique_ptr<ASTReader> Reader;
 418   Reader.reset(new ASTReader(PP, Context,
 419                              Sysroot.empty() ? "" : Sysroot.c_str(),
 420                              DisablePCHValidation,
 421                              AllowPCHWithCompilerErrors,
 422                              /*AllowConfigurationMismatch*/false,
 423                              HSOpts.ModulesValidateSystemHeaders,
 424                              UseGlobalModuleIndex));
 425
 426   Reader->setDeserializationListener(
 427       static_cast<ASTDeserializationListener *>(DeserializationListener),
 428       /*TakeOwnership=*/OwnDeserializationListener);
 429   switch (Reader->ReadAST(Path,
 430                           Preamble ? serialization::MK_Preamble
 431                                    : serialization::MK_PCH,
 432                           SourceLocation(),
 433                           ASTReader::ARR_None)) {
 434   case ASTReader::Success:
 435     // Set the predefines buffer as suggested by the PCH reader. Typically, the
 436     // predefines buffer will be empty.
 437     PP.setPredefines(Reader->getSuggestedPredefines());
 438     return Reader.release();
 439
 440   case ASTReader::Failure:
 441     // Unrecoverable failure: don't even try to process the input file.
 442     break;
 443
 444   case ASTReader::Missing:
 445   case ASTReader::OutOfDate:
 446   case ASTReader::VersionMismatch:
 447   case ASTReader::ConfigurationMismatch:
 448   case ASTReader::HadErrors:
 449     // No suitable PCH file could be found. Return an error.
 450     break;
 451   }
 452
 453   return nullptr;
 454 }
 455
 456 // Code Completion
 457
 458 static bool EnableCodeCompletion(Preprocessor &PP,
 459                                  const std::string &Filename,
 460                                  unsigned Line,
 461                                  unsigned Column) {
 462   // Tell the source manager to chop off the given file at a specific
 463   // line and column.
 464   const FileEntry *Entry = PP.getFileManager().getFile(Filename);
 465   if (!Entry) {
 466     PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
 467       << Filename;
 468     return true;
 469   }
 470
 471   // Truncate the named file at the given line/column.
 472   PP.SetCodeCompletionPoint(Entry, Line, Column);
 473   return false;
 474 }
 475
 476 void CompilerInstance::createCodeCompletionConsumer() {
 477   const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
 478   if (!CompletionConsumer) {
 479     setCodeCompletionConsumer(
 480       createCodeCompletionConsumer(getPreprocessor(),
 481                                    Loc.FileName, Loc.Line, Loc.Column,
 482                                    getFrontendOpts().CodeCompleteOpts,
 483                                    llvm::outs()));
 484     if (!CompletionConsumer)
 485       return;
 486   } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
 487                                   Loc.Line, Loc.Column)) {
 488     setCodeCompletionConsumer(nullptr);
 489     return;
 490   }
 491
 492   if (CompletionConsumer->isOutputBinary() &&
 493       llvm::sys::ChangeStdoutToBinary()) {
 494     getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
 495     setCodeCompletionConsumer(nullptr);
 496   }
 497 }
 498
 499 void CompilerInstance::createFrontendTimer() {
 500   FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
 501 }
 502
 503 CodeCompleteConsumer *
 504 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
 505                                                const std::string &Filename,
 506                                                unsigned Line,
 507                                                unsigned Column,
 508                                                const CodeCompleteOptions &Opts,
 509                                                raw_ostream &OS) {
 510   if (EnableCodeCompletion(PP, Filename, Line, Column))
 511     return nullptr;
 512
 513   // Set up the creation routine for code-completion.
 514   return new PrintingCodeCompleteConsumer(Opts, OS);
 515 }
 516
 517 void CompilerInstance::createSema(TranslationUnitKind TUKind,
 518                                   CodeCompleteConsumer *CompletionConsumer) {
 519   TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
 520                          TUKind, CompletionConsumer));
 521 }
 522
 523 // Output Files
 524
 525 void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
 526   assert(OutFile.OS && "Attempt to add empty stream to output list!");
 527   OutputFiles.push_back(OutFile);
 528 }
 529
 530 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
 531   for (std::list<OutputFile>::iterator
 532          it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
 533     delete it->OS;
 534     if (!it->TempFilename.empty()) {
 535       if (EraseFiles) {
 536         llvm::sys::fs::remove(it->TempFilename);
 537       } else {
 538         SmallString<128> NewOutFile(it->Filename);
 539
 540         // If '-working-directory' was passed, the output filename should be
 541         // relative to that.
 542         FileMgr->FixupRelativePath(NewOutFile);
 543         if (std::error_code ec =
 544                 llvm::sys::fs::rename(it->TempFilename, NewOutFile.str())) {
 545           getDiagnostics().Report(diag::err_unable_to_rename_temp)
 546             << it->TempFilename << it->Filename << ec.message();
 547
 548           llvm::sys::fs::remove(it->TempFilename);
 549         }
 550       }
 551     } else if (!it->Filename.empty() && EraseFiles)
 552       llvm::sys::fs::remove(it->Filename);
 553
 554   }
 555   OutputFiles.clear();
 556 }
 557
 558 llvm::raw_fd_ostream *
 559 CompilerInstance::createDefaultOutputFile(bool Binary,
 560                                           StringRef InFile,
 561                                           StringRef Extension) {
 562   return createOutputFile(getFrontendOpts().OutputFile, Binary,
 563                           /*RemoveFileOnSignal=*/true, InFile, Extension,
 564                           /*UseTemporary=*/true);
 565 }
 566
 567 llvm::raw_null_ostream *CompilerInstance::createNullOutputFile() {
 568   llvm::raw_null_ostream *OS = new llvm::raw_null_ostream();
 569   addOutputFile(OutputFile("", "", OS));
 570   return OS;
 571 }
 572
 573 llvm::raw_fd_ostream *
 574 CompilerInstance::createOutputFile(StringRef OutputPath,
 575                                    bool Binary, bool RemoveFileOnSignal,
 576                                    StringRef InFile,
 577                                    StringRef Extension,
 578                                    bool UseTemporary,
 579                                    bool CreateMissingDirectories) {
 580   std::string OutputPathName, TempPathName;
 581   std::error_code EC;
 582   llvm::raw_fd_ostream *OS = createOutputFile(
 583       OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
 584       UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
 585   if (!OS) {
 586     getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
 587                                                                 << EC.message();
 588     return nullptr;
 589   }
 590
 591   // Add the output file -- but don't try to remove "-", since this means we are
 592   // using stdin.
 593   addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
 594                 TempPathName, OS));
 595
 596   return OS;
 597 }
 598
 599 llvm::raw_fd_ostream *CompilerInstance::createOutputFile(
 600     StringRef OutputPath, std::error_code &Error, bool Binary,
 601     bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
 602     bool UseTemporary, bool CreateMissingDirectories,
 603     std::string *ResultPathName, std::string *TempPathName) {
 604   assert((!CreateMissingDirectories || UseTemporary) &&
 605          "CreateMissingDirectories is only allowed when using temporary files");
 606
 607   std::string OutFile, TempFile;
 608   if (!OutputPath.empty()) {
 609     OutFile = OutputPath;
 610   } else if (InFile == "-") {
 611     OutFile = "-";
 612   } else if (!Extension.empty()) {
 613     SmallString<128> Path(InFile);
 614     llvm::sys::path::replace_extension(Path, Extension);
 615     OutFile = Path.str();
 616   } else {
 617     OutFile = "-";
 618   }
 619
 620   std::unique_ptr<llvm::raw_fd_ostream> OS;
 621   std::string OSFile;
 622
 623   if (UseTemporary) {
 624     if (OutFile == "-")
 625       UseTemporary = false;
 626     else {
 627       llvm::sys::fs::file_status Status;
 628       llvm::sys::fs::status(OutputPath, Status);
 629       if (llvm::sys::fs::exists(Status)) {
 630         // Fail early if we can't write to the final destination.
 631         if (!llvm::sys::fs::can_write(OutputPath))
 632           return nullptr;
 633
 634         // Don't use a temporary if the output is a special file. This handles
 635         // things like '-o /dev/null'
 636         if (!llvm::sys::fs::is_regular_file(Status))
 637           UseTemporary = false;
 638       }
 639     }
 640   }
 641
 642   if (UseTemporary) {
 643     // Create a temporary file.
 644     SmallString<128> TempPath;
 645     TempPath = OutFile;
 646     TempPath += "-%%%%%%%%";
 647     int fd;
 648     std::error_code EC =
 649         llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
 650
 651     if (CreateMissingDirectories &&
 652         EC == llvm::errc::no_such_file_or_directory) {
 653       StringRef Parent = llvm::sys::path::parent_path(OutputPath);
 654       EC = llvm::sys::fs::create_directories(Parent);
 655       if (!EC) {
 656         EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
 657       }
 658     }
 659
 660     if (!EC) {
 661       OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
 662       OSFile = TempFile = TempPath.str();
 663     }
 664     // If we failed to create the temporary, fallback to writing to the file
 665     // directly. This handles the corner case where we cannot write to the
 666     // directory, but can write to the file.
 667   }
 668
 669   if (!OS) {
 670     OSFile = OutFile;
 671     OS.reset(new llvm::raw_fd_ostream(
 672         OSFile, Error,
 673         (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
 674     if (Error)
 675       return nullptr;
 676   }
 677
 678   // Make sure the out stream file gets removed if we crash.
 679   if (RemoveFileOnSignal)
 680     llvm::sys::RemoveFileOnSignal(OSFile);
 681
 682   if (ResultPathName)
 683     *ResultPathName = OutFile;
 684   if (TempPathName)
 685     *TempPathName = TempFile;
 686
 687   return OS.release();
 688 }
 689
 690 // Initialization Utilities
 691
 692 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
 693   return InitializeSourceManager(Input, getDiagnostics(),
 694                                  getFileManager(), getSourceManager(),
 695                                  getFrontendOpts());
 696 }
 697
 698 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
 699                                                DiagnosticsEngine &Diags,
 700                                                FileManager &FileMgr,
 701                                                SourceManager &SourceMgr,
 702                                                const FrontendOptions &Opts) {
 703   SrcMgr::CharacteristicKind
 704     Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
 705
 706   if (Input.isBuffer()) {
 707     SourceMgr.setMainFileID(SourceMgr.createFileID(
 708         std::unique_ptr<llvm::MemoryBuffer>(Input.getBuffer()), Kind));
 709     assert(!SourceMgr.getMainFileID().isInvalid() &&
 710            "Couldn't establish MainFileID!");
 711     return true;
 712   }
 713
 714   StringRef InputFile = Input.getFile();
 715
 716   // Figure out where to get and map in the main file.
 717   if (InputFile != "-") {
 718     const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
 719     if (!File) {
 720       Diags.Report(diag::err_fe_error_reading) << InputFile;
 721       return false;
 722     }
 723
 724     // The natural SourceManager infrastructure can't currently handle named
 725     // pipes, but we would at least like to accept them for the main
 726     // file. Detect them here, read them with the volatile flag so FileMgr will
 727     // pick up the correct size, and simply override their contents as we do for
 728     // STDIN.
 729     if (File->isNamedPipe()) {
 730       std::string ErrorStr;
 731       if (std::unique_ptr<llvm::MemoryBuffer> MB =
 732               FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) {
 733         // Create a new virtual file that will have the correct size.
 734         File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
 735         SourceMgr.overrideFileContents(File, std::move(MB));
 736       } else {
 737         Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr;
 738         return false;
 739       }
 740     }
 741
 742     SourceMgr.setMainFileID(
 743         SourceMgr.createFileID(File, SourceLocation(), Kind));
 744   } else {
 745     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
 746         llvm::MemoryBuffer::getSTDIN();
 747     if (std::error_code EC = SBOrErr.getError()) {
 748       Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
 749       return false;
 750     }
 751     std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
 752
 753     const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
 754                                                    SB->getBufferSize(), 0);
 755     SourceMgr.setMainFileID(
 756         SourceMgr.createFileID(File, SourceLocation(), Kind));
 757     SourceMgr.overrideFileContents(File, std::move(SB));
 758   }
 759
 760   assert(!SourceMgr.getMainFileID().isInvalid() &&
 761          "Couldn't establish MainFileID!");
 762   return true;
 763 }
 764
 765 // High-Level Operations
 766
 767 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
 768   assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
 769   assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
 770   assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
 771
 772   // FIXME: Take this as an argument, once all the APIs we used have moved to
 773   // taking it as an input instead of hard-coding llvm::errs.
 774   raw_ostream &OS = llvm::errs();
 775
 776   // Create the target instance.
 777   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
 778                                          getInvocation().TargetOpts));
 779   if (!hasTarget())
 780     return false;
 781
 782   // Inform the target of the language options.
 783   //
 784   // FIXME: We shouldn't need to do this, the target should be immutable once
 785   // created. This complexity should be lifted elsewhere.
 786   getTarget().adjust(getLangOpts());
 787
 788   // rewriter project will change target built-in bool type from its default.
 789   if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
 790     getTarget().noSignedCharForObjCBool();
 791
 792   // Validate/process some options.
 793   if (getHeaderSearchOpts().Verbose)
 794     OS << "clang -cc1 version " CLANG_VERSION_STRING
 795        << " based upon " << BACKEND_PACKAGE_STRING
 796        << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
 797
 798   if (getFrontendOpts().ShowTimers)
 799     createFrontendTimer();
 800
 801   if (getFrontendOpts().ShowStats)
 802     llvm::EnableStatistics();
 803
 804   for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
 805     // Reset the ID tables if we are reusing the SourceManager and parsing
 806     // regular files.
 807     if (hasSourceManager() && !Act.isModelParsingAction())
 808       getSourceManager().clearIDTables();
 809
 810     if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
 811       Act.Execute();
 812       Act.EndSourceFile();
 813     }
 814   }
 815
 816   // Notify the diagnostic client that all files were processed.
 817   getDiagnostics().getClient()->finish();
 818
 819   if (getDiagnosticOpts().ShowCarets) {
 820     // We can have multiple diagnostics sharing one diagnostic client.
 821     // Get the total number of warnings/errors from the client.
 822     unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
 823     unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
 824
 825     if (NumWarnings)
 826       OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
 827     if (NumWarnings && NumErrors)
 828       OS << " and ";
 829     if (NumErrors)
 830       OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
 831     if (NumWarnings || NumErrors)
 832       OS << " generated.\n";
 833   }
 834
 835   if (getFrontendOpts().ShowStats && hasFileManager()) {
 836     getFileManager().PrintStats();
 837     OS << "\n";
 838   }
 839
 840   return !getDiagnostics().getClient()->getNumErrors();
 841 }
 842
 843 /// \brief Determine the appropriate source input kind based on language
 844 /// options.
 845 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
 846   if (LangOpts.OpenCL)
 847     return IK_OpenCL;
 848   if (LangOpts.CUDA)
 849     return IK_CUDA;
 850   if (LangOpts.ObjC1)
 851     return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
 852   return LangOpts.CPlusPlus? IK_CXX : IK_C;
 853 }
 854
 855 /// \brief Compile a module file for the given module, using the options
 856 /// provided by the importing compiler instance. Returns true if the module
 857 /// was built without errors.
 858 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
 859                               SourceLocation ImportLoc,
 860                               Module *Module,
 861                               StringRef ModuleFileName) {
 862   ModuleMap &ModMap
 863     = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
 864
 865   // Construct a compiler invocation for creating this module.
 866   IntrusiveRefCntPtr<CompilerInvocation> Invocation
 867     (new CompilerInvocation(ImportingInstance.getInvocation()));
 868
 869   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
 870
 871   // For any options that aren't intended to affect how a module is built,
 872   // reset them to their default values.
 873   Invocation->getLangOpts()->resetNonModularOptions();
 874   PPOpts.resetNonModularOptions();
 875
 876   // Remove any macro definitions that are explicitly ignored by the module.
 877   // They aren't supposed to affect how the module is built anyway.
 878   const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
 879   PPOpts.Macros.erase(
 880       std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
 881                      [&HSOpts](const std::pair<std::string, bool> &def) {
 882         StringRef MacroDef = def.first;
 883         return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
 884       }),
 885       PPOpts.Macros.end());
 886
 887   // Note the name of the module we're building.
 888   Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
 889
 890   // Make sure that the failed-module structure has been allocated in
 891   // the importing instance, and propagate the pointer to the newly-created
 892   // instance.
 893   PreprocessorOptions &ImportingPPOpts
 894     = ImportingInstance.getInvocation().getPreprocessorOpts();
 895   if (!ImportingPPOpts.FailedModules)
 896     ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
 897   PPOpts.FailedModules = ImportingPPOpts.FailedModules;
 898
 899   // If there is a module map file, build the module using the module map.
 900   // Set up the inputs/outputs so that we build the module from its umbrella
 901   // header.
 902   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
 903   FrontendOpts.OutputFile = ModuleFileName.str();
 904   FrontendOpts.DisableFree = false;
 905   FrontendOpts.GenerateGlobalModuleIndex = false;
 906   FrontendOpts.Inputs.clear();
 907   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
 908
 909   // Don't free the remapped file buffers; they are owned by our caller.
 910   PPOpts.RetainRemappedFileBuffers = true;
 911
 912   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
 913   assert(ImportingInstance.getInvocation().getModuleHash() ==
 914          Invocation->getModuleHash() && "Module hash mismatch!");
 915
 916   // Construct a compiler instance that will be used to actually create the
 917   // module.
 918   CompilerInstance Instance(/*BuildingModule=*/true);
 919   Instance.setInvocation(&*Invocation);
 920
 921   Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
 922                                    ImportingInstance.getDiagnosticClient()),
 923                              /*ShouldOwnClient=*/true);
 924
 925   Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
 926
 927   // Note that this module is part of the module build stack, so that we
 928   // can detect cycles in the module graph.
 929   Instance.setFileManager(&ImportingInstance.getFileManager());
 930   Instance.createSourceManager(Instance.getFileManager());
 931   SourceManager &SourceMgr = Instance.getSourceManager();
 932   SourceMgr.setModuleBuildStack(
 933     ImportingInstance.getSourceManager().getModuleBuildStack());
 934   SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
 935     FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
 936
 937   // If we're collecting module dependencies, we need to share a collector
 938   // between all of the module CompilerInstances.
 939   Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
 940
 941   // Get or create the module map that we'll use to build this module.
 942   std::string InferredModuleMapContent;
 943   if (const FileEntry *ModuleMapFile =
 944           ModMap.getContainingModuleMapFile(Module)) {
 945     // Use the module map where this module resides.
 946     FrontendOpts.Inputs.push_back(
 947         FrontendInputFile(ModuleMapFile->getName(), IK));
 948   } else {
 949     llvm::raw_string_ostream OS(InferredModuleMapContent);
 950     Module->print(OS);
 951     OS.flush();
 952     FrontendOpts.Inputs.push_back(
 953         FrontendInputFile("__inferred_module.map", IK));
 954
 955     std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
 956         llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
 957     ModuleMapFile = Instance.getFileManager().getVirtualFile(
 958         "__inferred_module.map", InferredModuleMapContent.size(), 0);
 959     SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
 960   }
 961
 962   // Construct a module-generating action. Passing through the module map is
 963   // safe because the FileManager is shared between the compiler instances.
 964   GenerateModuleAction CreateModuleAction(
 965       ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
 966
 967   // Execute the action to actually build the module in-place. Use a separate
 968   // thread so that we get a stack large enough.
 969   const unsigned ThreadStackSize = 8 << 20;
 970   llvm::CrashRecoveryContext CRC;
 971   CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
 972                         ThreadStackSize);
 973
 974   // Delete the temporary module map file.
 975   // FIXME: Even though we're executing under crash protection, it would still
 976   // be nice to do this with RemoveFileOnSignal when we can. However, that
 977   // doesn't make sense for all clients, so clean this up manually.
 978   Instance.clearOutputFiles(/*EraseFiles=*/true);
 979
 980   // We've rebuilt a module. If we're allowed to generate or update the global
 981   // module index, record that fact in the importing compiler instance.
 982   if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
 983     ImportingInstance.setBuildGlobalModuleIndex(true);
 984   }
 985
 986   return !Instance.getDiagnostics().hasErrorOccurred();
 987 }
 988
 989 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
 990                                  SourceLocation ImportLoc,
 991                                  SourceLocation ModuleNameLoc, Module *Module,
 992                                  StringRef ModuleFileName) {
 993   DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
 994
 995   auto diagnoseBuildFailure = [&] {
 996     Diags.Report(ModuleNameLoc, diag::err_module_not_built)
 997         << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
 998   };
 999
1000   // FIXME: have LockFileManager return an error_code so that we can
1001   // avoid the mkdir when the directory already exists.
1002   StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1003   llvm::sys::fs::create_directories(Dir);
1004
1005   while (1) {
1006     unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1007     llvm::LockFileManager Locked(ModuleFileName);
1008     switch (Locked) {
1009     case llvm::LockFileManager::LFS_Error:
1010       Diags.Report(ModuleNameLoc, diag::err_module_lock_failure)
1011           << Module->Name;
1012       return false;
1013
1014     case llvm::LockFileManager::LFS_Owned:
1015       // We're responsible for building the module ourselves.
1016       if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1017                              ModuleFileName)) {
1018         diagnoseBuildFailure();
1019         return false;
1020       }
1021       break;
1022
1023     case llvm::LockFileManager::LFS_Shared:
1024       // Someone else is responsible for building the module. Wait for them to
1025       // finish.
1026       if (Locked.waitForUnlock() == llvm::LockFileManager::Res_OwnerDied)
1027         continue; // try again to get the lock.
1028       ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1029       break;
1030     }
1031
1032     // Try to read the module file, now that we've compiled it.
1033     ASTReader::ASTReadResult ReadResult =
1034         ImportingInstance.getModuleManager()->ReadAST(
1035             ModuleFileName, serialization::MK_Module, ImportLoc,
1036             ModuleLoadCapabilities);
1037
1038     if (ReadResult == ASTReader::OutOfDate &&
1039         Locked == llvm::LockFileManager::LFS_Shared) {
1040       // The module may be out of date in the presence of file system races,
1041       // or if one of its imports depends on header search paths that are not
1042       // consistent with this ImportingInstance.  Try again...
1043       continue;
1044     } else if (ReadResult == ASTReader::Missing) {
1045       diagnoseBuildFailure();
1046     } else if (ReadResult != ASTReader::Success &&
1047                !Diags.hasErrorOccurred()) {
1048       // The ASTReader didn't diagnose the error, so conservatively report it.
1049       diagnoseBuildFailure();
1050     }
1051     return ReadResult == ASTReader::Success;
1052   }
1053 }
1054
1055 /// \brief Diagnose differences between the current definition of the given
1056 /// configuration macro and the definition provided on the command line.
1057 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1058                              Module *Mod, SourceLocation ImportLoc) {
1059   IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1060   SourceManager &SourceMgr = PP.getSourceManager();
1061
1062   // If this identifier has never had a macro definition, then it could
1063   // not have changed.
1064   if (!Id->hadMacroDefinition())
1065     return;
1066
1067   // If this identifier does not currently have a macro definition,
1068   // check whether it had one on the command line.
1069   if (!Id->hasMacroDefinition()) {
1070     MacroDirective::DefInfo LatestDef =
1071         PP.getMacroDirectiveHistory(Id)->getDefinition();
1072     for (MacroDirective::DefInfo Def = LatestDef; Def;
1073            Def = Def.getPreviousDefinition()) {
1074       FileID FID = SourceMgr.getFileID(Def.getLocation());
1075       if (FID.isInvalid())
1076         continue;
1077
1078       // We only care about the predefines buffer.
1079       if (FID != PP.getPredefinesFileID())
1080         continue;
1081
1082       // This macro was defined on the command line, then #undef'd later.
1083       // Complain.
1084       PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1085         << true << ConfigMacro << Mod->getFullModuleName();
1086       if (LatestDef.isUndefined())
1087         PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1088           << true;
1089       return;
1090     }
1091
1092     // Okay: no definition in the predefines buffer.
1093     return;
1094   }
1095
1096   // This identifier has a macro definition. Check whether we had a definition
1097   // on the command line.
1098   MacroDirective::DefInfo LatestDef =
1099       PP.getMacroDirectiveHistory(Id)->getDefinition();
1100   MacroDirective::DefInfo PredefinedDef;
1101   for (MacroDirective::DefInfo Def = LatestDef; Def;
1102          Def = Def.getPreviousDefinition()) {
1103     FileID FID = SourceMgr.getFileID(Def.getLocation());
1104     if (FID.isInvalid())
1105       continue;
1106
1107     // We only care about the predefines buffer.
1108     if (FID != PP.getPredefinesFileID())
1109       continue;
1110
1111     PredefinedDef = Def;
1112     break;
1113   }
1114
1115   // If there was no definition for this macro in the predefines buffer,
1116   // complain.
1117   if (!PredefinedDef ||
1118       (!PredefinedDef.getLocation().isValid() &&
1119        PredefinedDef.getUndefLocation().isValid())) {
1120     PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1121       << false << ConfigMacro << Mod->getFullModuleName();
1122     PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
1123       << false;
1124     return;
1125   }
1126
1127   // If the current macro definition is the same as the predefined macro
1128   // definition, it's okay.
1129   if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
1130       LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
1131                                               /*Syntactically=*/true))
1132     return;
1133
1134   // The macro definitions differ.
1135   PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1136     << false << ConfigMacro << Mod->getFullModuleName();
1137   PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
1138     << false;
1139 }
1140
1141 /// \brief Write a new timestamp file with the given path.
1142 static void writeTimestampFile(StringRef TimestampFile) {
1143   std::error_code EC;
1144   llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1145 }
1146
1147 /// \brief Prune the module cache of modules that haven't been accessed in
1148 /// a long time.
1149 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1150   struct stat StatBuf;
1151   llvm::SmallString<128> TimestampFile;
1152   TimestampFile = HSOpts.ModuleCachePath;
1153   llvm::sys::path::append(TimestampFile, "modules.timestamp");
1154
1155   // Try to stat() the timestamp file.
1156   if (::stat(TimestampFile.c_str(), &StatBuf)) {
1157     // If the timestamp file wasn't there, create one now.
1158     if (errno == ENOENT) {
1159       writeTimestampFile(TimestampFile);
1160     }
1161     return;
1162   }
1163
1164   // Check whether the time stamp is older than our pruning interval.
1165   // If not, do nothing.
1166   time_t TimeStampModTime = StatBuf.st_mtime;
1167   time_t CurrentTime = time(nullptr);
1168   if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1169     return;
1170
1171   // Write a new timestamp file so that nobody else attempts to prune.
1172   // There is a benign race condition here, if two Clang instances happen to
1173   // notice at the same time that the timestamp is out-of-date.
1174   writeTimestampFile(TimestampFile);
1175
1176   // Walk the entire module cache, looking for unused module files and module
1177   // indices.
1178   std::error_code EC;
1179   SmallString<128> ModuleCachePathNative;
1180   llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1181   for (llvm::sys::fs::directory_iterator
1182          Dir(ModuleCachePathNative.str(), EC), DirEnd;
1183        Dir != DirEnd && !EC; Dir.increment(EC)) {
1184     // If we don't have a directory, there's nothing to look into.
1185     if (!llvm::sys::fs::is_directory(Dir->path()))
1186       continue;
1187
1188     // Walk all of the files within this directory.
1189     for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1190          File != FileEnd && !EC; File.increment(EC)) {
1191       // We only care about module and global module index files.
1192       StringRef Extension = llvm::sys::path::extension(File->path());
1193       if (Extension != ".pcm" && Extension != ".timestamp" &&
1194           llvm::sys::path::filename(File->path()) != "modules.idx")
1195         continue;
1196
1197       // Look at this file. If we can't stat it, there's nothing interesting
1198       // there.
1199       if (::stat(File->path().c_str(), &StatBuf))
1200         continue;
1201
1202       // If the file has been used recently enough, leave it there.
1203       time_t FileAccessTime = StatBuf.st_atime;
1204       if (CurrentTime - FileAccessTime <=
1205               time_t(HSOpts.ModuleCachePruneAfter)) {
1206         continue;
1207       }
1208
1209       // Remove the file.
1210       llvm::sys::fs::remove(File->path());
1211
1212       // Remove the timestamp file.
1213       std::string TimpestampFilename = File->path() + ".timestamp";
1214       llvm::sys::fs::remove(TimpestampFilename);
1215     }
1216
1217     // If we removed all of the files in the directory, remove the directory
1218     // itself.
1219     if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1220             llvm::sys::fs::directory_iterator() && !EC)
1221       llvm::sys::fs::remove(Dir->path());
1222   }
1223 }
1224
1225 void CompilerInstance::createModuleManager() {
1226   if (!ModuleManager) {
1227     if (!hasASTContext())
1228       createASTContext();
1229
1230     // If we're not recursively building a module, check whether we
1231     // need to prune the module cache.
1232     if (getSourceManager().getModuleBuildStack().empty() &&
1233         getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1234         getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1235       pruneModuleCache(getHeaderSearchOpts());
1236     }
1237
1238     HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1239     std::string Sysroot = HSOpts.Sysroot;
1240     const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1241     ModuleManager = new ASTReader(getPreprocessor(), *Context,
1242                                   Sysroot.empty() ? "" : Sysroot.c_str(),
1243                                   PPOpts.DisablePCHValidation,
1244                                   /*AllowASTWithCompilerErrors=*/false,
1245                                   /*AllowConfigurationMismatch=*/false,
1246                                   HSOpts.ModulesValidateSystemHeaders,
1247                                   getFrontendOpts().UseGlobalModuleIndex);
1248     if (hasASTConsumer()) {
1249       ModuleManager->setDeserializationListener(
1250         getASTConsumer().GetASTDeserializationListener());
1251       getASTContext().setASTMutationListener(
1252         getASTConsumer().GetASTMutationListener());
1253     }
1254     getASTContext().setExternalSource(ModuleManager);
1255     if (hasSema())
1256       ModuleManager->InitializeSema(getSema());
1257     if (hasASTConsumer())
1258       ModuleManager->StartTranslationUnit(&getASTConsumer());
1259   }
1260 }
1261
1262 ModuleLoadResult
1263 CompilerInstance::loadModule(SourceLocation ImportLoc,
1264                              ModuleIdPath Path,
1265                              Module::NameVisibilityKind Visibility,
1266                              bool IsInclusionDirective) {
1267   // Determine what file we're searching from.
1268   StringRef ModuleName = Path[0].first->getName();
1269   SourceLocation ModuleNameLoc = Path[0].second;
1270
1271   // If we've already handled this import, just return the cached result.
1272   // This one-element cache is important to eliminate redundant diagnostics
1273   // when both the preprocessor and parser see the same import declaration.
1274   if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1275     // Make the named module visible.
1276     if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule &&
1277         ModuleName != getLangOpts().ImplementationOfModule)
1278       ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1279                                        ImportLoc, /*Complain=*/false);
1280     return LastModuleImportResult;
1281   }
1282
1283   clang::Module *Module = nullptr;
1284
1285   // If we don't already have information on this module, load the module now.
1286   llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1287     = KnownModules.find(Path[0].first);
1288   if (Known != KnownModules.end()) {
1289     // Retrieve the cached top-level module.
1290     Module = Known->second;
1291   } else if (ModuleName == getLangOpts().CurrentModule ||
1292              ModuleName == getLangOpts().ImplementationOfModule) {
1293     // This is the module we're building.
1294     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1295     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1296   } else {
1297     // Search for a module with the given name.
1298     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1299     if (!Module) {
1300       getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1301       << ModuleName
1302       << SourceRange(ImportLoc, ModuleNameLoc);
1303       ModuleBuildFailed = true;
1304       return ModuleLoadResult();
1305     }
1306
1307     std::string ModuleFileName =
1308         PP->getHeaderSearchInfo().getModuleFileName(Module);
1309
1310     // If we don't already have an ASTReader, create one now.
1311     if (!ModuleManager)
1312       createModuleManager();
1313
1314     if (TheDependencyFileGenerator)
1315       TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1316
1317     if (ModuleDepCollector)
1318       ModuleDepCollector->attachToASTReader(*ModuleManager);
1319
1320     for (auto &Listener : DependencyCollectors)
1321       Listener->attachToASTReader(*ModuleManager);
1322
1323     // Try to load the module file.
1324     unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1325     switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1326                                    ImportLoc, ARRFlags)) {
1327     case ASTReader::Success:
1328       break;
1329
1330     case ASTReader::OutOfDate:
1331     case ASTReader::Missing: {
1332       // The module file is missing or out-of-date. Build it.
1333       assert(Module && "missing module file");
1334       // Check whether there is a cycle in the module graph.
1335       ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1336       ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1337       for (; Pos != PosEnd; ++Pos) {
1338         if (Pos->first == ModuleName)
1339           break;
1340       }
1341
1342       if (Pos != PosEnd) {
1343         SmallString<256> CyclePath;
1344         for (; Pos != PosEnd; ++Pos) {
1345           CyclePath += Pos->first;
1346           CyclePath += " -> ";
1347         }
1348         CyclePath += ModuleName;
1349
1350         getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1351           << ModuleName << CyclePath;
1352         return ModuleLoadResult();
1353       }
1354
1355       getDiagnostics().Report(ImportLoc, diag::remark_module_build)
1356           << ModuleName << ModuleFileName;
1357
1358       // Check whether we have already attempted to build this module (but
1359       // failed).
1360       if (getPreprocessorOpts().FailedModules &&
1361           getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1362         getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1363           << ModuleName
1364           << SourceRange(ImportLoc, ModuleNameLoc);
1365         ModuleBuildFailed = true;
1366         return ModuleLoadResult();
1367       }
1368
1369       // Try to compile and then load the module.
1370       if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1371                                 ModuleFileName)) {
1372         assert(getDiagnostics().hasErrorOccurred() &&
1373                "undiagnosed error in compileAndLoadModule");
1374         if (getPreprocessorOpts().FailedModules)
1375           getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1376         KnownModules[Path[0].first] = nullptr;
1377         ModuleBuildFailed = true;
1378         return ModuleLoadResult();
1379       }
1380
1381       // Okay, we've rebuilt and now loaded the module.
1382       break;
1383     }
1384
1385     case ASTReader::VersionMismatch:
1386     case ASTReader::ConfigurationMismatch:
1387     case ASTReader::HadErrors:
1388       ModuleLoader::HadFatalFailure = true;
1389       // FIXME: The ASTReader will already have complained, but can we showhorn
1390       // that diagnostic information into a more useful form?
1391       KnownModules[Path[0].first] = nullptr;
1392       return ModuleLoadResult();
1393
1394     case ASTReader::Failure:
1395       ModuleLoader::HadFatalFailure = true;
1396       // Already complained, but note now that we failed.
1397       KnownModules[Path[0].first] = nullptr;
1398       ModuleBuildFailed = true;
1399       return ModuleLoadResult();
1400     }
1401
1402     // Cache the result of this top-level module lookup for later.
1403     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1404   }
1405
1406   // If we never found the module, fail.
1407   if (!Module)
1408     return ModuleLoadResult();
1409
1410   // Verify that the rest of the module path actually corresponds to
1411   // a submodule.
1412   if (Path.size() > 1) {
1413     for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1414       StringRef Name = Path[I].first->getName();
1415       clang::Module *Sub = Module->findSubmodule(Name);
1416
1417       if (!Sub) {
1418         // Attempt to perform typo correction to find a module name that works.
1419         SmallVector<StringRef, 2> Best;
1420         unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1421
1422         for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1423                                             JEnd = Module->submodule_end();
1424              J != JEnd; ++J) {
1425           unsigned ED = Name.edit_distance((*J)->Name,
1426                                            /*AllowReplacements=*/true,
1427                                            BestEditDistance);
1428           if (ED <= BestEditDistance) {
1429             if (ED < BestEditDistance) {
1430               Best.clear();
1431               BestEditDistance = ED;
1432             }
1433
1434             Best.push_back((*J)->Name);
1435           }
1436         }
1437
1438         // If there was a clear winner, user it.
1439         if (Best.size() == 1) {
1440           getDiagnostics().Report(Path[I].second,
1441                                   diag::err_no_submodule_suggest)
1442             << Path[I].first << Module->getFullModuleName() << Best[0]
1443             << SourceRange(Path[0].second, Path[I-1].second)
1444             << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1445                                             Best[0]);
1446
1447           Sub = Module->findSubmodule(Best[0]);
1448         }
1449       }
1450
1451       if (!Sub) {
1452         // No submodule by this name. Complain, and don't look for further
1453         // submodules.
1454         getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1455           << Path[I].first << Module->getFullModuleName()
1456           << SourceRange(Path[0].second, Path[I-1].second);
1457         break;
1458       }
1459
1460       Module = Sub;
1461     }
1462   }
1463
1464   // Don't make the module visible if we are in the implementation.
1465   if (ModuleName == getLangOpts().ImplementationOfModule)
1466     return ModuleLoadResult(Module, false);
1467
1468   // Make the named module visible, if it's not already part of the module
1469   // we are parsing.
1470   if (ModuleName != getLangOpts().CurrentModule) {
1471     if (!Module->IsFromModuleFile) {
1472       // We have an umbrella header or directory that doesn't actually include
1473       // all of the headers within the directory it covers. Complain about
1474       // this missing submodule and recover by forgetting that we ever saw
1475       // this submodule.
1476       // FIXME: Should we detect this at module load time? It seems fairly
1477       // expensive (and rare).
1478       getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1479         << Module->getFullModuleName()
1480         << SourceRange(Path.front().second, Path.back().second);
1481
1482       return ModuleLoadResult(nullptr, true);
1483     }
1484
1485     // Check whether this module is available.
1486     clang::Module::Requirement Requirement;
1487     clang::Module::HeaderDirective MissingHeader;
1488     if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1489                              MissingHeader)) {
1490       if (MissingHeader.FileNameLoc.isValid()) {
1491         getDiagnostics().Report(MissingHeader.FileNameLoc,
1492                                 diag::err_module_header_missing)
1493           << MissingHeader.IsUmbrella << MissingHeader.FileName;
1494       } else {
1495         getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1496           << Module->getFullModuleName()
1497           << Requirement.second << Requirement.first
1498           << SourceRange(Path.front().second, Path.back().second);
1499       }
1500       LastModuleImportLoc = ImportLoc;
1501       LastModuleImportResult = ModuleLoadResult();
1502       return ModuleLoadResult();
1503     }
1504
1505     ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1506                                      /*Complain=*/true);
1507   }
1508
1509   // Check for any configuration macros that have changed.
1510   clang::Module *TopModule = Module->getTopLevelModule();
1511   for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1512     checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1513                      Module, ImportLoc);
1514   }
1515
1516   // If this module import was due to an inclusion directive, create an
1517   // implicit import declaration to capture it in the AST.
1518   if (IsInclusionDirective && hasASTContext()) {
1519     TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
1520     ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1521                                                      ImportLoc, Module,
1522                                                      Path.back().second);
1523     TU->addDecl(ImportD);
1524     if (Consumer)
1525       Consumer->HandleImplicitImportDecl(ImportD);
1526   }
1527
1528   LastModuleImportLoc = ImportLoc;
1529   LastModuleImportResult = ModuleLoadResult(Module, false);
1530   return LastModuleImportResult;
1531 }
1532
1533 void CompilerInstance::makeModuleVisible(Module *Mod,
1534                                          Module::NameVisibilityKind Visibility,
1535                                          SourceLocation ImportLoc,
1536                                          bool Complain){
1537   ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
1538 }
1539
1540 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
1541     SourceLocation TriggerLoc) {
1542   if (!ModuleManager)
1543     createModuleManager();
1544   // Can't do anything if we don't have the module manager.
1545   if (!ModuleManager)
1546     return nullptr;
1547   // Get an existing global index.  This loads it if not already
1548   // loaded.
1549   ModuleManager->loadGlobalIndex();
1550   GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1551   // If the global index doesn't exist, create it.
1552   if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1553       hasPreprocessor()) {
1554     llvm::sys::fs::create_directories(
1555       getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1556     GlobalModuleIndex::writeIndex(
1557       getFileManager(),
1558       getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1559     ModuleManager->resetForReload();
1560     ModuleManager->loadGlobalIndex();
1561     GlobalIndex = ModuleManager->getGlobalIndex();
1562   }
1563   // For finding modules needing to be imported for fixit messages,
1564   // we need to make the global index cover all modules, so we do that here.
1565   if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1566     ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
1567     bool RecreateIndex = false;
1568     for (ModuleMap::module_iterator I = MMap.module_begin(),
1569         E = MMap.module_end(); I != E; ++I) {
1570       Module *TheModule = I->second;
1571       const FileEntry *Entry = TheModule->getASTFile();
1572       if (!Entry) {
1573         SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1574         Path.push_back(std::make_pair(
1575                                   getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
1576         std::reverse(Path.begin(), Path.end());
1577                     // Load a module as hidden.  This also adds it to the global index.
1578         loadModule(TheModule->DefinitionLoc, Path,
1579                                              Module::Hidden, false);
1580         RecreateIndex = true;
1581       }
1582     }
1583     if (RecreateIndex) {
1584       GlobalModuleIndex::writeIndex(
1585         getFileManager(),
1586         getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1587       ModuleManager->resetForReload();
1588       ModuleManager->loadGlobalIndex();
1589       GlobalIndex = ModuleManager->getGlobalIndex();
1590     }
1591     HaveFullGlobalModuleIndex = true;
1592   }
1593   return GlobalIndex;
1594 }
1595
1596 // Check global module index for missing imports.
1597 bool
1598 CompilerInstance::lookupMissingImports(StringRef Name,
1599                                        SourceLocation TriggerLoc) {
1600   // Look for the symbol in non-imported modules, but only if an error
1601   // actually occurred.
1602   if (!buildingModule()) {
1603     // Load global module index, or retrieve a previously loaded one.
1604     GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
1605       TriggerLoc);
1606
1607     // Only if we have a global index.
1608     if (GlobalIndex) {
1609       GlobalModuleIndex::HitSet FoundModules;
1610
1611       // Find the modules that reference the identifier.
1612       // Note that this only finds top-level modules.
1613       // We'll let diagnoseTypo find the actual declaration module.
1614       if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1615         return true;
1616     }
1617   }
1618
1619   return false;
1620 }
1621 void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }