clang  7.0.0svn
CompilerInstance.cpp
Go to the documentation of this file.
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 
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/Decl.h"
14 #include "clang/Basic/CharInfo.h"
15 #include "clang/Basic/Diagnostic.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Basic/Version.h"
21 #include "clang/Config/config.h"
29 #include "clang/Frontend/Utils.h"
31 #include "clang/Lex/HeaderSearch.h"
32 #include "clang/Lex/PTHManager.h"
33 #include "clang/Lex/Preprocessor.h"
36 #include "clang/Sema/Sema.h"
39 #include "llvm/ADT/Statistic.h"
40 #include "llvm/Support/CrashRecoveryContext.h"
41 #include "llvm/Support/Errc.h"
42 #include "llvm/Support/FileSystem.h"
43 #include "llvm/Support/Host.h"
44 #include "llvm/Support/LockFileManager.h"
45 #include "llvm/Support/MemoryBuffer.h"
46 #include "llvm/Support/Path.h"
47 #include "llvm/Support/Program.h"
48 #include "llvm/Support/Signals.h"
49 #include "llvm/Support/Timer.h"
50 #include "llvm/Support/raw_ostream.h"
51 #include <sys/stat.h>
52 #include <system_error>
53 #include <time.h>
54 #include <utility>
55 
56 using namespace clang;
57 
58 CompilerInstance::CompilerInstance(
59  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
60  MemoryBufferCache *SharedPCMCache)
61  : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
62  Invocation(new CompilerInvocation()),
63  PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
64  ThePCHContainerOperations(std::move(PCHContainerOps)) {
65  // Don't allow this to invalidate buffers in use by others.
66  if (SharedPCMCache)
68 }
69 
71  assert(OutputFiles.empty() && "Still output files in flight?");
72 }
73 
75  std::shared_ptr<CompilerInvocation> Value) {
76  Invocation = std::move(Value);
77 }
78 
80  return (BuildGlobalModuleIndex ||
81  (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
83  !ModuleBuildFailed;
84 }
85 
87  Diagnostics = Value;
88 }
89 
92 
94  FileMgr = Value;
95  if (Value)
96  VirtualFileSystem = Value->getVirtualFileSystem();
97  else
98  VirtualFileSystem.reset();
99 }
100 
102  SourceMgr = Value;
103 }
104 
105 void CompilerInstance::setPreprocessor(std::shared_ptr<Preprocessor> Value) {
106  PP = std::move(Value);
107 }
108 
110  Context = Value;
111 
112  if (Context && Consumer)
114 }
115 
117  TheSema.reset(S);
118 }
119 
120 void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
121  Consumer = std::move(Value);
122 
123  if (Context && Consumer)
125 }
126 
128  CompletionConsumer.reset(Value);
129 }
130 
131 std::unique_ptr<Sema> CompilerInstance::takeSema() {
132  return std::move(TheSema);
133 }
134 
136  return ModuleManager;
137 }
139  assert(PCMCache.get() == &Reader->getModuleManager().getPCMCache() &&
140  "Expected ASTReader to use the same PCM cache");
141  ModuleManager = std::move(Reader);
142 }
143 
144 std::shared_ptr<ModuleDependencyCollector>
146  return ModuleDepCollector;
147 }
148 
150  std::shared_ptr<ModuleDependencyCollector> Collector) {
151  ModuleDepCollector = std::move(Collector);
152 }
153 
154 static void collectHeaderMaps(const HeaderSearch &HS,
155  std::shared_ptr<ModuleDependencyCollector> MDC) {
156  SmallVector<std::string, 4> HeaderMapFileNames;
157  HS.getHeaderMapFileNames(HeaderMapFileNames);
158  for (auto &Name : HeaderMapFileNames)
159  MDC->addFile(Name);
160 }
161 
163  std::shared_ptr<ModuleDependencyCollector> MDC) {
164  const PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
165  if (PPOpts.ImplicitPCHInclude.empty())
166  return;
167 
168  StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
169  FileManager &FileMgr = CI.getFileManager();
170  const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude);
171  if (!PCHDir) {
172  MDC->addFile(PCHInclude);
173  return;
174  }
175 
176  std::error_code EC;
177  SmallString<128> DirNative;
178  llvm::sys::path::native(PCHDir->getName(), DirNative);
179  vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
181  for (vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC), DirEnd;
182  Dir != DirEnd && !EC; Dir.increment(EC)) {
183  // Check whether this is an AST file. ASTReader::isAcceptableASTFile is not
184  // used here since we're not interested in validating the PCH at this time,
185  // but only to check whether this is a file containing an AST.
187  Dir->getName(), FileMgr, CI.getPCHContainerReader(),
188  /*FindModuleFileExtensions=*/false, Validator,
189  /*ValidateDiagnosticOptions=*/false))
190  MDC->addFile(Dir->getName());
191  }
192 }
193 
195  std::shared_ptr<ModuleDependencyCollector> MDC) {
196  if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
197  return;
198 
199  // Collect all VFS found.
201  for (const std::string &VFSFile : CI.getHeaderSearchOpts().VFSOverlayFiles) {
202  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
203  llvm::MemoryBuffer::getFile(VFSFile);
204  if (!Buffer)
205  return;
206  vfs::collectVFSFromYAML(std::move(Buffer.get()), /*DiagHandler*/ nullptr,
207  VFSFile, VFSEntries);
208  }
209 
210  for (auto &E : VFSEntries)
211  MDC->addFile(E.VPath, E.RPath);
212 }
213 
214 // Diagnostics
215 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
216  const CodeGenOptions *CodeGenOpts,
217  DiagnosticsEngine &Diags) {
218  std::error_code EC;
219  std::unique_ptr<raw_ostream> StreamOwner;
220  raw_ostream *OS = &llvm::errs();
221  if (DiagOpts->DiagnosticLogFile != "-") {
222  // Create the output stream.
223  auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
224  DiagOpts->DiagnosticLogFile, EC,
225  llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
226  if (EC) {
227  Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
228  << DiagOpts->DiagnosticLogFile << EC.message();
229  } else {
230  FileOS->SetUnbuffered();
231  OS = FileOS.get();
232  StreamOwner = std::move(FileOS);
233  }
234  }
235 
236  // Chain in the diagnostic client which will log the diagnostics.
237  auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
238  std::move(StreamOwner));
239  if (CodeGenOpts)
240  Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
241  assert(Diags.ownsClient());
242  Diags.setClient(
243  new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
244 }
245 
247  DiagnosticsEngine &Diags,
248  StringRef OutputFile) {
249  auto SerializedConsumer =
250  clang::serialized_diags::create(OutputFile, DiagOpts);
251 
252  if (Diags.ownsClient()) {
254  Diags.takeClient(), std::move(SerializedConsumer)));
255  } else {
257  Diags.getClient(), std::move(SerializedConsumer)));
258  }
259 }
260 
262  bool ShouldOwnClient) {
263  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
264  ShouldOwnClient, &getCodeGenOpts());
265 }
266 
269  DiagnosticConsumer *Client,
270  bool ShouldOwnClient,
271  const CodeGenOptions *CodeGenOpts) {
274  Diags(new DiagnosticsEngine(DiagID, Opts));
275 
276  // Create the diagnostic client for reporting errors or for
277  // implementing -verify.
278  if (Client) {
279  Diags->setClient(Client, ShouldOwnClient);
280  } else
281  Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
282 
283  // Chain in -verify checker, if requested.
284  if (Opts->VerifyDiagnostics)
285  Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
286 
287  // Chain in -diagnostic-log-file dumper, if requested.
288  if (!Opts->DiagnosticLogFile.empty())
289  SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
290 
291  if (!Opts->DiagnosticSerializationFile.empty())
292  SetupSerializedDiagnostics(Opts, *Diags,
294 
295  // Configure our handling of diagnostics.
296  ProcessWarningOptions(*Diags, *Opts);
297 
298  return Diags;
299 }
300 
301 // File Manager
302 
304  if (!hasVirtualFileSystem()) {
308  }
309  FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
310  return FileMgr.get();
311 }
312 
313 // Source Manager
314 
316  SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
317 }
318 
319 // Initialize the remapping of files to alternative contents, e.g.,
320 // those specified through other files.
322  SourceManager &SourceMgr,
323  FileManager &FileMgr,
324  const PreprocessorOptions &InitOpts) {
325  // Remap files in the source manager (with buffers).
326  for (const auto &RB : InitOpts.RemappedFileBuffers) {
327  // Create the file entry for the file that we're mapping from.
328  const FileEntry *FromFile =
329  FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
330  if (!FromFile) {
331  Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
332  if (!InitOpts.RetainRemappedFileBuffers)
333  delete RB.second;
334  continue;
335  }
336 
337  // Override the contents of the "from" file with the contents of
338  // the "to" file.
339  SourceMgr.overrideFileContents(FromFile, RB.second,
340  InitOpts.RetainRemappedFileBuffers);
341  }
342 
343  // Remap files in the source manager (with other files).
344  for (const auto &RF : InitOpts.RemappedFiles) {
345  // Find the file that we're mapping to.
346  const FileEntry *ToFile = FileMgr.getFile(RF.second);
347  if (!ToFile) {
348  Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
349  continue;
350  }
351 
352  // Create the file entry for the file that we're mapping from.
353  const FileEntry *FromFile =
354  FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
355  if (!FromFile) {
356  Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
357  continue;
358  }
359 
360  // Override the contents of the "from" file with the contents of
361  // the "to" file.
362  SourceMgr.overrideFileContents(FromFile, ToFile);
363  }
364 
367 }
368 
369 // Preprocessor
370 
372  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
373 
374  // Create a PTH manager if we are using some form of a token cache.
375  PTHManager *PTHMgr = nullptr;
376  if (!PPOpts.TokenCache.empty())
377  PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
378 
379  // Create the Preprocessor.
380  HeaderSearch *HeaderInfo =
383  PP = std::make_shared<Preprocessor>(
384  Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
385  getSourceManager(), getPCMCache(), *HeaderInfo, *this, PTHMgr,
386  /*OwnsHeaderSearch=*/true, TUKind);
388  PP->Initialize(getTarget(), getAuxTarget());
389 
390  // Note that this is different then passing PTHMgr to Preprocessor's ctor.
391  // That argument is used as the IdentifierInfoLookup argument to
392  // IdentifierTable's ctor.
393  if (PTHMgr) {
394  PTHMgr->setPreprocessor(&*PP);
395  PP->setPTHManager(PTHMgr);
396  }
397 
398  if (PPOpts.DetailedRecord)
399  PP->createPreprocessingRecord();
400 
401  // Apply remappings to the source manager.
402  InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
403  PP->getFileManager(), PPOpts);
404 
405  // Predefine macros and configure the preprocessor.
407  getFrontendOpts());
408 
409  // Initialize the header search object. In CUDA compilations, we use the aux
410  // triple (the host triple) to initialize our header search, since we need to
411  // find the host headers in order to compile the CUDA code.
412  const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
413  if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
414  PP->getAuxTargetInfo())
415  HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
416 
417  ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
418  PP->getLangOpts(), *HeaderSearchTriple);
419 
420  PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
421 
422  if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
423  PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
424 
425  // Handle generating dependencies, if requested.
427  if (!DepOpts.OutputFile.empty())
428  TheDependencyFileGenerator.reset(
430  if (!DepOpts.DOTOutputFile.empty())
433 
434  // If we don't have a collector, but we are collecting module dependencies,
435  // then we're the top level compiler instance and need to create one.
436  if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
437  ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
438  DepOpts.ModuleDependencyOutputDir);
439  }
440 
441  // If there is a module dep collector, register with other dep collectors
442  // and also (a) collect header maps and (b) TODO: input vfs overlay files.
443  if (ModuleDepCollector) {
444  addDependencyCollector(ModuleDepCollector);
445  collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
446  collectIncludePCH(*this, ModuleDepCollector);
447  collectVFSEntries(*this, ModuleDepCollector);
448  }
449 
450  for (auto &Listener : DependencyCollectors)
451  Listener->attachToPreprocessor(*PP);
452 
453  // Handle generating header include information, if requested.
454  if (DepOpts.ShowHeaderIncludes)
455  AttachHeaderIncludeGen(*PP, DepOpts);
456  if (!DepOpts.HeaderIncludeOutputFile.empty()) {
457  StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
458  if (OutputPath == "-")
459  OutputPath = "";
460  AttachHeaderIncludeGen(*PP, DepOpts,
461  /*ShowAllHeaders=*/true, OutputPath,
462  /*ShowDepth=*/false);
463  }
464 
465  if (DepOpts.PrintShowIncludes) {
466  AttachHeaderIncludeGen(*PP, DepOpts,
467  /*ShowAllHeaders=*/true, /*OutputPath=*/"",
468  /*ShowDepth=*/true, /*MSStyle=*/true);
469  }
470 }
471 
473  // Set up the module path, including the hash for the
474  // module-creation options.
475  SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
476  if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
477  llvm::sys::path::append(SpecificModuleCache,
479  return SpecificModuleCache.str();
480 }
481 
482 // ASTContext
483 
486  auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
488  PP.getBuiltinInfo());
489  Context->InitBuiltinTypes(getTarget(), getAuxTarget());
490  setASTContext(Context);
491 }
492 
493 // ExternalASTSource
494 
496  StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
497  void *DeserializationListener, bool OwnDeserializationListener) {
498  bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
499  ModuleManager = createPCHExternalASTSource(
500  Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
501  AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
503  getFrontendOpts().ModuleFileExtensions,
504  TheDependencyFileGenerator.get(),
505  DependencyCollectors,
506  DeserializationListener,
507  OwnDeserializationListener, Preamble,
509 }
510 
512  StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
513  bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
514  const PCHContainerReader &PCHContainerRdr,
515  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
516  DependencyFileGenerator *DependencyFile,
517  ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
518  void *DeserializationListener, bool OwnDeserializationListener,
519  bool Preamble, bool UseGlobalModuleIndex) {
521 
523  PP, &Context, PCHContainerRdr, Extensions,
524  Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
525  AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
526  HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
527 
528  // We need the external source to be set up before we read the AST, because
529  // eagerly-deserialized declarations may use it.
530  Context.setExternalSource(Reader.get());
531 
532  Reader->setDeserializationListener(
533  static_cast<ASTDeserializationListener *>(DeserializationListener),
534  /*TakeOwnership=*/OwnDeserializationListener);
535 
536  if (DependencyFile)
537  DependencyFile->AttachToASTReader(*Reader);
538  for (auto &Listener : DependencyCollectors)
539  Listener->attachToASTReader(*Reader);
540 
541  switch (Reader->ReadAST(Path,
542  Preamble ? serialization::MK_Preamble
544  SourceLocation(),
546  case ASTReader::Success:
547  // Set the predefines buffer as suggested by the PCH reader. Typically, the
548  // predefines buffer will be empty.
549  PP.setPredefines(Reader->getSuggestedPredefines());
550  return Reader;
551 
552  case ASTReader::Failure:
553  // Unrecoverable failure: don't even try to process the input file.
554  break;
555 
556  case ASTReader::Missing:
561  // No suitable PCH file could be found. Return an error.
562  break;
563  }
564 
565  Context.setExternalSource(nullptr);
566  return nullptr;
567 }
568 
569 // Code Completion
570 
572  StringRef Filename,
573  unsigned Line,
574  unsigned Column) {
575  // Tell the source manager to chop off the given file at a specific
576  // line and column.
577  const FileEntry *Entry = PP.getFileManager().getFile(Filename);
578  if (!Entry) {
579  PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
580  << Filename;
581  return true;
582  }
583 
584  // Truncate the named file at the given line/column.
585  PP.SetCodeCompletionPoint(Entry, Line, Column);
586  return false;
587 }
588 
591  if (!CompletionConsumer) {
594  Loc.FileName, Loc.Line, Loc.Column,
595  getFrontendOpts().CodeCompleteOpts,
596  llvm::outs()));
597  if (!CompletionConsumer)
598  return;
600  Loc.Line, Loc.Column)) {
601  setCodeCompletionConsumer(nullptr);
602  return;
603  }
604 
605  if (CompletionConsumer->isOutputBinary() &&
606  llvm::sys::ChangeStdoutToBinary()) {
607  getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
608  setCodeCompletionConsumer(nullptr);
609  }
610 }
611 
613  FrontendTimerGroup.reset(
614  new llvm::TimerGroup("frontend", "Clang front-end time report"));
615  FrontendTimer.reset(
616  new llvm::Timer("frontend", "Clang front-end timer",
617  *FrontendTimerGroup));
618 }
619 
622  StringRef Filename,
623  unsigned Line,
624  unsigned Column,
625  const CodeCompleteOptions &Opts,
626  raw_ostream &OS) {
627  if (EnableCodeCompletion(PP, Filename, Line, Column))
628  return nullptr;
629 
630  // Set up the creation routine for code-completion.
631  return new PrintingCodeCompleteConsumer(Opts, OS);
632 }
633 
635  CodeCompleteConsumer *CompletionConsumer) {
636  TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
637  TUKind, CompletionConsumer));
638  // Attach the external sema source if there is any.
639  if (ExternalSemaSrc) {
640  TheSema->addExternalSource(ExternalSemaSrc.get());
641  ExternalSemaSrc->InitializeSema(*TheSema);
642  }
643 }
644 
645 // Output Files
646 
647 void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
648  OutputFiles.push_back(std::move(OutFile));
649 }
650 
651 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
652  for (OutputFile &OF : OutputFiles) {
653  if (!OF.TempFilename.empty()) {
654  if (EraseFiles) {
655  llvm::sys::fs::remove(OF.TempFilename);
656  } else {
657  SmallString<128> NewOutFile(OF.Filename);
658 
659  // If '-working-directory' was passed, the output filename should be
660  // relative to that.
661  FileMgr->FixupRelativePath(NewOutFile);
662  if (std::error_code ec =
663  llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
664  getDiagnostics().Report(diag::err_unable_to_rename_temp)
665  << OF.TempFilename << OF.Filename << ec.message();
666 
667  llvm::sys::fs::remove(OF.TempFilename);
668  }
669  }
670  } else if (!OF.Filename.empty() && EraseFiles)
671  llvm::sys::fs::remove(OF.Filename);
672  }
673  OutputFiles.clear();
674  if (DeleteBuiltModules) {
675  for (auto &Module : BuiltModules)
676  llvm::sys::fs::remove(Module.second);
677  BuiltModules.clear();
678  }
679  NonSeekStream.reset();
680 }
681 
682 std::unique_ptr<raw_pwrite_stream>
683 CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
684  StringRef Extension) {
685  return createOutputFile(getFrontendOpts().OutputFile, Binary,
686  /*RemoveFileOnSignal=*/true, InFile, Extension,
687  /*UseTemporary=*/true);
688 }
689 
690 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
691  return llvm::make_unique<llvm::raw_null_ostream>();
692 }
693 
694 std::unique_ptr<raw_pwrite_stream>
695 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
696  bool RemoveFileOnSignal, StringRef InFile,
697  StringRef Extension, bool UseTemporary,
698  bool CreateMissingDirectories) {
699  std::string OutputPathName, TempPathName;
700  std::error_code EC;
701  std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
702  OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
703  UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
704  if (!OS) {
705  getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
706  << EC.message();
707  return nullptr;
708  }
709 
710  // Add the output file -- but don't try to remove "-", since this means we are
711  // using stdin.
713  OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
714 
715  return OS;
716 }
717 
718 std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
719  StringRef OutputPath, std::error_code &Error, bool Binary,
720  bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
721  bool UseTemporary, bool CreateMissingDirectories,
722  std::string *ResultPathName, std::string *TempPathName) {
723  assert((!CreateMissingDirectories || UseTemporary) &&
724  "CreateMissingDirectories is only allowed when using temporary files");
725 
726  std::string OutFile, TempFile;
727  if (!OutputPath.empty()) {
728  OutFile = OutputPath;
729  } else if (InFile == "-") {
730  OutFile = "-";
731  } else if (!Extension.empty()) {
732  SmallString<128> Path(InFile);
733  llvm::sys::path::replace_extension(Path, Extension);
734  OutFile = Path.str();
735  } else {
736  OutFile = "-";
737  }
738 
739  std::unique_ptr<llvm::raw_fd_ostream> OS;
740  std::string OSFile;
741 
742  if (UseTemporary) {
743  if (OutFile == "-")
744  UseTemporary = false;
745  else {
746  llvm::sys::fs::file_status Status;
747  llvm::sys::fs::status(OutputPath, Status);
748  if (llvm::sys::fs::exists(Status)) {
749  // Fail early if we can't write to the final destination.
750  if (!llvm::sys::fs::can_write(OutputPath)) {
751  Error = make_error_code(llvm::errc::operation_not_permitted);
752  return nullptr;
753  }
754 
755  // Don't use a temporary if the output is a special file. This handles
756  // things like '-o /dev/null'
757  if (!llvm::sys::fs::is_regular_file(Status))
758  UseTemporary = false;
759  }
760  }
761  }
762 
763  if (UseTemporary) {
764  // Create a temporary file.
765  // Insert -%%%%%%%% before the extension (if any), and because some tools
766  // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
767  // artifacts, also append .tmp.
768  StringRef OutputExtension = llvm::sys::path::extension(OutFile);
769  SmallString<128> TempPath =
770  StringRef(OutFile).drop_back(OutputExtension.size());
771  TempPath += "-%%%%%%%%";
772  TempPath += OutputExtension;
773  TempPath += ".tmp";
774  int fd;
775  std::error_code EC =
776  llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
777 
778  if (CreateMissingDirectories &&
779  EC == llvm::errc::no_such_file_or_directory) {
780  StringRef Parent = llvm::sys::path::parent_path(OutputPath);
781  EC = llvm::sys::fs::create_directories(Parent);
782  if (!EC) {
783  EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
784  }
785  }
786 
787  if (!EC) {
788  OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
789  OSFile = TempFile = TempPath.str();
790  }
791  // If we failed to create the temporary, fallback to writing to the file
792  // directly. This handles the corner case where we cannot write to the
793  // directory, but can write to the file.
794  }
795 
796  if (!OS) {
797  OSFile = OutFile;
798  OS.reset(new llvm::raw_fd_ostream(
799  OSFile, Error,
800  (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
801  if (Error)
802  return nullptr;
803  }
804 
805  // Make sure the out stream file gets removed if we crash.
806  if (RemoveFileOnSignal)
807  llvm::sys::RemoveFileOnSignal(OSFile);
808 
809  if (ResultPathName)
810  *ResultPathName = OutFile;
811  if (TempPathName)
812  *TempPathName = TempFile;
813 
814  if (!Binary || OS->supportsSeeking())
815  return std::move(OS);
816 
817  auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
818  assert(!NonSeekStream);
819  NonSeekStream = std::move(OS);
820  return std::move(B);
821 }
822 
823 // Initialization Utilities
824 
828  hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
830 }
831 
832 // static
834  const FrontendInputFile &Input, DiagnosticsEngine &Diags,
835  FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
836  DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
842 
843  if (Input.isBuffer()) {
845  Input.getBuffer(), Kind));
846  assert(SourceMgr.getMainFileID().isValid() &&
847  "Couldn't establish MainFileID!");
848  return true;
849  }
850 
851  StringRef InputFile = Input.getFile();
852 
853  // Figure out where to get and map in the main file.
854  if (InputFile != "-") {
855  const FileEntry *File;
856  if (Opts.FindPchSource.empty()) {
857  File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
858  } else {
859  // When building a pch file in clang-cl mode, the .h file is built as if
860  // it was included by a cc file. Since the driver doesn't know about
861  // all include search directories, the frontend must search the input
862  // file through HeaderSearch here, as if it had been included by the
863  // cc file at Opts.FindPchSource.
864  const FileEntry *FindFile = FileMgr.getFile(Opts.FindPchSource);
865  if (!FindFile) {
866  Diags.Report(diag::err_fe_error_reading) << Opts.FindPchSource;
867  return false;
868  }
869  const DirectoryLookup *UnusedCurDir;
871  Includers;
872  Includers.push_back(std::make_pair(FindFile, FindFile->getDir()));
873  File = HS->LookupFile(InputFile, SourceLocation(), /*isAngled=*/false,
874  /*FromDir=*/nullptr,
875  /*CurDir=*/UnusedCurDir, Includers,
876  /*SearchPath=*/nullptr,
877  /*RelativePath=*/nullptr,
878  /*RequestingModule=*/nullptr,
879  /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr,
880  /*SkipCache=*/true);
881  // Also add the header to /showIncludes output.
882  if (File)
883  DepOpts.ShowIncludesPretendHeader = File->getName();
884  }
885  if (!File) {
886  Diags.Report(diag::err_fe_error_reading) << InputFile;
887  return false;
888  }
889 
890  // The natural SourceManager infrastructure can't currently handle named
891  // pipes, but we would at least like to accept them for the main
892  // file. Detect them here, read them with the volatile flag so FileMgr will
893  // pick up the correct size, and simply override their contents as we do for
894  // STDIN.
895  if (File->isNamedPipe()) {
896  auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
897  if (MB) {
898  // Create a new virtual file that will have the correct size.
899  File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
900  SourceMgr.overrideFileContents(File, std::move(*MB));
901  } else {
902  Diags.Report(diag::err_cannot_open_file) << InputFile
903  << MB.getError().message();
904  return false;
905  }
906  }
907 
908  SourceMgr.setMainFileID(
909  SourceMgr.createFileID(File, SourceLocation(), Kind));
910  } else {
911  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
912  llvm::MemoryBuffer::getSTDIN();
913  if (std::error_code EC = SBOrErr.getError()) {
914  Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
915  return false;
916  }
917  std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
918 
919  const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
920  SB->getBufferSize(), 0);
921  SourceMgr.setMainFileID(
922  SourceMgr.createFileID(File, SourceLocation(), Kind));
923  SourceMgr.overrideFileContents(File, std::move(SB));
924  }
925 
926  assert(SourceMgr.getMainFileID().isValid() &&
927  "Couldn't establish MainFileID!");
928  return true;
929 }
930 
931 // High-Level Operations
932 
934  assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
935  assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
936  assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
937 
938  // FIXME: Take this as an argument, once all the APIs we used have moved to
939  // taking it as an input instead of hard-coding llvm::errs.
940  raw_ostream &OS = llvm::errs();
941 
942  // Create the target instance.
944  getInvocation().TargetOpts));
945  if (!hasTarget())
946  return false;
947 
948  // Create TargetInfo for the other side of CUDA and OpenMP compilation.
949  if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
950  !getFrontendOpts().AuxTriple.empty()) {
951  auto TO = std::make_shared<TargetOptions>();
952  TO->Triple = getFrontendOpts().AuxTriple;
953  TO->HostTriple = getTarget().getTriple().str();
955  }
956 
957  // Inform the target of the language options.
958  //
959  // FIXME: We shouldn't need to do this, the target should be immutable once
960  // created. This complexity should be lifted elsewhere.
962 
963  // Adjust target options based on codegen options.
965 
966  // rewriter project will change target built-in bool type from its default.
967  if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
969 
970  // Validate/process some options.
971  if (getHeaderSearchOpts().Verbose)
972  OS << "clang -cc1 version " CLANG_VERSION_STRING
973  << " based upon " << BACKEND_PACKAGE_STRING
974  << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
975 
976  if (getFrontendOpts().ShowTimers)
978 
979  if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
980  llvm::EnableStatistics(false);
981 
982  for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
983  // Reset the ID tables if we are reusing the SourceManager and parsing
984  // regular files.
985  if (hasSourceManager() && !Act.isModelParsingAction())
987 
988  if (Act.BeginSourceFile(*this, FIF)) {
989  Act.Execute();
990  Act.EndSourceFile();
991  }
992  }
993 
994  // Notify the diagnostic client that all files were processed.
996 
997  if (getDiagnosticOpts().ShowCarets) {
998  // We can have multiple diagnostics sharing one diagnostic client.
999  // Get the total number of warnings/errors from the client.
1000  unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
1001  unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
1002 
1003  if (NumWarnings)
1004  OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
1005  if (NumWarnings && NumErrors)
1006  OS << " and ";
1007  if (NumErrors)
1008  OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
1009  if (NumWarnings || NumErrors) {
1010  OS << " generated";
1011  if (getLangOpts().CUDA) {
1012  if (!getLangOpts().CUDAIsDevice) {
1013  OS << " when compiling for host";
1014  } else {
1015  OS << " when compiling for " << getTargetOpts().CPU;
1016  }
1017  }
1018  OS << ".\n";
1019  }
1020  }
1021 
1022  if (getFrontendOpts().ShowStats) {
1023  if (hasFileManager()) {
1025  OS << '\n';
1026  }
1027  llvm::PrintStatistics(OS);
1028  }
1029  StringRef StatsFile = getFrontendOpts().StatsFile;
1030  if (!StatsFile.empty()) {
1031  std::error_code EC;
1032  auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1033  llvm::sys::fs::F_Text);
1034  if (EC) {
1035  getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1036  << StatsFile << EC.message();
1037  } else {
1038  llvm::PrintStatisticsJSON(*StatS);
1039  }
1040  }
1041 
1042  return !getDiagnostics().getClient()->getNumErrors();
1043 }
1044 
1045 /// \brief Determine the appropriate source input kind based on language
1046 /// options.
1048  if (LangOpts.OpenCL)
1049  return InputKind::OpenCL;
1050  if (LangOpts.CUDA)
1051  return InputKind::CUDA;
1052  if (LangOpts.ObjC1)
1053  return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1054  return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1055 }
1056 
1057 /// \brief Compile a module file for the given module, using the options
1058 /// provided by the importing compiler instance. Returns true if the module
1059 /// was built without errors.
1060 static bool
1061 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1062  StringRef ModuleName, FrontendInputFile Input,
1063  StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1064  llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1065  [](CompilerInstance &) {},
1066  llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1067  [](CompilerInstance &) {}) {
1068  // Construct a compiler invocation for creating this module.
1069  auto Invocation =
1070  std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1071 
1072  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1073 
1074  // For any options that aren't intended to affect how a module is built,
1075  // reset them to their default values.
1076  Invocation->getLangOpts()->resetNonModularOptions();
1077  PPOpts.resetNonModularOptions();
1078 
1079  // Remove any macro definitions that are explicitly ignored by the module.
1080  // They aren't supposed to affect how the module is built anyway.
1081  HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1082  PPOpts.Macros.erase(
1083  std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1084  [&HSOpts](const std::pair<std::string, bool> &def) {
1085  StringRef MacroDef = def.first;
1086  return HSOpts.ModulesIgnoreMacros.count(
1087  llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1088  }),
1089  PPOpts.Macros.end());
1090 
1091  // If the original compiler invocation had -fmodule-name, pass it through.
1092  Invocation->getLangOpts()->ModuleName =
1093  ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1094 
1095  // Note the name of the module we're building.
1096  Invocation->getLangOpts()->CurrentModule = ModuleName;
1097 
1098  // Make sure that the failed-module structure has been allocated in
1099  // the importing instance, and propagate the pointer to the newly-created
1100  // instance.
1101  PreprocessorOptions &ImportingPPOpts
1102  = ImportingInstance.getInvocation().getPreprocessorOpts();
1103  if (!ImportingPPOpts.FailedModules)
1104  ImportingPPOpts.FailedModules =
1105  std::make_shared<PreprocessorOptions::FailedModulesSet>();
1106  PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1107 
1108  // If there is a module map file, build the module using the module map.
1109  // Set up the inputs/outputs so that we build the module from its umbrella
1110  // header.
1111  FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1112  FrontendOpts.OutputFile = ModuleFileName.str();
1113  FrontendOpts.DisableFree = false;
1114  FrontendOpts.GenerateGlobalModuleIndex = false;
1115  FrontendOpts.BuildingImplicitModule = true;
1116  FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1117  // Force implicitly-built modules to hash the content of the module file.
1118  HSOpts.ModulesHashContent = true;
1119  FrontendOpts.Inputs = {Input};
1120 
1121  // Don't free the remapped file buffers; they are owned by our caller.
1122  PPOpts.RetainRemappedFileBuffers = true;
1123 
1124  Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1125  assert(ImportingInstance.getInvocation().getModuleHash() ==
1126  Invocation->getModuleHash() && "Module hash mismatch!");
1127 
1128  // Construct a compiler instance that will be used to actually create the
1129  // module. Since we're sharing a PCMCache,
1130  // CompilerInstance::CompilerInstance is responsible for finalizing the
1131  // buffers to prevent use-after-frees.
1132  CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1133  &ImportingInstance.getPreprocessor().getPCMCache());
1134  auto &Inv = *Invocation;
1135  Instance.setInvocation(std::move(Invocation));
1136 
1137  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1138  ImportingInstance.getDiagnosticClient()),
1139  /*ShouldOwnClient=*/true);
1140 
1141  Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1142 
1143  // Note that this module is part of the module build stack, so that we
1144  // can detect cycles in the module graph.
1145  Instance.setFileManager(&ImportingInstance.getFileManager());
1146  Instance.createSourceManager(Instance.getFileManager());
1147  SourceManager &SourceMgr = Instance.getSourceManager();
1148  SourceMgr.setModuleBuildStack(
1149  ImportingInstance.getSourceManager().getModuleBuildStack());
1150  SourceMgr.pushModuleBuildStack(ModuleName,
1151  FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1152 
1153  // If we're collecting module dependencies, we need to share a collector
1154  // between all of the module CompilerInstances. Other than that, we don't
1155  // want to produce any dependency output from the module build.
1156  Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1157  Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1158 
1159  ImportingInstance.getDiagnostics().Report(ImportLoc,
1160  diag::remark_module_build)
1161  << ModuleName << ModuleFileName;
1162 
1163  PreBuildStep(Instance);
1164 
1165  // Execute the action to actually build the module in-place. Use a separate
1166  // thread so that we get a stack large enough.
1167  const unsigned ThreadStackSize = 8 << 20;
1168  llvm::CrashRecoveryContext CRC;
1169  CRC.RunSafelyOnThread(
1170  [&]() {
1172  Instance.ExecuteAction(Action);
1173  },
1174  ThreadStackSize);
1175 
1176  PostBuildStep(Instance);
1177 
1178  ImportingInstance.getDiagnostics().Report(ImportLoc,
1179  diag::remark_module_build_done)
1180  << ModuleName;
1181 
1182  // Delete the temporary module map file.
1183  // FIXME: Even though we're executing under crash protection, it would still
1184  // be nice to do this with RemoveFileOnSignal when we can. However, that
1185  // doesn't make sense for all clients, so clean this up manually.
1186  Instance.clearOutputFiles(/*EraseFiles=*/true);
1187 
1188  return !Instance.getDiagnostics().hasErrorOccurred();
1189 }
1190 
1191 /// \brief Compile a module file for the given module, using the options
1192 /// provided by the importing compiler instance. Returns true if the module
1193 /// was built without errors.
1194 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1195  SourceLocation ImportLoc,
1196  Module *Module,
1197  StringRef ModuleFileName) {
1198  InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1200 
1201  // Get or create the module map that we'll use to build this module.
1202  ModuleMap &ModMap
1203  = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1204  bool Result;
1205  if (const FileEntry *ModuleMapFile =
1206  ModMap.getContainingModuleMapFile(Module)) {
1207  // Use the module map where this module resides.
1208  Result = compileModuleImpl(
1209  ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1210  FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1211  ModMap.getModuleMapFileForUniquing(Module)->getName(),
1212  ModuleFileName);
1213  } else {
1214  // FIXME: We only need to fake up an input file here as a way of
1215  // transporting the module's directory to the module map parser. We should
1216  // be able to do that more directly, and parse from a memory buffer without
1217  // inventing this file.
1218  SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1219  llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1220 
1221  std::string InferredModuleMapContent;
1222  llvm::raw_string_ostream OS(InferredModuleMapContent);
1223  Module->print(OS);
1224  OS.flush();
1225 
1226  Result = compileModuleImpl(
1227  ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1228  FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1229  ModMap.getModuleMapFileForUniquing(Module)->getName(),
1230  ModuleFileName,
1231  [&](CompilerInstance &Instance) {
1232  std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1233  llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1234  ModuleMapFile = Instance.getFileManager().getVirtualFile(
1235  FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1236  Instance.getSourceManager().overrideFileContents(
1237  ModuleMapFile, std::move(ModuleMapBuffer));
1238  });
1239  }
1240 
1241  // We've rebuilt a module. If we're allowed to generate or update the global
1242  // module index, record that fact in the importing compiler instance.
1243  if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1244  ImportingInstance.setBuildGlobalModuleIndex(true);
1245  }
1246 
1247  return Result;
1248 }
1249 
1250 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1251  SourceLocation ImportLoc,
1252  SourceLocation ModuleNameLoc, Module *Module,
1253  StringRef ModuleFileName) {
1254  DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1255 
1256  auto diagnoseBuildFailure = [&] {
1257  Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1258  << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1259  };
1260 
1261  // FIXME: have LockFileManager return an error_code so that we can
1262  // avoid the mkdir when the directory already exists.
1263  StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1264  llvm::sys::fs::create_directories(Dir);
1265 
1266  while (1) {
1267  unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1268  llvm::LockFileManager Locked(ModuleFileName);
1269  switch (Locked) {
1270  case llvm::LockFileManager::LFS_Error:
1271  // PCMCache takes care of correctness and locks are only necessary for
1272  // performance. Fallback to building the module in case of any lock
1273  // related errors.
1274  Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1275  << Module->Name << Locked.getErrorMessage();
1276  // Clear out any potential leftover.
1277  Locked.unsafeRemoveLockFile();
1278  // FALLTHROUGH
1279  case llvm::LockFileManager::LFS_Owned:
1280  // We're responsible for building the module ourselves.
1281  if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1282  ModuleFileName)) {
1283  diagnoseBuildFailure();
1284  return false;
1285  }
1286  break;
1287 
1288  case llvm::LockFileManager::LFS_Shared:
1289  // Someone else is responsible for building the module. Wait for them to
1290  // finish.
1291  switch (Locked.waitForUnlock()) {
1292  case llvm::LockFileManager::Res_Success:
1293  ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1294  break;
1295  case llvm::LockFileManager::Res_OwnerDied:
1296  continue; // try again to get the lock.
1297  case llvm::LockFileManager::Res_Timeout:
1298  // Since PCMCache takes care of correctness, we try waiting for another
1299  // process to complete the build so clang does not do it done twice. If
1300  // case of timeout, build it ourselves.
1301  Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1302  << Module->Name;
1303  // Clear the lock file so that future invocations can make progress.
1304  Locked.unsafeRemoveLockFile();
1305  continue;
1306  }
1307  break;
1308  }
1309 
1310  // Try to read the module file, now that we've compiled it.
1311  ASTReader::ASTReadResult ReadResult =
1312  ImportingInstance.getModuleManager()->ReadAST(
1313  ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1314  ModuleLoadCapabilities);
1315 
1316  if (ReadResult == ASTReader::OutOfDate &&
1317  Locked == llvm::LockFileManager::LFS_Shared) {
1318  // The module may be out of date in the presence of file system races,
1319  // or if one of its imports depends on header search paths that are not
1320  // consistent with this ImportingInstance. Try again...
1321  continue;
1322  } else if (ReadResult == ASTReader::Missing) {
1323  diagnoseBuildFailure();
1324  } else if (ReadResult != ASTReader::Success &&
1325  !Diags.hasErrorOccurred()) {
1326  // The ASTReader didn't diagnose the error, so conservatively report it.
1327  diagnoseBuildFailure();
1328  }
1329  return ReadResult == ASTReader::Success;
1330  }
1331 }
1332 
1333 /// \brief Diagnose differences between the current definition of the given
1334 /// configuration macro and the definition provided on the command line.
1335 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1336  Module *Mod, SourceLocation ImportLoc) {
1337  IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1338  SourceManager &SourceMgr = PP.getSourceManager();
1339 
1340  // If this identifier has never had a macro definition, then it could
1341  // not have changed.
1342  if (!Id->hadMacroDefinition())
1343  return;
1344  auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1345 
1346  // Find the macro definition from the command line.
1347  MacroInfo *CmdLineDefinition = nullptr;
1348  for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1349  // We only care about the predefines buffer.
1350  FileID FID = SourceMgr.getFileID(MD->getLocation());
1351  if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1352  continue;
1353  if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1354  CmdLineDefinition = DMD->getMacroInfo();
1355  break;
1356  }
1357 
1358  auto *CurrentDefinition = PP.getMacroInfo(Id);
1359  if (CurrentDefinition == CmdLineDefinition) {
1360  // Macro matches. Nothing to do.
1361  } else if (!CurrentDefinition) {
1362  // This macro was defined on the command line, then #undef'd later.
1363  // Complain.
1364  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1365  << true << ConfigMacro << Mod->getFullModuleName();
1366  auto LatestDef = LatestLocalMD->getDefinition();
1367  assert(LatestDef.isUndefined() &&
1368  "predefined macro went away with no #undef?");
1369  PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1370  << true;
1371  return;
1372  } else if (!CmdLineDefinition) {
1373  // There was no definition for this macro in the predefines buffer,
1374  // but there was a local definition. Complain.
1375  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1376  << false << ConfigMacro << Mod->getFullModuleName();
1377  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1378  diag::note_module_def_undef_here)
1379  << false;
1380  } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1381  /*Syntactically=*/true)) {
1382  // The macro definitions differ.
1383  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1384  << false << ConfigMacro << Mod->getFullModuleName();
1385  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1386  diag::note_module_def_undef_here)
1387  << false;
1388  }
1389 }
1390 
1391 /// \brief Write a new timestamp file with the given path.
1392 static void writeTimestampFile(StringRef TimestampFile) {
1393  std::error_code EC;
1394  llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1395 }
1396 
1397 /// \brief Prune the module cache of modules that haven't been accessed in
1398 /// a long time.
1399 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1400  struct stat StatBuf;
1401  llvm::SmallString<128> TimestampFile;
1402  TimestampFile = HSOpts.ModuleCachePath;
1403  assert(!TimestampFile.empty());
1404  llvm::sys::path::append(TimestampFile, "modules.timestamp");
1405 
1406  // Try to stat() the timestamp file.
1407  if (::stat(TimestampFile.c_str(), &StatBuf)) {
1408  // If the timestamp file wasn't there, create one now.
1409  if (errno == ENOENT) {
1410  writeTimestampFile(TimestampFile);
1411  }
1412  return;
1413  }
1414 
1415  // Check whether the time stamp is older than our pruning interval.
1416  // If not, do nothing.
1417  time_t TimeStampModTime = StatBuf.st_mtime;
1418  time_t CurrentTime = time(nullptr);
1419  if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1420  return;
1421 
1422  // Write a new timestamp file so that nobody else attempts to prune.
1423  // There is a benign race condition here, if two Clang instances happen to
1424  // notice at the same time that the timestamp is out-of-date.
1425  writeTimestampFile(TimestampFile);
1426 
1427  // Walk the entire module cache, looking for unused module files and module
1428  // indices.
1429  std::error_code EC;
1430  SmallString<128> ModuleCachePathNative;
1431  llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1432  for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1433  Dir != DirEnd && !EC; Dir.increment(EC)) {
1434  // If we don't have a directory, there's nothing to look into.
1435  if (!llvm::sys::fs::is_directory(Dir->path()))
1436  continue;
1437 
1438  // Walk all of the files within this directory.
1439  for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1440  File != FileEnd && !EC; File.increment(EC)) {
1441  // We only care about module and global module index files.
1442  StringRef Extension = llvm::sys::path::extension(File->path());
1443  if (Extension != ".pcm" && Extension != ".timestamp" &&
1444  llvm::sys::path::filename(File->path()) != "modules.idx")
1445  continue;
1446 
1447  // Look at this file. If we can't stat it, there's nothing interesting
1448  // there.
1449  if (::stat(File->path().c_str(), &StatBuf))
1450  continue;
1451 
1452  // If the file has been used recently enough, leave it there.
1453  time_t FileAccessTime = StatBuf.st_atime;
1454  if (CurrentTime - FileAccessTime <=
1455  time_t(HSOpts.ModuleCachePruneAfter)) {
1456  continue;
1457  }
1458 
1459  // Remove the file.
1460  llvm::sys::fs::remove(File->path());
1461 
1462  // Remove the timestamp file.
1463  std::string TimpestampFilename = File->path() + ".timestamp";
1464  llvm::sys::fs::remove(TimpestampFilename);
1465  }
1466 
1467  // If we removed all of the files in the directory, remove the directory
1468  // itself.
1469  if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1470  llvm::sys::fs::directory_iterator() && !EC)
1471  llvm::sys::fs::remove(Dir->path());
1472  }
1473 }
1474 
1476  if (!ModuleManager) {
1477  if (!hasASTContext())
1478  createASTContext();
1479 
1480  // If we're implicitly building modules but not currently recursively
1481  // building a module, check whether we need to prune the module cache.
1482  if (getSourceManager().getModuleBuildStack().empty() &&
1483  !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1484  getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1485  getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1487  }
1488 
1490  std::string Sysroot = HSOpts.Sysroot;
1491  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1492  std::unique_ptr<llvm::Timer> ReadTimer;
1493  if (FrontendTimerGroup)
1494  ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1495  "Reading modules",
1496  *FrontendTimerGroup);
1497  ModuleManager = new ASTReader(
1499  getFrontendOpts().ModuleFileExtensions,
1500  Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1501  /*AllowASTWithCompilerErrors=*/false,
1502  /*AllowConfigurationMismatch=*/false,
1505  std::move(ReadTimer));
1506  if (hasASTConsumer()) {
1507  ModuleManager->setDeserializationListener(
1508  getASTConsumer().GetASTDeserializationListener());
1510  getASTConsumer().GetASTMutationListener());
1511  }
1512  getASTContext().setExternalSource(ModuleManager);
1513  if (hasSema())
1514  ModuleManager->InitializeSema(getSema());
1515  if (hasASTConsumer())
1516  ModuleManager->StartTranslationUnit(&getASTConsumer());
1517 
1518  if (TheDependencyFileGenerator)
1519  TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1520  for (auto &Listener : DependencyCollectors)
1521  Listener->attachToASTReader(*ModuleManager);
1522  }
1523 }
1524 
1525 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1526  llvm::Timer Timer;
1527  if (FrontendTimerGroup)
1528  Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1529  *FrontendTimerGroup);
1530  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1531 
1532  // Helper to recursively read the module names for all modules we're adding.
1533  // We mark these as known and redirect any attempt to load that module to
1534  // the files we were handed.
1535  struct ReadModuleNames : ASTReaderListener {
1536  CompilerInstance &CI;
1538 
1539  ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1540 
1541  void ReadModuleName(StringRef ModuleName) override {
1542  LoadedModules.push_back(
1543  CI.getPreprocessor().getIdentifierInfo(ModuleName));
1544  }
1545 
1546  void registerAll() {
1547  for (auto *II : LoadedModules) {
1548  CI.KnownModules[II] = CI.getPreprocessor()
1550  .getModuleMap()
1551  .findModule(II->getName());
1552  }
1553  LoadedModules.clear();
1554  }
1555 
1556  void markAllUnavailable() {
1557  for (auto *II : LoadedModules) {
1558  if (Module *M = CI.getPreprocessor()
1560  .getModuleMap()
1561  .findModule(II->getName())) {
1562  M->HasIncompatibleModuleFile = true;
1563 
1564  // Mark module as available if the only reason it was unavailable
1565  // was missing headers.
1567  Stack.push_back(M);
1568  while (!Stack.empty()) {
1569  Module *Current = Stack.pop_back_val();
1570  if (Current->IsMissingRequirement) continue;
1571  Current->IsAvailable = true;
1572  Stack.insert(Stack.end(),
1573  Current->submodule_begin(), Current->submodule_end());
1574  }
1575  }
1576  }
1577  LoadedModules.clear();
1578  }
1579  };
1580 
1581  // If we don't already have an ASTReader, create one now.
1582  if (!ModuleManager)
1584 
1585  auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1586  auto &ListenerRef = *Listener;
1587  ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1588  std::move(Listener));
1589 
1590  // Try to load the module file.
1591  switch (ModuleManager->ReadAST(FileName, serialization::MK_ExplicitModule,
1592  SourceLocation(),
1594  case ASTReader::Success:
1595  // We successfully loaded the module file; remember the set of provided
1596  // modules so that we don't try to load implicit modules for them.
1597  ListenerRef.registerAll();
1598  return true;
1599 
1601  // Ignore unusable module files.
1602  getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1603  << FileName;
1604  // All modules provided by any files we tried and failed to load are now
1605  // unavailable; includes of those modules should now be handled textually.
1606  ListenerRef.markAllUnavailable();
1607  return true;
1608 
1609  default:
1610  return false;
1611  }
1612 }
1613 
1616  ModuleIdPath Path,
1618  bool IsInclusionDirective) {
1619  // Determine what file we're searching from.
1620  // FIXME: Should we be deciding whether this is a submodule (here and
1621  // below) based on -fmodules-ts or should we pass a flag and make the
1622  // caller decide?
1623  std::string ModuleName;
1624  if (getLangOpts().ModulesTS) {
1625  // FIXME: Same code as Sema::ActOnModuleDecl() so there is probably a
1626  // better place/way to do this.
1627  for (auto &Piece : Path) {
1628  if (!ModuleName.empty())
1629  ModuleName += ".";
1630  ModuleName += Piece.first->getName();
1631  }
1632  }
1633  else
1634  ModuleName = Path[0].first->getName();
1635 
1636  SourceLocation ModuleNameLoc = Path[0].second;
1637 
1638  // If we've already handled this import, just return the cached result.
1639  // This one-element cache is important to eliminate redundant diagnostics
1640  // when both the preprocessor and parser see the same import declaration.
1641  if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1642  // Make the named module visible.
1643  if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1644  ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1645  ImportLoc);
1646  return LastModuleImportResult;
1647  }
1648 
1649  clang::Module *Module = nullptr;
1650 
1651  // If we don't already have information on this module, load the module now.
1652  llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1653  = KnownModules.find(Path[0].first);
1654  if (Known != KnownModules.end()) {
1655  // Retrieve the cached top-level module.
1656  Module = Known->second;
1657  } else if (ModuleName == getLangOpts().CurrentModule) {
1658  // This is the module we're building.
1659  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1660  /// FIXME: perhaps we should (a) look for a module using the module name
1661  // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1662  //if (Module == nullptr) {
1663  // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1664  // << ModuleName;
1665  // ModuleBuildFailed = true;
1666  // return ModuleLoadResult();
1667  //}
1668  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1669  } else {
1670  // Search for a module with the given name.
1671  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1672  HeaderSearchOptions &HSOpts =
1673  PP->getHeaderSearchInfo().getHeaderSearchOpts();
1674 
1675  std::string ModuleFileName;
1676  enum ModuleSource {
1677  ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1678  } Source = ModuleNotFound;
1679 
1680  // Check to see if the module has been built as part of this compilation
1681  // via a module build pragma.
1682  auto BuiltModuleIt = BuiltModules.find(ModuleName);
1683  if (BuiltModuleIt != BuiltModules.end()) {
1684  ModuleFileName = BuiltModuleIt->second;
1685  Source = ModuleBuildPragma;
1686  }
1687 
1688  // Try to load the module from the prebuilt module path.
1689  if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1690  !HSOpts.PrebuiltModulePaths.empty())) {
1691  ModuleFileName =
1692  PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1693  if (!ModuleFileName.empty())
1694  Source = PrebuiltModulePath;
1695  }
1696 
1697  // Try to load the module from the module cache.
1698  if (Source == ModuleNotFound && Module) {
1699  ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1700  Source = ModuleCache;
1701  }
1702 
1703  if (Source == ModuleNotFound) {
1704  // We can't find a module, error out here.
1705  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1706  << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1707  ModuleBuildFailed = true;
1708  return ModuleLoadResult();
1709  }
1710 
1711  if (ModuleFileName.empty()) {
1712  if (Module && Module->HasIncompatibleModuleFile) {
1713  // We tried and failed to load a module file for this module. Fall
1714  // back to textual inclusion for its headers.
1716  }
1717 
1718  getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1719  << ModuleName;
1720  ModuleBuildFailed = true;
1721  return ModuleLoadResult();
1722  }
1723 
1724  // If we don't already have an ASTReader, create one now.
1725  if (!ModuleManager)
1727 
1728  llvm::Timer Timer;
1729  if (FrontendTimerGroup)
1730  Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1731  *FrontendTimerGroup);
1732  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1733 
1734  // Try to load the module file. If we are not trying to load from the
1735  // module cache, we don't know how to rebuild modules.
1736  unsigned ARRFlags = Source == ModuleCache ?
1739  switch (ModuleManager->ReadAST(ModuleFileName,
1740  Source == PrebuiltModulePath
1742  : Source == ModuleBuildPragma
1745  ImportLoc, ARRFlags)) {
1746  case ASTReader::Success: {
1747  if (Source != ModuleCache && !Module) {
1748  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1749  if (!Module || !Module->getASTFile() ||
1750  FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1751  // Error out if Module does not refer to the file in the prebuilt
1752  // module path.
1753  getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1754  << ModuleName;
1755  ModuleBuildFailed = true;
1756  KnownModules[Path[0].first] = nullptr;
1757  return ModuleLoadResult();
1758  }
1759  }
1760  break;
1761  }
1762 
1763  case ASTReader::OutOfDate:
1764  case ASTReader::Missing: {
1765  if (Source != ModuleCache) {
1766  // We don't know the desired configuration for this module and don't
1767  // necessarily even have a module map. Since ReadAST already produces
1768  // diagnostics for these two cases, we simply error out here.
1769  ModuleBuildFailed = true;
1770  KnownModules[Path[0].first] = nullptr;
1771  return ModuleLoadResult();
1772  }
1773 
1774  // The module file is missing or out-of-date. Build it.
1775  assert(Module && "missing module file");
1776  // Check whether there is a cycle in the module graph.
1778  ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1779  for (; Pos != PosEnd; ++Pos) {
1780  if (Pos->first == ModuleName)
1781  break;
1782  }
1783 
1784  if (Pos != PosEnd) {
1785  SmallString<256> CyclePath;
1786  for (; Pos != PosEnd; ++Pos) {
1787  CyclePath += Pos->first;
1788  CyclePath += " -> ";
1789  }
1790  CyclePath += ModuleName;
1791 
1792  getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1793  << ModuleName << CyclePath;
1794  return ModuleLoadResult();
1795  }
1796 
1797  // Check whether we have already attempted to build this module (but
1798  // failed).
1799  if (getPreprocessorOpts().FailedModules &&
1800  getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1801  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1802  << ModuleName
1803  << SourceRange(ImportLoc, ModuleNameLoc);
1804  ModuleBuildFailed = true;
1805  return ModuleLoadResult();
1806  }
1807 
1808  // Try to compile and then load the module.
1809  if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1810  ModuleFileName)) {
1811  assert(getDiagnostics().hasErrorOccurred() &&
1812  "undiagnosed error in compileAndLoadModule");
1813  if (getPreprocessorOpts().FailedModules)
1814  getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1815  KnownModules[Path[0].first] = nullptr;
1816  ModuleBuildFailed = true;
1817  return ModuleLoadResult();
1818  }
1819 
1820  // Okay, we've rebuilt and now loaded the module.
1821  break;
1822  }
1823 
1825  if (Source == PrebuiltModulePath)
1826  // FIXME: We shouldn't be setting HadFatalFailure below if we only
1827  // produce a warning here!
1829  diag::warn_module_config_mismatch)
1830  << ModuleFileName;
1831  // Fall through to error out.
1832  LLVM_FALLTHROUGH;
1834  case ASTReader::HadErrors:
1836  // FIXME: The ASTReader will already have complained, but can we shoehorn
1837  // that diagnostic information into a more useful form?
1838  KnownModules[Path[0].first] = nullptr;
1839  return ModuleLoadResult();
1840 
1841  case ASTReader::Failure:
1843  // Already complained, but note now that we failed.
1844  KnownModules[Path[0].first] = nullptr;
1845  ModuleBuildFailed = true;
1846  return ModuleLoadResult();
1847  }
1848 
1849  // Cache the result of this top-level module lookup for later.
1850  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1851  }
1852 
1853  // If we never found the module, fail.
1854  if (!Module)
1855  return ModuleLoadResult();
1856 
1857  // Verify that the rest of the module path actually corresponds to
1858  // a submodule.
1859  bool MapPrivateSubModToTopLevel = false;
1860  if (!getLangOpts().ModulesTS && Path.size() > 1) {
1861  for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1862  StringRef Name = Path[I].first->getName();
1863  clang::Module *Sub = Module->findSubmodule(Name);
1864 
1865  // If the user is requesting Foo.Private and it doesn't exist, try to
1866  // match Foo_Private and emit a warning asking for the user to write
1867  // @import Foo_Private instead. FIXME: remove this when existing clients
1868  // migrate off of Foo.Private syntax.
1869  if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1870  Module == Module->getTopLevelModule()) {
1871  SmallString<128> PrivateModule(Module->Name);
1872  PrivateModule.append("_Private");
1873 
1875  auto &II = PP->getIdentifierTable().get(
1876  PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1877  PrivPath.push_back(std::make_pair(&II, Path[0].second));
1878 
1879  if (PP->getHeaderSearchInfo().lookupModule(PrivateModule))
1880  Sub =
1881  loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1882  if (Sub) {
1883  MapPrivateSubModToTopLevel = true;
1884  if (!getDiagnostics().isIgnored(
1885  diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1886  getDiagnostics().Report(Path[I].second,
1887  diag::warn_no_priv_submodule_use_toplevel)
1888  << Path[I].first << Module->getFullModuleName() << PrivateModule
1889  << SourceRange(Path[0].second, Path[I].second)
1890  << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1891  PrivateModule);
1893  diag::note_private_top_level_defined);
1894  }
1895  }
1896  }
1897 
1898  if (!Sub) {
1899  // Attempt to perform typo correction to find a module name that works.
1901  unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1902 
1904  JEnd = Module->submodule_end();
1905  J != JEnd; ++J) {
1906  unsigned ED = Name.edit_distance((*J)->Name,
1907  /*AllowReplacements=*/true,
1908  BestEditDistance);
1909  if (ED <= BestEditDistance) {
1910  if (ED < BestEditDistance) {
1911  Best.clear();
1912  BestEditDistance = ED;
1913  }
1914 
1915  Best.push_back((*J)->Name);
1916  }
1917  }
1918 
1919  // If there was a clear winner, user it.
1920  if (Best.size() == 1) {
1921  getDiagnostics().Report(Path[I].second,
1922  diag::err_no_submodule_suggest)
1923  << Path[I].first << Module->getFullModuleName() << Best[0]
1924  << SourceRange(Path[0].second, Path[I-1].second)
1925  << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1926  Best[0]);
1927 
1928  Sub = Module->findSubmodule(Best[0]);
1929  }
1930  }
1931 
1932  if (!Sub) {
1933  // No submodule by this name. Complain, and don't look for further
1934  // submodules.
1935  getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1936  << Path[I].first << Module->getFullModuleName()
1937  << SourceRange(Path[0].second, Path[I-1].second);
1938  break;
1939  }
1940 
1941  Module = Sub;
1942  }
1943  }
1944 
1945  // Make the named module visible, if it's not already part of the module
1946  // we are parsing.
1947  if (ModuleName != getLangOpts().CurrentModule) {
1948  if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1949  // We have an umbrella header or directory that doesn't actually include
1950  // all of the headers within the directory it covers. Complain about
1951  // this missing submodule and recover by forgetting that we ever saw
1952  // this submodule.
1953  // FIXME: Should we detect this at module load time? It seems fairly
1954  // expensive (and rare).
1955  getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1956  << Module->getFullModuleName()
1957  << SourceRange(Path.front().second, Path.back().second);
1958 
1960  }
1961 
1962  // Check whether this module is available.
1964  getDiagnostics(), Module)) {
1965  getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1966  << SourceRange(Path.front().second, Path.back().second);
1967  LastModuleImportLoc = ImportLoc;
1968  LastModuleImportResult = ModuleLoadResult();
1969  return ModuleLoadResult();
1970  }
1971 
1972  ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1973  }
1974 
1975  // Check for any configuration macros that have changed.
1976  clang::Module *TopModule = Module->getTopLevelModule();
1977  for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1979  Module, ImportLoc);
1980  }
1981 
1982  // Resolve any remaining module using export_as for this one.
1983  getPreprocessor()
1985  .getModuleMap()
1986  .resolveLinkAsDependencies(TopModule);
1987 
1988  LastModuleImportLoc = ImportLoc;
1989  LastModuleImportResult = ModuleLoadResult(Module);
1990  return LastModuleImportResult;
1991 }
1992 
1994  StringRef ModuleName,
1995  StringRef Source) {
1996  // Avoid creating filenames with special characters.
1997  SmallString<128> CleanModuleName(ModuleName);
1998  for (auto &C : CleanModuleName)
1999  if (!isAlphanumeric(C))
2000  C = '_';
2001 
2002  // FIXME: Using a randomized filename here means that our intermediate .pcm
2003  // output is nondeterministic (as .pcm files refer to each other by name).
2004  // Can this affect the output in any way?
2005  SmallString<128> ModuleFileName;
2006  if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
2007  CleanModuleName, "pcm", ModuleFileName)) {
2008  getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2009  << ModuleFileName << EC.message();
2010  return;
2011  }
2012  std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2013 
2014  FrontendInputFile Input(
2015  ModuleMapFileName,
2016  InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2017  InputKind::ModuleMap, /*Preprocessed*/true));
2018 
2019  std::string NullTerminatedSource(Source.str());
2020 
2021  auto PreBuildStep = [&](CompilerInstance &Other) {
2022  // Create a virtual file containing our desired source.
2023  // FIXME: We shouldn't need to do this.
2024  const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2025  ModuleMapFileName, NullTerminatedSource.size(), 0);
2026  Other.getSourceManager().overrideFileContents(
2027  ModuleMapFile,
2028  llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2029 
2030  Other.BuiltModules = std::move(BuiltModules);
2031  Other.DeleteBuiltModules = false;
2032  };
2033 
2034  auto PostBuildStep = [this](CompilerInstance &Other) {
2035  BuiltModules = std::move(Other.BuiltModules);
2036  };
2037 
2038  // Build the module, inheriting any modules that we've built locally.
2039  if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2040  ModuleFileName, PreBuildStep, PostBuildStep)) {
2041  BuiltModules[ModuleName] = ModuleFileName.str();
2042  llvm::sys::RemoveFileOnSignal(ModuleFileName);
2043  }
2044 }
2045 
2048  SourceLocation ImportLoc) {
2049  if (!ModuleManager)
2051  if (!ModuleManager)
2052  return;
2053 
2054  ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2055 }
2056 
2058  SourceLocation TriggerLoc) {
2059  if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2060  return nullptr;
2061  if (!ModuleManager)
2063  // Can't do anything if we don't have the module manager.
2064  if (!ModuleManager)
2065  return nullptr;
2066  // Get an existing global index. This loads it if not already
2067  // loaded.
2068  ModuleManager->loadGlobalIndex();
2069  GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2070  // If the global index doesn't exist, create it.
2071  if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2072  hasPreprocessor()) {
2073  llvm::sys::fs::create_directories(
2074  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2077  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2078  ModuleManager->resetForReload();
2079  ModuleManager->loadGlobalIndex();
2080  GlobalIndex = ModuleManager->getGlobalIndex();
2081  }
2082  // For finding modules needing to be imported for fixit messages,
2083  // we need to make the global index cover all modules, so we do that here.
2084  if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2086  bool RecreateIndex = false;
2087  for (ModuleMap::module_iterator I = MMap.module_begin(),
2088  E = MMap.module_end(); I != E; ++I) {
2089  Module *TheModule = I->second;
2090  const FileEntry *Entry = TheModule->getASTFile();
2091  if (!Entry) {
2093  Path.push_back(std::make_pair(
2094  getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2095  std::reverse(Path.begin(), Path.end());
2096  // Load a module as hidden. This also adds it to the global index.
2097  loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2098  RecreateIndex = true;
2099  }
2100  }
2101  if (RecreateIndex) {
2104  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2105  ModuleManager->resetForReload();
2106  ModuleManager->loadGlobalIndex();
2107  GlobalIndex = ModuleManager->getGlobalIndex();
2108  }
2109  HaveFullGlobalModuleIndex = true;
2110  }
2111  return GlobalIndex;
2112 }
2113 
2114 // Check global module index for missing imports.
2115 bool
2117  SourceLocation TriggerLoc) {
2118  // Look for the symbol in non-imported modules, but only if an error
2119  // actually occurred.
2120  if (!buildingModule()) {
2121  // Load global module index, or retrieve a previously loaded one.
2123  TriggerLoc);
2124 
2125  // Only if we have a global index.
2126  if (GlobalIndex) {
2127  GlobalModuleIndex::HitSet FoundModules;
2128 
2129  // Find the modules that reference the identifier.
2130  // Note that this only finds top-level modules.
2131  // We'll let diagnoseTypo find the actual declaration module.
2132  if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2133  return true;
2134  }
2135  }
2136 
2137  return false;
2138 }
2140 
2143  ExternalSemaSrc = std::move(ESS);
2144 }
std::string OutputFile
The output file, if any.
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:213
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:862
static bool compileAndLoadModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)
Defines the clang::ASTContext interface.
LangOptions & getLangOpts()
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
Definition: ASTReader.h:380
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred...
std::string Name
The name of this module.
Definition: Module.h:68
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
bool hasErrorOccurred() const
Definition: Diagnostic.h:746
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:509
std::string DwarfDebugFlags
The string to embed in the debug information for the compile unit, if non-empty.
std::vector< std::string > PrebuiltModulePaths
The directories used to load prebuilt module files.
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:825
std::string DOTOutputFile
The file to write GraphViz-formatted header dependencies to.
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:553
VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to c...
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
bool RemappedFilesKeepOriginalName
True if the SourceManager should report the original file name for contents of files that were remapp...
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
virtual void adjust(LangOptions &Opts)
Set forced language options.
Definition: TargetInfo.cpp:292
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
setCodeCompletionConsumer - Replace the current code completion consumer; the compiler instance takes...
Defines the clang::FileManager interface and associated types.
void EndSourceFile()
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
MemoryBufferCache & getPCMCache() const
Definition: Preprocessor.h:820
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation&#39;s diagnostic options and replace any existing one ...
submodule_iterator submodule_begin()
Definition: Module.h:556
static void writeTimestampFile(StringRef TimestampFile)
Write a new timestamp file with the given path.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
Format getFormat() const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:795
bool buildingModule() const
Returns true if this instance is building a module.
Definition: ModuleLoader.h:85
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:451
Defines the SourceManager interface.
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
FileManager & getFileManager() const
Definition: Preprocessor.h:818
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Abstract base class for actions which can be performed by the frontend.
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Definition: ModuleMap.cpp:1165
DiagnosticOptions & getDiagnosticOpts()
std::string HeaderIncludeOutputFile
The file to write header include output to.
std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const
const FileEntry * getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:466
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file...
void setAuxTarget(TargetInfo *Value)
Replace the current AuxTarget.
ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client a...
llvm::StringMap< Module * >::const_iterator module_iterator
Definition: ModuleMap.h:661
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::shared_ptr< FailedModulesSet > FailedModules
The set of modules that failed to build.
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:517
ASTContext & getASTContext() const
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
Definition: ASTReader.h:1500
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
The AST file has errors.
Definition: ASTReader.h:403
virtual void adjustTargetOptions(const CodeGenOptions &CGOpts, TargetOptions &TargetOpts) const
Adjust target options based on codegen options.
Definition: TargetInfo.h:849
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
llvm::SmallSetVector< llvm::CachedHashString, 16 > ModulesIgnoreMacros
The set of macro names that should be ignored for the purposes of computing the module hash...
Manage memory buffers across multiple users.
static PTHManager * Create(StringRef file, DiagnosticsEngine &Diags)
Create - This method creates PTHManager objects.
Definition: PTHLexer.cpp:450
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1487
DependencyOutputOptions & getDependencyOutputOpts()
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:647
std::string ModuleCachePath
The directory used for the module cache.
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:826
void setPredefines(const char *P)
Set the predefines for this Preprocessor.
static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, StringRef ModuleName, FrontendInputFile Input, StringRef OriginalModuleMapFile, StringRef ModuleFileName, llvm::function_ref< void(CompilerInstance &)> PreBuildStep=[](CompilerInstance &) {}, llvm::function_ref< void(CompilerInstance &)> PostBuildStep=[](CompilerInstance &) {})
Compile a module file for the given module, using the options provided by the importing compiler inst...
The client can handle an AST file that cannot load because it is missing.
Definition: ASTReader.h:1496
void setExternalSemaSource(IntrusiveRefCntPtr< ExternalSemaSource > ESS)
std::string FindPchSource
If non-empty, search the pch input file as if it was a header included by this file.
The virtual file system interface.
One of these records is kept for each identifier that is lexed.
void setMainFileID(FileID FID)
Set the file ID for the main source file.
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
Definition: Diagnostic.cpp:92
static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile)
void loadModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName, StringRef Source) override
Attempt to load the given module from the specified source buffer.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
static void collectHeaderMaps(const HeaderSearch &HS, std::shared_ptr< ModuleDependencyCollector > MDC)
unsigned getNumErrors() const
Definition: Diagnostic.h:1496
Definition: Format.h:2041
A source location that has been parsed on the command line.
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
CodeGenOptions & getCodeGenOpts()
The client can handle an AST file that cannot load because it&#39;s compiled configuration doesn&#39;t match ...
Definition: ASTReader.h:1509
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
Describes a module or submodule.
Definition: Module.h:65
Languages that the frontend can parse and compile.
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc) override
Make the given module visible.
bool SetCodeCompletionPoint(const FileEntry *File, unsigned Line, unsigned Column)
Specify the point at which code-completion will be performed.
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:461
bool isInvalid() const
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
Definition: ModuleMap.cpp:742
MemoryBufferCache & getPCMCache() const
std::error_code make_error_code(BuildPreambleError Error)
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:182
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:821
FrontendOptions & getFrontendOpts()
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:33
std::vector< std::string > VFSOverlayFiles
The set of user-provided virtual filesystem overlay files.
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
ASTConsumer & getASTConsumer() const
Defines the Diagnostic-related interfaces.
bool RetainRemappedFileBuffers
Whether the compiler instance should retain (i.e., not free) the buffers associated with remapped fil...
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value...
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Module.h:216
submodule_iterator submodule_end()
Definition: Module.h:558
InputKind getKind() const
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
unsigned DisableModuleHash
Whether we should disable the use of the hash string within the module cache.
HeaderSearchOptions & getHeaderSearchOpts()
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc)
Diagnose differences between the current definition of the given configuration macro and the definiti...
std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const
The AST file itself appears corrupted.
Definition: ASTReader.h:386
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
Builds a depdenency file when attached to a Preprocessor (for includes) and ASTReader (for module imp...
Definition: Utils.h:119
void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
Create an external AST source to read a PCH file and attach it to the AST context.
std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers
The set of file-to-buffer remappings, which take existing files on the system (the first part of each...
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:148
const FileEntry * getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
Definition: ModuleMap.cpp:1157
static ErrorCode writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, StringRef Path)
Write a global index into the given.
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Module.h:226
NodeId Parent
Definition: ASTDiff.cpp:192
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
static DependencyFileGenerator * CreateAndAttachToPreprocessor(Preprocessor &PP, const DependencyOutputOptions &Opts)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:274
static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags)
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:183
const DirectoryEntry * getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:285
void setVirtualFileSystem(IntrusiveRefCntPtr< vfs::FileSystem > FS)
Replace the current virtual file system.
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:36
std::string ShowIncludesPretendHeader
In /showIncludes mode, pretend the main TU is a header with this name.
StringRef Filename
Definition: Format.cpp:1549
bool isValid() const
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
Exposes information about the current target.
Definition: TargetInfo.h:54
void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)
A simple code-completion consumer that prints the results it receives in a simple format...
File is from a prebuilt module path.
Definition: Module.h:60
llvm::MemoryBuffer * getBuffer() const
unsigned ModuleCachePruneInterval
The interval (in seconds) between pruning operations.
std::string getSpecificModuleCachePath()
int Id
Definition: ASTDiff.cpp:191
const AnnotatedLine * Line
RAII object to temporarily add an AST callback listener.
Definition: ASTReader.h:1574
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, unsigned LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
StringRef getFile() const
Defines version macros and version-related utility functions for Clang.
void finalizeCurrentBuffers()
Finalize the current buffers in the cache.
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
Definition: Module.cpp:373
Defines the clang::Preprocessor interface.
IntrusiveRefCntPtr< vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
Definition: ASTReader.h:317
void createASTContext()
Create the AST context.
unsigned ShowHeaderIncludes
Show header inclusions (-H).
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
Definition: CharInfo.h:118
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M)
Check that the given module is available, producing a diagnostic if not.
HeaderSearchOptions & getHeaderSearchOpts() const
Retrieve the header-search options with which this header search was initialized. ...
Definition: HeaderSearch.h:271
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:985
void AttachHeaderIncludeGen(Preprocessor &PP, const DependencyOutputOptions &DepOpts, bool ShowAllHeaders=false, StringRef OutputPath={}, bool ShowDepth=true, bool MSStyle=false)
AttachHeaderIncludeGen - Create a header include list generator, and attach it to the given preproces...
FileManager * createFileManager()
Create the file manager and replace any existing one with it.
static InputKind::Language getLanguageFromOptions(const LangOptions &LangOpts)
Determine the appropriate source input kind based on language options.
module_iterator module_begin() const
Definition: ModuleMap.h:663
TargetInfo * getAuxTarget() const
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:596
An input file for the front end.
The result type of a method or function.
void addOutputFile(OutputFile &&OutFile)
addOutputFile - Add an output file onto the list of tracked output files.
static bool EnableCodeCompletion(Preprocessor &PP, StringRef Filename, unsigned Line, unsigned Column)
std::string AuxTriple
Auxiliary triple for CUDA compilation.
The client can&#39;t handle any AST loading failures.
Definition: ASTReader.h:1492
std::unique_ptr< raw_pwrite_stream > createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file and add it to the list of tracked output files, optionally deriving the outp...
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
The AST file was missing.
Definition: ASTReader.h:389
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
Check global module index for missing imports.
std::unique_ptr< Sema > takeSema()
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
SourceManager & getSourceManager() const
Definition: Preprocessor.h:819
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:96
void overrideFileContents(const FileEntry *SourceFile, llvm::MemoryBuffer *Buffer, bool DoNotFree)
Override the contents of the given source file by providing an already-allocated buffer.
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:94
FileSystemOptions & getFileSystemOpts()
The control block was read successfully.
Definition: ASTReader.h:383
Kind
void ApplyHeaderSearchOptions(HeaderSearch &HS, const HeaderSearchOptions &HSOpts, const LangOptions &Lang, const llvm::Triple &triple)
Apply the header search options to get given HeaderSearch object.
bool ExecuteAction(FrontendAction &Act)
ExecuteAction - Execute the provided action against the compiler&#39;s CompilerInvocation object...
File is a PCH file treated as the preamble.
Definition: Module.h:54
void AttachToASTReader(ASTReader &R)
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
bool Execute()
Set the source manager&#39;s main input file, and run the action.
StringRef getName() const
Definition: FileManager.h:84
File is a PCH file treated as such.
Definition: Module.h:51
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
bool isNamedPipe() const
Check whether the file is a named pipe (and thus can&#39;t be opened by the native FileManager methods)...
Definition: FileManager.h:100
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
void collectVFSFromYAML(std::unique_ptr< llvm::MemoryBuffer > Buffer, llvm::SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath, SmallVectorImpl< YAMLVFSEntry > &CollectedEntries, void *DiagContext=nullptr, IntrusiveRefCntPtr< FileSystem > ExternalFS=getRealFileSystem())
Collect all pairs of <virtual path, real path> entries from the YAMLFilePath.
unsigned getNumWarnings() const
Definition: Diagnostic.h:1497
Options for controlling the compiler diagnostics engine.
std::vector< FrontendInputFile > Inputs
The input files and their types.
virtual void finish()
Callback to inform the diagnostic client that processing of all source files has ended.
Definition: Diagnostic.h:1523
All of the names in this module are hidden.
Definition: Module.h:269
File is an implicitly-loaded module.
Definition: Module.h:45
unsigned ModulesValidateSystemHeaders
Whether to validate system input files when a module is loaded.
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, StringRef SysRoot)
AttachDependencyGraphGen - Create a dependency graph generator, and attach it to the given preprocess...
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
The kind of a file that we&#39;ve been handed as an input.
Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...
Definition: Diagnostic.h:1554
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
Definition: Warnings.cpp:44
bool hasVirtualFileSystem() const
std::unique_ptr< raw_pwrite_stream > createNullOutputFile()
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
void PrintStats() const
std::string ModuleName
The module currently being compiled as speficied by -fmodule-name.
Definition: LangOptions.h:176
const FileEntry * getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime)
Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...
const FileEntry * LookupFile(StringRef Filename, SourceLocation IncludeLoc, bool isAngled, const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, ArrayRef< std::pair< const FileEntry *, const DirectoryEntry *>> Includers, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool SkipCache=false, bool BuildSystemModule=false)
Given a "foo" or <foo> reference, look up the indicated file, return null on failure.
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
A global index for a set of module files, providing information about the identifiers within those mo...
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
module_iterator module_end() const
Definition: ModuleMap.h:664
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:400
std::string OutputFile
The file to write dependency output to.
Abstract interface for a consumer of code-completion information.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Options controlling the behavior of code completion.
void getHeaderMapFileNames(SmallVectorImpl< std::string > &Names) const
Get filenames for all registered header maps.
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
Definition: ASTReader.cpp:797
unsigned IsMissingRequirement
Whether this module is missing a feature from Requirements.
Definition: Module.h:204
void setPreprocessor(std::shared_ptr< Preprocessor > Value)
Replace the current preprocessor.
FileManager & getFileManager() const
Return the current file manager to the caller.
PreprocessorOptions & getPreprocessorOpts()
static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts)
off_t getSize() const
Definition: FileManager.h:87
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
File is an explicitly-loaded module.
Definition: Module.h:48
FileID getMainFileID() const
Returns the FileID of the main source file.
bool loadModuleFile(StringRef FileName)
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
vfs::FileSystem & getVirtualFileSystem() const
Used for handling and querying diagnostic IDs.
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1057
Helper class for holding the data necessary to invoke the compiler.
static void pruneModuleCache(const HeaderSearchOptions &HSOpts)
Prune the module cache of modules that haven&#39;t been accessed in a long time.
SourceManager & getSourceManager() const
Return the current source manager.
Language
The language for the input, used to select and validate the language standard and possible actions...
static void collectIncludePCH(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)
FrontendOptions - Options for controlling the behavior of the frontend.
Abstract interface for a module loader.
Definition: ModuleLoader.h:74
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
std::string StatsFile
Filename to write statistics to.
SourceLocation DefinitionLoc
The location of the module definition.
Definition: Module.h:71
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
void BuryPointer(const void *Ptr)
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:126
TargetInfo & getTarget() const
void setOverridenFilesKeepOriginalName(bool value)
Set true if the SourceManager should report the original file name for contents of files that were ov...
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation&#39;s options) and add it to the list of tracked outp...
void setTarget(TargetInfo *Value)
Replace the current Target.
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:45
unsigned DisableFree
Disable memory freeing on exit.
virtual void Initialize(ASTContext &Context)
Initialize - This is called to initialize the consumer, providing the ASTContext. ...
Definition: ASTConsumer.h:48
void setInvocation(std::shared_ptr< CompilerInvocation > Value)
setInvocation - Replace the current invocation.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
DiagnosticConsumer & getDiagnosticClient() const
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
Definition: Preprocessor.h:904
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:812
unsigned ModuleCachePruneAfter
The time (in seconds) after which an unused module file will be considered unused and will...
IntrusiveRefCntPtr< vfs::FileSystem > getVirtualFileSystem() const
Definition: FileManager.h:225
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts)
InitializePreprocessor - Initialize the preprocessor getting it and the environment ready to process ...
void setModuleBuildStack(ModuleBuildStack stack)
Set the module build stack.
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:298
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
Definition: ModuleMap.cpp:57
unsigned HasIncompatibleModuleFile
Whether we tried and failed to load a module file for this module.
Definition: Module.h:207
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
Defines the clang::TargetInfo interface.
The AST file is out-of-date relative to its input files, and needs to be regenerated.
Definition: ASTReader.h:393
A SourceLocation and its associated SourceManager.
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:267
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:344
__DEVICE__ int max(int __a, int __b)
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
The AST file was written by a different version of Clang.
Definition: ASTReader.h:396
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
static void collectVFSEntries(CompilerInstance &CI, std::shared_ptr< ModuleDependencyCollector > MDC)
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:818
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions)
Read the control block for the named AST file.
Definition: ASTReader.cpp:4706
GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Load, create, or return global module.
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
A trivial tuple used to represent a source range.
unsigned PrintShowIncludes
Print cl.exe style /showIncludes info.
std::map< std::string, std::string > PrebuiltModuleFiles
The mapping of module names to prebuilt module files.
TargetOptions & getTargetOpts()
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
This class handles loading and caching of source files into memory.
void setDiagnostics(DiagnosticsEngine *Value)
setDiagnostics - Replace the current diagnostics engine.
void noSignedCharForObjCBool()
Definition: TargetInfo.h:506
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
std::string DiagnosticLogFile
The file to log diagnostic output to.
std::string TokenCache
If given, a PTH cache file to use for speeding up header parsing.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
bool lookupIdentifier(StringRef Name, HitSet &Hits)
Look for all of the module files with information about the given identifier, e.g., a global function, variable, or type with that name.
bool ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
Definition: Diagnostic.h:513
StringRef getName() const
Definition: FileManager.h:51
virtual bool isModelParsingAction() const
Is this action invoked on a model file?