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