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