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