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