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, /*SkipCache=*/true);
 862       // Also add the header to /showIncludes output.
 863       if (File)
 864         DepOpts.ShowIncludesPretendHeader = File->getName();
 865     }
 866     if (!File) {
 867       Diags.Report(diag::err_fe_error_reading) << InputFile;
 868       return false;
 869     }
 870
 871     // The natural SourceManager infrastructure can't currently handle named
 872     // pipes, but we would at least like to accept them for the main
 873     // file. Detect them here, read them with the volatile flag so FileMgr will
 874     // pick up the correct size, and simply override their contents as we do for
 875     // STDIN.
 876     if (File->isNamedPipe()) {
 877       auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
 878       if (MB) {
 879         // Create a new virtual file that will have the correct size.
 880         File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
 881         SourceMgr.overrideFileContents(File, std::move(*MB));
 882       } else {
 883         Diags.Report(diag::err_cannot_open_file) << InputFile
 884                                                  << MB.getError().message();
 885         return false;
 886       }
 887     }
 888
 889     SourceMgr.setMainFileID(
 890         SourceMgr.createFileID(File, SourceLocation(), Kind));
 891   } else {
 892     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
 893         llvm::MemoryBuffer::getSTDIN();
 894     if (std::error_code EC = SBOrErr.getError()) {
 895       Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
 896       return false;
 897     }
 898     std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
 899
 900     const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
 901                                                    SB->getBufferSize(), 0);
 902     SourceMgr.setMainFileID(
 903         SourceMgr.createFileID(File, SourceLocation(), Kind));
 904     SourceMgr.overrideFileContents(File, std::move(SB));
 905   }
 906
 907   assert(SourceMgr.getMainFileID().isValid() &&
 908          "Couldn't establish MainFileID!");
 909   return true;
 910 }
 911
 912 // High-Level Operations
 913
 914 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
 915   assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
 916   assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
 917   assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
 918
 919   // FIXME: Take this as an argument, once all the APIs we used have moved to
 920   // taking it as an input instead of hard-coding llvm::errs.
 921   raw_ostream &OS = llvm::errs();
 922
 923   // Create the target instance.
 924   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
 925                                          getInvocation().TargetOpts));
 926   if (!hasTarget())
 927     return false;
 928
 929   // Create TargetInfo for the other side of CUDA compilation.
 930   if (getLangOpts().CUDA && !getFrontendOpts().AuxTriple.empty()) {
 931     auto TO = std::make_shared<TargetOptions>();
 932     TO->Triple = getFrontendOpts().AuxTriple;
 933     TO->HostTriple = getTarget().getTriple().str();
 934     setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
 935   }
 936
 937   // Inform the target of the language options.
 938   //
 939   // FIXME: We shouldn't need to do this, the target should be immutable once
 940   // created. This complexity should be lifted elsewhere.
 941   getTarget().adjust(getLangOpts());
 942
 943   // Adjust target options based on codegen options.
 944   getTarget().adjustTargetOptions(getCodeGenOpts(), getTargetOpts());
 945
 946   // rewriter project will change target built-in bool type from its default.
 947   if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
 948     getTarget().noSignedCharForObjCBool();
 949
 950   // Validate/process some options.
 951   if (getHeaderSearchOpts().Verbose)
 952     OS << "clang -cc1 version " CLANG_VERSION_STRING
 953        << " based upon " << BACKEND_PACKAGE_STRING
 954        << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
 955
 956   if (getFrontendOpts().ShowTimers)
 957     createFrontendTimer();
 958
 959   if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
 960     llvm::EnableStatistics(false);
 961
 962   for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
 963     // Reset the ID tables if we are reusing the SourceManager and parsing
 964     // regular files.
 965     if (hasSourceManager() && !Act.isModelParsingAction())
 966       getSourceManager().clearIDTables();
 967
 968     if (Act.BeginSourceFile(*this, FIF)) {
 969       Act.Execute();
 970       Act.EndSourceFile();
 971     }
 972   }
 973
 974   // Notify the diagnostic client that all files were processed.
 975   getDiagnostics().getClient()->finish();
 976
 977   if (getDiagnosticOpts().ShowCarets) {
 978     // We can have multiple diagnostics sharing one diagnostic client.
 979     // Get the total number of warnings/errors from the client.
 980     unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
 981     unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
 982
 983     if (NumWarnings)
 984       OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
 985     if (NumWarnings && NumErrors)
 986       OS << " and ";
 987     if (NumErrors)
 988       OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
 989     if (NumWarnings || NumErrors)
 990       OS << " generated.\n";
 991   }
 992
 993   if (getFrontendOpts().ShowStats) {
 994     if (hasFileManager()) {
 995       getFileManager().PrintStats();
 996       OS << '\n';
 997     }
 998     llvm::PrintStatistics(OS);
 999   }
1000   StringRef StatsFile = getFrontendOpts().StatsFile;
1001   if (!StatsFile.empty()) {
1002     std::error_code EC;
1003     auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1004                                                          llvm::sys::fs::F_Text);
1005     if (EC) {
1006       getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1007           << StatsFile << EC.message();
1008     } else {
1009       llvm::PrintStatisticsJSON(*StatS);
1010     }
1011   }
1012
1013   return !getDiagnostics().getClient()->getNumErrors();
1014 }
1015
1016 /// \brief Determine the appropriate source input kind based on language
1017 /// options.
1018 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
1019   if (LangOpts.OpenCL)
1020     return IK_OpenCL;
1021   if (LangOpts.CUDA)
1022     return IK_CUDA;
1023   if (LangOpts.ObjC1)
1024     return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
1025   return LangOpts.CPlusPlus? IK_CXX : IK_C;
1026 }
1027
1028 /// \brief Compile a module file for the given module, using the options
1029 /// provided by the importing compiler instance. Returns true if the module
1030 /// was built without errors.
1031 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1032                               SourceLocation ImportLoc,
1033                               Module *Module,
1034                               StringRef ModuleFileName) {
1035   ModuleMap &ModMap
1036     = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1037
1038   // Construct a compiler invocation for creating this module.
1039   auto Invocation =
1040       std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1041
1042   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1043
1044   // For any options that aren't intended to affect how a module is built,
1045   // reset them to their default values.
1046   Invocation->getLangOpts()->resetNonModularOptions();
1047   PPOpts.resetNonModularOptions();
1048
1049   // Remove any macro definitions that are explicitly ignored by the module.
1050   // They aren't supposed to affect how the module is built anyway.
1051   HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1052   PPOpts.Macros.erase(
1053       std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1054                      [&HSOpts](const std::pair<std::string, bool> &def) {
1055         StringRef MacroDef = def.first;
1056         return HSOpts.ModulesIgnoreMacros.count(
1057                    llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1058       }),
1059       PPOpts.Macros.end());
1060
1061   // Note the name of the module we're building.
1062   Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
1063
1064   // Make sure that the failed-module structure has been allocated in
1065   // the importing instance, and propagate the pointer to the newly-created
1066   // instance.
1067   PreprocessorOptions &ImportingPPOpts
1068     = ImportingInstance.getInvocation().getPreprocessorOpts();
1069   if (!ImportingPPOpts.FailedModules)
1070     ImportingPPOpts.FailedModules =
1071         std::make_shared<PreprocessorOptions::FailedModulesSet>();
1072   PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1073
1074   // If there is a module map file, build the module using the module map.
1075   // Set up the inputs/outputs so that we build the module from its umbrella
1076   // header.
1077   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1078   FrontendOpts.OutputFile = ModuleFileName.str();
1079   FrontendOpts.DisableFree = false;
1080   FrontendOpts.GenerateGlobalModuleIndex = false;
1081   FrontendOpts.BuildingImplicitModule = true;
1082   // Force implicitly-built modules to hash the content of the module file.
1083   HSOpts.ModulesHashContent = true;
1084   FrontendOpts.Inputs.clear();
1085   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
1086
1087   // Don't free the remapped file buffers; they are owned by our caller.
1088   PPOpts.RetainRemappedFileBuffers = true;
1089
1090   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1091   assert(ImportingInstance.getInvocation().getModuleHash() ==
1092          Invocation->getModuleHash() && "Module hash mismatch!");
1093
1094   // Construct a compiler instance that will be used to actually create the
1095   // module.  Since we're sharing a PCMCache,
1096   // CompilerInstance::CompilerInstance is responsible for finalizing the
1097   // buffers to prevent use-after-frees.
1098   CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1099                             &ImportingInstance.getPreprocessor().getPCMCache());
1100   auto &Inv = *Invocation;
1101   Instance.setInvocation(std::move(Invocation));
1102
1103   Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1104                                    ImportingInstance.getDiagnosticClient()),
1105                              /*ShouldOwnClient=*/true);
1106
1107   Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1108
1109   // Note that this module is part of the module build stack, so that we
1110   // can detect cycles in the module graph.
1111   Instance.setFileManager(&ImportingInstance.getFileManager());
1112   Instance.createSourceManager(Instance.getFileManager());
1113   SourceManager &SourceMgr = Instance.getSourceManager();
1114   SourceMgr.setModuleBuildStack(
1115     ImportingInstance.getSourceManager().getModuleBuildStack());
1116   SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
1117     FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1118
1119   // If we're collecting module dependencies, we need to share a collector
1120   // between all of the module CompilerInstances. Other than that, we don't
1121   // want to produce any dependency output from the module build.
1122   Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1123   Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1124
1125   // Get or create the module map that we'll use to build this module.
1126   std::string InferredModuleMapContent;
1127   if (const FileEntry *ModuleMapFile =
1128           ModMap.getContainingModuleMapFile(Module)) {
1129     // Use the module map where this module resides.
1130     FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK);
1131   } else {
1132     SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1133     llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1134     FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK);
1135
1136     llvm::raw_string_ostream OS(InferredModuleMapContent);
1137     Module->print(OS);
1138     OS.flush();
1139
1140     std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1141         llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1142     ModuleMapFile = Instance.getFileManager().getVirtualFile(
1143         FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1144     SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
1145   }
1146
1147   // Construct a module-generating action. Passing through the module map is
1148   // safe because the FileManager is shared between the compiler instances.
1149   GenerateModuleFromModuleMapAction CreateModuleAction(
1150       ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
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([&]() { Instance.ExecuteAction(CreateModuleAction); },
1161                         ThreadStackSize);
1162
1163   ImportingInstance.getDiagnostics().Report(ImportLoc,
1164                                             diag::remark_module_build_done)
1165     << Module->Name;
1166
1167   // Delete the temporary module map file.
1168   // FIXME: Even though we're executing under crash protection, it would still
1169   // be nice to do this with RemoveFileOnSignal when we can. However, that
1170   // doesn't make sense for all clients, so clean this up manually.
1171   Instance.clearOutputFiles(/*EraseFiles=*/true);
1172
1173   // We've rebuilt a module. If we're allowed to generate or update the global
1174   // module index, record that fact in the importing compiler instance.
1175   if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1176     ImportingInstance.setBuildGlobalModuleIndex(true);
1177   }
1178
1179   return !Instance.getDiagnostics().hasErrorOccurred();
1180 }
1181
1182 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1183                                  SourceLocation ImportLoc,
1184                                  SourceLocation ModuleNameLoc, Module *Module,
1185                                  StringRef ModuleFileName) {
1186   DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1187
1188   auto diagnoseBuildFailure = [&] {
1189     Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1190         << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1191   };
1192
1193   // FIXME: have LockFileManager return an error_code so that we can
1194   // avoid the mkdir when the directory already exists.
1195   StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1196   llvm::sys::fs::create_directories(Dir);
1197
1198   while (1) {
1199     unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1200     llvm::LockFileManager Locked(ModuleFileName);
1201     switch (Locked) {
1202     case llvm::LockFileManager::LFS_Error:
1203       // PCMCache takes care of correctness and locks are only necessary for
1204       // performance. Fallback to building the module in case of any lock
1205       // related errors.
1206       Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1207           << Module->Name << Locked.getErrorMessage();
1208       // Clear out any potential leftover.
1209       Locked.unsafeRemoveLockFile();
1210       // FALLTHROUGH
1211     case llvm::LockFileManager::LFS_Owned:
1212       // We're responsible for building the module ourselves.
1213       if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1214                              ModuleFileName)) {
1215         diagnoseBuildFailure();
1216         return false;
1217       }
1218       break;
1219
1220     case llvm::LockFileManager::LFS_Shared:
1221       // Someone else is responsible for building the module. Wait for them to
1222       // finish.
1223       switch (Locked.waitForUnlock()) {
1224       case llvm::LockFileManager::Res_Success:
1225         ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1226         break;
1227       case llvm::LockFileManager::Res_OwnerDied:
1228         continue; // try again to get the lock.
1229       case llvm::LockFileManager::Res_Timeout:
1230         // Since PCMCache takes care of correctness, we try waiting for another
1231         // process to complete the build so clang does not do it done twice. If
1232         // case of timeout, build it ourselves.
1233         Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1234             << Module->Name;
1235         // Clear the lock file so that future invokations can make progress.
1236         Locked.unsafeRemoveLockFile();
1237         continue;
1238       }
1239       break;
1240     }
1241
1242     // Try to read the module file, now that we've compiled it.
1243     ASTReader::ASTReadResult ReadResult =
1244         ImportingInstance.getModuleManager()->ReadAST(
1245             ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1246             ModuleLoadCapabilities);
1247
1248     if (ReadResult == ASTReader::OutOfDate &&
1249         Locked == llvm::LockFileManager::LFS_Shared) {
1250       // The module may be out of date in the presence of file system races,
1251       // or if one of its imports depends on header search paths that are not
1252       // consistent with this ImportingInstance.  Try again...
1253       continue;
1254     } else if (ReadResult == ASTReader::Missing) {
1255       diagnoseBuildFailure();
1256     } else if (ReadResult != ASTReader::Success &&
1257                !Diags.hasErrorOccurred()) {
1258       // The ASTReader didn't diagnose the error, so conservatively report it.
1259       diagnoseBuildFailure();
1260     }
1261     return ReadResult == ASTReader::Success;
1262   }
1263 }
1264
1265 /// \brief Diagnose differences between the current definition of the given
1266 /// configuration macro and the definition provided on the command line.
1267 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1268                              Module *Mod, SourceLocation ImportLoc) {
1269   IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1270   SourceManager &SourceMgr = PP.getSourceManager();
1271
1272   // If this identifier has never had a macro definition, then it could
1273   // not have changed.
1274   if (!Id->hadMacroDefinition())
1275     return;
1276   auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1277
1278   // Find the macro definition from the command line.
1279   MacroInfo *CmdLineDefinition = nullptr;
1280   for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1281     // We only care about the predefines buffer.
1282     FileID FID = SourceMgr.getFileID(MD->getLocation());
1283     if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1284       continue;
1285     if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1286       CmdLineDefinition = DMD->getMacroInfo();
1287     break;
1288   }
1289
1290   auto *CurrentDefinition = PP.getMacroInfo(Id);
1291   if (CurrentDefinition == CmdLineDefinition) {
1292     // Macro matches. Nothing to do.
1293   } else if (!CurrentDefinition) {
1294     // This macro was defined on the command line, then #undef'd later.
1295     // Complain.
1296     PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1297       << true << ConfigMacro << Mod->getFullModuleName();
1298     auto LatestDef = LatestLocalMD->getDefinition();
1299     assert(LatestDef.isUndefined() &&
1300            "predefined macro went away with no #undef?");
1301     PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1302       << true;
1303     return;
1304   } else if (!CmdLineDefinition) {
1305     // There was no definition for this macro in the predefines buffer,
1306     // but there was a local definition. Complain.
1307     PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1308       << false << ConfigMacro << Mod->getFullModuleName();
1309     PP.Diag(CurrentDefinition->getDefinitionLoc(),
1310             diag::note_module_def_undef_here)
1311       << false;
1312   } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1313                                                /*Syntactically=*/true)) {
1314     // The macro definitions differ.
1315     PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1316       << false << ConfigMacro << Mod->getFullModuleName();
1317     PP.Diag(CurrentDefinition->getDefinitionLoc(),
1318             diag::note_module_def_undef_here)
1319       << false;
1320   }
1321 }
1322
1323 /// \brief Write a new timestamp file with the given path.
1324 static void writeTimestampFile(StringRef TimestampFile) {
1325   std::error_code EC;
1326   llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1327 }
1328
1329 /// \brief Prune the module cache of modules that haven't been accessed in
1330 /// a long time.
1331 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1332   struct stat StatBuf;
1333   llvm::SmallString<128> TimestampFile;
1334   TimestampFile = HSOpts.ModuleCachePath;
1335   assert(!TimestampFile.empty());
1336   llvm::sys::path::append(TimestampFile, "modules.timestamp");
1337
1338   // Try to stat() the timestamp file.
1339   if (::stat(TimestampFile.c_str(), &StatBuf)) {
1340     // If the timestamp file wasn't there, create one now.
1341     if (errno == ENOENT) {
1342       writeTimestampFile(TimestampFile);
1343     }
1344     return;
1345   }
1346
1347   // Check whether the time stamp is older than our pruning interval.
1348   // If not, do nothing.
1349   time_t TimeStampModTime = StatBuf.st_mtime;
1350   time_t CurrentTime = time(nullptr);
1351   if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1352     return;
1353
1354   // Write a new timestamp file so that nobody else attempts to prune.
1355   // There is a benign race condition here, if two Clang instances happen to
1356   // notice at the same time that the timestamp is out-of-date.
1357   writeTimestampFile(TimestampFile);
1358
1359   // Walk the entire module cache, looking for unused module files and module
1360   // indices.
1361   std::error_code EC;
1362   SmallString<128> ModuleCachePathNative;
1363   llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1364   for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1365        Dir != DirEnd && !EC; Dir.increment(EC)) {
1366     // If we don't have a directory, there's nothing to look into.
1367     if (!llvm::sys::fs::is_directory(Dir->path()))
1368       continue;
1369
1370     // Walk all of the files within this directory.
1371     for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1372          File != FileEnd && !EC; File.increment(EC)) {
1373       // We only care about module and global module index files.
1374       StringRef Extension = llvm::sys::path::extension(File->path());
1375       if (Extension != ".pcm" && Extension != ".timestamp" &&
1376           llvm::sys::path::filename(File->path()) != "modules.idx")
1377         continue;
1378
1379       // Look at this file. If we can't stat it, there's nothing interesting
1380       // there.
1381       if (::stat(File->path().c_str(), &StatBuf))
1382         continue;
1383
1384       // If the file has been used recently enough, leave it there.
1385       time_t FileAccessTime = StatBuf.st_atime;
1386       if (CurrentTime - FileAccessTime <=
1387               time_t(HSOpts.ModuleCachePruneAfter)) {
1388         continue;
1389       }
1390
1391       // Remove the file.
1392       llvm::sys::fs::remove(File->path());
1393
1394       // Remove the timestamp file.
1395       std::string TimpestampFilename = File->path() + ".timestamp";
1396       llvm::sys::fs::remove(TimpestampFilename);
1397     }
1398
1399     // If we removed all of the files in the directory, remove the directory
1400     // itself.
1401     if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1402             llvm::sys::fs::directory_iterator() && !EC)
1403       llvm::sys::fs::remove(Dir->path());
1404   }
1405 }
1406
1407 void CompilerInstance::createModuleManager() {
1408   if (!ModuleManager) {
1409     if (!hasASTContext())
1410       createASTContext();
1411
1412     // If we're implicitly building modules but not currently recursively
1413     // building a module, check whether we need to prune the module cache.
1414     if (getSourceManager().getModuleBuildStack().empty() &&
1415         !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1416         getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1417         getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1418       pruneModuleCache(getHeaderSearchOpts());
1419     }
1420
1421     HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1422     std::string Sysroot = HSOpts.Sysroot;
1423     const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1424     std::unique_ptr<llvm::Timer> ReadTimer;
1425     if (FrontendTimerGroup)
1426       ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1427                                                  "Reading modules",
1428                                                  *FrontendTimerGroup);
1429     ModuleManager = new ASTReader(
1430         getPreprocessor(), getASTContext(), getPCHContainerReader(),
1431         getFrontendOpts().ModuleFileExtensions,
1432         Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1433         /*AllowASTWithCompilerErrors=*/false,
1434         /*AllowConfigurationMismatch=*/false,
1435         HSOpts.ModulesValidateSystemHeaders,
1436         getFrontendOpts().UseGlobalModuleIndex,
1437         std::move(ReadTimer));
1438     if (hasASTConsumer()) {
1439       ModuleManager->setDeserializationListener(
1440         getASTConsumer().GetASTDeserializationListener());
1441       getASTContext().setASTMutationListener(
1442         getASTConsumer().GetASTMutationListener());
1443     }
1444     getASTContext().setExternalSource(ModuleManager);
1445     if (hasSema())
1446       ModuleManager->InitializeSema(getSema());
1447     if (hasASTConsumer())
1448       ModuleManager->StartTranslationUnit(&getASTConsumer());
1449
1450     if (TheDependencyFileGenerator)
1451       TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1452     for (auto &Listener : DependencyCollectors)
1453       Listener->attachToASTReader(*ModuleManager);
1454   }
1455 }
1456
1457 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1458   llvm::Timer Timer;
1459   if (FrontendTimerGroup)
1460     Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1461                *FrontendTimerGroup);
1462   llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1463
1464   // Helper to recursively read the module names for all modules we're adding.
1465   // We mark these as known and redirect any attempt to load that module to
1466   // the files we were handed.
1467   struct ReadModuleNames : ASTReaderListener {
1468     CompilerInstance &CI;
1469     llvm::SmallVector<IdentifierInfo*, 8> LoadedModules;
1470
1471     ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1472
1473     void ReadModuleName(StringRef ModuleName) override {
1474       LoadedModules.push_back(
1475           CI.getPreprocessor().getIdentifierInfo(ModuleName));
1476     }
1477
1478     void registerAll() {
1479       for (auto *II : LoadedModules) {
1480         CI.KnownModules[II] = CI.getPreprocessor()
1481                                   .getHeaderSearchInfo()
1482                                   .getModuleMap()
1483                                   .findModule(II->getName());
1484       }
1485       LoadedModules.clear();
1486     }
1487
1488     void markAllUnavailable() {
1489       for (auto *II : LoadedModules) {
1490         if (Module *M = CI.getPreprocessor()
1491                             .getHeaderSearchInfo()
1492                             .getModuleMap()
1493                             .findModule(II->getName())) {
1494           M->HasIncompatibleModuleFile = true;
1495
1496           // Mark module as available if the only reason it was unavailable
1497           // was missing headers.
1498           SmallVector<Module *, 2> Stack;
1499           Stack.push_back(M);
1500           while (!Stack.empty()) {
1501             Module *Current = Stack.pop_back_val();
1502             if (Current->IsMissingRequirement) continue;
1503             Current->IsAvailable = true;
1504             Stack.insert(Stack.end(),
1505                          Current->submodule_begin(), Current->submodule_end());
1506           }
1507         }
1508       }
1509       LoadedModules.clear();
1510     }
1511   };
1512
1513   // If we don't already have an ASTReader, create one now.
1514   if (!ModuleManager)
1515     createModuleManager();
1516
1517   auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1518   auto &ListenerRef = *Listener;
1519   ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1520                                                    std::move(Listener));
1521
1522   // Try to load the module file.
1523   switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1524                                  SourceLocation(),
1525                                  ASTReader::ARR_ConfigurationMismatch)) {
1526   case ASTReader::Success:
1527     // We successfully loaded the module file; remember the set of provided
1528     // modules so that we don't try to load implicit modules for them.
1529     ListenerRef.registerAll();
1530     return true;
1531
1532   case ASTReader::ConfigurationMismatch:
1533     // Ignore unusable module files.
1534     getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1535         << FileName;
1536     // All modules provided by any files we tried and failed to load are now
1537     // unavailable; includes of those modules should now be handled textually.
1538     ListenerRef.markAllUnavailable();
1539     return true;
1540
1541   default:
1542     return false;
1543   }
1544 }
1545
1546 ModuleLoadResult
1547 CompilerInstance::loadModule(SourceLocation ImportLoc,
1548                              ModuleIdPath Path,
1549                              Module::NameVisibilityKind Visibility,
1550                              bool IsInclusionDirective) {
1551   // Determine what file we're searching from.
1552   StringRef ModuleName = Path[0].first->getName();
1553   SourceLocation ModuleNameLoc = Path[0].second;
1554
1555   // If we've already handled this import, just return the cached result.
1556   // This one-element cache is important to eliminate redundant diagnostics
1557   // when both the preprocessor and parser see the same import declaration.
1558   if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1559     // Make the named module visible.
1560     if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1561       ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1562                                        ImportLoc);
1563     return LastModuleImportResult;
1564   }
1565
1566   clang::Module *Module = nullptr;
1567
1568   // If we don't already have information on this module, load the module now.
1569   llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1570     = KnownModules.find(Path[0].first);
1571   if (Known != KnownModules.end()) {
1572     // Retrieve the cached top-level module.
1573     Module = Known->second;
1574   } else if (ModuleName == getLangOpts().CurrentModule) {
1575     // This is the module we're building.
1576     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1577     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1578   } else {
1579     // Search for a module with the given name.
1580     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1581     HeaderSearchOptions &HSOpts =
1582         PP->getHeaderSearchInfo().getHeaderSearchOpts();
1583
1584     std::string ModuleFileName;
1585     bool LoadFromPrebuiltModulePath = false;
1586     // We try to load the module from the prebuilt module paths. If not
1587     // successful, we then try to find it in the module cache.
1588     if (!HSOpts.PrebuiltModulePaths.empty()) {
1589       // Load the module from the prebuilt module path.
1590       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(
1591           ModuleName, "", /*UsePrebuiltPath*/ true);
1592       if (!ModuleFileName.empty())
1593         LoadFromPrebuiltModulePath = true;
1594     }
1595     if (!LoadFromPrebuiltModulePath && Module) {
1596       // Load the module from the module cache.
1597       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
1598     } else if (!LoadFromPrebuiltModulePath) {
1599       // We can't find a module, error out here.
1600       getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1601       << ModuleName
1602       << SourceRange(ImportLoc, ModuleNameLoc);
1603       ModuleBuildFailed = true;
1604       return ModuleLoadResult();
1605     }
1606
1607     if (ModuleFileName.empty()) {
1608       if (Module && Module->HasIncompatibleModuleFile) {
1609         // We tried and failed to load a module file for this module. Fall
1610         // back to textual inclusion for its headers.
1611         return ModuleLoadResult::ConfigMismatch;
1612       }
1613
1614       getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1615           << ModuleName;
1616       ModuleBuildFailed = true;
1617       return ModuleLoadResult();
1618     }
1619
1620     // If we don't already have an ASTReader, create one now.
1621     if (!ModuleManager)
1622       createModuleManager();
1623
1624     llvm::Timer Timer;
1625     if (FrontendTimerGroup)
1626       Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1627                  *FrontendTimerGroup);
1628     llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1629
1630     // Try to load the module file. If we are trying to load from the prebuilt
1631     // module path, we don't have the module map files and don't know how to
1632     // rebuild modules.
1633     unsigned ARRFlags = LoadFromPrebuiltModulePath ?
1634                         ASTReader::ARR_ConfigurationMismatch :
1635                         ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1636     switch (ModuleManager->ReadAST(ModuleFileName,
1637                                    LoadFromPrebuiltModulePath ?
1638                                    serialization::MK_PrebuiltModule :
1639                                    serialization::MK_ImplicitModule,
1640                                    ImportLoc,
1641                                    ARRFlags)) {
1642     case ASTReader::Success: {
1643       if (LoadFromPrebuiltModulePath && !Module) {
1644         Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1645         if (!Module || !Module->getASTFile() ||
1646             FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1647           // Error out if Module does not refer to the file in the prebuilt
1648           // module path.
1649           getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1650               << ModuleName;
1651           ModuleBuildFailed = true;
1652           KnownModules[Path[0].first] = nullptr;
1653           return ModuleLoadResult();
1654         }
1655       }
1656       break;
1657     }
1658
1659     case ASTReader::OutOfDate:
1660     case ASTReader::Missing: {
1661       if (LoadFromPrebuiltModulePath) {
1662         // We can't rebuild the module without a module map. Since ReadAST
1663         // already produces diagnostics for these two cases, we simply
1664         // error out here.
1665         ModuleBuildFailed = true;
1666         KnownModules[Path[0].first] = nullptr;
1667         return ModuleLoadResult();
1668       }
1669
1670       // The module file is missing or out-of-date. Build it.
1671       assert(Module && "missing module file");
1672       // Check whether there is a cycle in the module graph.
1673       ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1674       ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1675       for (; Pos != PosEnd; ++Pos) {
1676         if (Pos->first == ModuleName)
1677           break;
1678       }
1679
1680       if (Pos != PosEnd) {
1681         SmallString<256> CyclePath;
1682         for (; Pos != PosEnd; ++Pos) {
1683           CyclePath += Pos->first;
1684           CyclePath += " -> ";
1685         }
1686         CyclePath += ModuleName;
1687
1688         getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1689           << ModuleName << CyclePath;
1690         return ModuleLoadResult();
1691       }
1692
1693       // Check whether we have already attempted to build this module (but
1694       // failed).
1695       if (getPreprocessorOpts().FailedModules &&
1696           getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1697         getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1698           << ModuleName
1699           << SourceRange(ImportLoc, ModuleNameLoc);
1700         ModuleBuildFailed = true;
1701         return ModuleLoadResult();
1702       }
1703
1704       // Try to compile and then load the module.
1705       if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1706                                 ModuleFileName)) {
1707         assert(getDiagnostics().hasErrorOccurred() &&
1708                "undiagnosed error in compileAndLoadModule");
1709         if (getPreprocessorOpts().FailedModules)
1710           getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1711         KnownModules[Path[0].first] = nullptr;
1712         ModuleBuildFailed = true;
1713         return ModuleLoadResult();
1714       }
1715
1716       // Okay, we've rebuilt and now loaded the module.
1717       break;
1718     }
1719
1720     case ASTReader::ConfigurationMismatch:
1721       if (LoadFromPrebuiltModulePath)
1722         getDiagnostics().Report(SourceLocation(),
1723                                 diag::warn_module_config_mismatch)
1724             << ModuleFileName;
1725       // Fall through to error out.
1726     case ASTReader::VersionMismatch:
1727     case ASTReader::HadErrors:
1728       ModuleLoader::HadFatalFailure = true;
1729       // FIXME: The ASTReader will already have complained, but can we shoehorn
1730       // that diagnostic information into a more useful form?
1731       KnownModules[Path[0].first] = nullptr;
1732       return ModuleLoadResult();
1733
1734     case ASTReader::Failure:
1735       ModuleLoader::HadFatalFailure = true;
1736       // Already complained, but note now that we failed.
1737       KnownModules[Path[0].first] = nullptr;
1738       ModuleBuildFailed = true;
1739       return ModuleLoadResult();
1740     }
1741
1742     // Cache the result of this top-level module lookup for later.
1743     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1744   }
1745
1746   // If we never found the module, fail.
1747   if (!Module)
1748     return ModuleLoadResult();
1749
1750   // Verify that the rest of the module path actually corresponds to
1751   // a submodule.
1752   if (Path.size() > 1) {
1753     for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1754       StringRef Name = Path[I].first->getName();
1755       clang::Module *Sub = Module->findSubmodule(Name);
1756
1757       if (!Sub) {
1758         // Attempt to perform typo correction to find a module name that works.
1759         SmallVector<StringRef, 2> Best;
1760         unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1761
1762         for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1763                                             JEnd = Module->submodule_end();
1764              J != JEnd; ++J) {
1765           unsigned ED = Name.edit_distance((*J)->Name,
1766                                            /*AllowReplacements=*/true,
1767                                            BestEditDistance);
1768           if (ED <= BestEditDistance) {
1769             if (ED < BestEditDistance) {
1770               Best.clear();
1771               BestEditDistance = ED;
1772             }
1773
1774             Best.push_back((*J)->Name);
1775           }
1776         }
1777
1778         // If there was a clear winner, user it.
1779         if (Best.size() == 1) {
1780           getDiagnostics().Report(Path[I].second,
1781                                   diag::err_no_submodule_suggest)
1782             << Path[I].first << Module->getFullModuleName() << Best[0]
1783             << SourceRange(Path[0].second, Path[I-1].second)
1784             << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1785                                             Best[0]);
1786
1787           Sub = Module->findSubmodule(Best[0]);
1788         }
1789       }
1790
1791       if (!Sub) {
1792         // No submodule by this name. Complain, and don't look for further
1793         // submodules.
1794         getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1795           << Path[I].first << Module->getFullModuleName()
1796           << SourceRange(Path[0].second, Path[I-1].second);
1797         break;
1798       }
1799
1800       Module = Sub;
1801     }
1802   }
1803
1804   // Make the named module visible, if it's not already part of the module
1805   // we are parsing.
1806   if (ModuleName != getLangOpts().CurrentModule) {
1807     if (!Module->IsFromModuleFile) {
1808       // We have an umbrella header or directory that doesn't actually include
1809       // all of the headers within the directory it covers. Complain about
1810       // this missing submodule and recover by forgetting that we ever saw
1811       // this submodule.
1812       // FIXME: Should we detect this at module load time? It seems fairly
1813       // expensive (and rare).
1814       getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1815         << Module->getFullModuleName()
1816         << SourceRange(Path.front().second, Path.back().second);
1817
1818       return ModuleLoadResult::MissingExpected;
1819     }
1820
1821     // Check whether this module is available.
1822     clang::Module::Requirement Requirement;
1823     clang::Module::UnresolvedHeaderDirective MissingHeader;
1824     if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1825                              MissingHeader)) {
1826       if (MissingHeader.FileNameLoc.isValid()) {
1827         getDiagnostics().Report(MissingHeader.FileNameLoc,
1828                                 diag::err_module_header_missing)
1829           << MissingHeader.IsUmbrella << MissingHeader.FileName;
1830       } else {
1831         getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1832           << Module->getFullModuleName()
1833           << Requirement.second << Requirement.first
1834           << SourceRange(Path.front().second, Path.back().second);
1835       }
1836       LastModuleImportLoc = ImportLoc;
1837       LastModuleImportResult = ModuleLoadResult();
1838       return ModuleLoadResult();
1839     }
1840
1841     ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1842   }
1843
1844   // Check for any configuration macros that have changed.
1845   clang::Module *TopModule = Module->getTopLevelModule();
1846   for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1847     checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1848                      Module, ImportLoc);
1849   }
1850
1851   LastModuleImportLoc = ImportLoc;
1852   LastModuleImportResult = ModuleLoadResult(Module);
1853   return LastModuleImportResult;
1854 }
1855
1856 void CompilerInstance::makeModuleVisible(Module *Mod,
1857                                          Module::NameVisibilityKind Visibility,
1858                                          SourceLocation ImportLoc) {
1859   if (!ModuleManager)
1860     createModuleManager();
1861   if (!ModuleManager)
1862     return;
1863
1864   ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
1865 }
1866
1867 GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex(
1868     SourceLocation TriggerLoc) {
1869   if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
1870     return nullptr;
1871   if (!ModuleManager)
1872     createModuleManager();
1873   // Can't do anything if we don't have the module manager.
1874   if (!ModuleManager)
1875     return nullptr;
1876   // Get an existing global index.  This loads it if not already
1877   // loaded.
1878   ModuleManager->loadGlobalIndex();
1879   GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1880   // If the global index doesn't exist, create it.
1881   if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1882       hasPreprocessor()) {
1883     llvm::sys::fs::create_directories(
1884       getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1885     GlobalModuleIndex::writeIndex(
1886         getFileManager(), getPCHContainerReader(),
1887         getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1888     ModuleManager->resetForReload();
1889     ModuleManager->loadGlobalIndex();
1890     GlobalIndex = ModuleManager->getGlobalIndex();
1891   }
1892   // For finding modules needing to be imported for fixit messages,
1893   // we need to make the global index cover all modules, so we do that here.
1894   if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1895     ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
1896     bool RecreateIndex = false;
1897     for (ModuleMap::module_iterator I = MMap.module_begin(),
1898         E = MMap.module_end(); I != E; ++I) {
1899       Module *TheModule = I->second;
1900       const FileEntry *Entry = TheModule->getASTFile();
1901       if (!Entry) {
1902         SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1903         Path.push_back(std::make_pair(
1904             getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
1905         std::reverse(Path.begin(), Path.end());
1906         // Load a module as hidden.  This also adds it to the global index.
1907         loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
1908         RecreateIndex = true;
1909       }
1910     }
1911     if (RecreateIndex) {
1912       GlobalModuleIndex::writeIndex(
1913           getFileManager(), getPCHContainerReader(),
1914           getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1915       ModuleManager->resetForReload();
1916       ModuleManager->loadGlobalIndex();
1917       GlobalIndex = ModuleManager->getGlobalIndex();
1918     }
1919     HaveFullGlobalModuleIndex = true;
1920   }
1921   return GlobalIndex;
1922 }
1923
1924 // Check global module index for missing imports.
1925 bool
1926 CompilerInstance::lookupMissingImports(StringRef Name,
1927                                        SourceLocation TriggerLoc) {
1928   // Look for the symbol in non-imported modules, but only if an error
1929   // actually occurred.
1930   if (!buildingModule()) {
1931     // Load global module index, or retrieve a previously loaded one.
1932     GlobalModuleIndex *GlobalIndex = loadGlobalModuleIndex(
1933       TriggerLoc);
1934
1935     // Only if we have a global index.
1936     if (GlobalIndex) {
1937       GlobalModuleIndex::HitSet FoundModules;
1938
1939       // Find the modules that reference the identifier.
1940       // Note that this only finds top-level modules.
1941       // We'll let diagnoseTypo find the actual declaration module.
1942       if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1943         return true;
1944     }
1945   }
1946
1947   return false;
1948 }
1949 void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }
1950
1951 void CompilerInstance::setExternalSemaSource(
1952     IntrusiveRefCntPtr<ExternalSemaSource> ESS) {
1953   ExternalSemaSrc = std::move(ESS);
1954 }