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  llvm::vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
182  for (llvm::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->path(), FileMgr, CI.getPCHContainerReader(),
189  /*FindModuleFileExtensions=*/false, Validator,
190  /*ValidateDiagnosticOptions=*/false))
191  MDC->addFile(Dir->path());
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  llvm::vfs::collectVFSFromYAML(std::move(Buffer.get()),
208  /*DiagHandler*/ nullptr, 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  if (!Act.PrepareToExecute(*this))
915  return false;
916 
917  // Create the target instance.
919  getInvocation().TargetOpts));
920  if (!hasTarget())
921  return false;
922 
923  // Create TargetInfo for the other side of CUDA and OpenMP compilation.
924  if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
925  !getFrontendOpts().AuxTriple.empty()) {
926  auto TO = std::make_shared<TargetOptions>();
927  TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
928  TO->HostTriple = getTarget().getTriple().str();
930  }
931 
932  // Inform the target of the language options.
933  //
934  // FIXME: We shouldn't need to do this, the target should be immutable once
935  // created. This complexity should be lifted elsewhere.
937 
938  // Adjust target options based on codegen options.
940 
941  // rewriter project will change target built-in bool type from its default.
942  if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
944 
945  // Validate/process some options.
946  if (getHeaderSearchOpts().Verbose)
947  OS << "clang -cc1 version " CLANG_VERSION_STRING
948  << " based upon " << BACKEND_PACKAGE_STRING
949  << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
950 
951  if (getFrontendOpts().ShowTimers)
953 
954  if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
955  llvm::EnableStatistics(false);
956 
957  for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
958  // Reset the ID tables if we are reusing the SourceManager and parsing
959  // regular files.
960  if (hasSourceManager() && !Act.isModelParsingAction())
962 
963  if (Act.BeginSourceFile(*this, FIF)) {
964  Act.Execute();
965  Act.EndSourceFile();
966  }
967  }
968 
969  // Notify the diagnostic client that all files were processed.
971 
972  if (getDiagnosticOpts().ShowCarets) {
973  // We can have multiple diagnostics sharing one diagnostic client.
974  // Get the total number of warnings/errors from the client.
975  unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
976  unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
977 
978  if (NumWarnings)
979  OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
980  if (NumWarnings && NumErrors)
981  OS << " and ";
982  if (NumErrors)
983  OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
984  if (NumWarnings || NumErrors) {
985  OS << " generated";
986  if (getLangOpts().CUDA) {
987  if (!getLangOpts().CUDAIsDevice) {
988  OS << " when compiling for host";
989  } else {
990  OS << " when compiling for " << getTargetOpts().CPU;
991  }
992  }
993  OS << ".\n";
994  }
995  }
996 
997  if (getFrontendOpts().ShowStats) {
998  if (hasFileManager()) {
1000  OS << '\n';
1001  }
1002  llvm::PrintStatistics(OS);
1003  }
1004  StringRef StatsFile = getFrontendOpts().StatsFile;
1005  if (!StatsFile.empty()) {
1006  std::error_code EC;
1007  auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
1008  llvm::sys::fs::F_Text);
1009  if (EC) {
1010  getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1011  << StatsFile << EC.message();
1012  } else {
1013  llvm::PrintStatisticsJSON(*StatS);
1014  }
1015  }
1016 
1017  return !getDiagnostics().getClient()->getNumErrors();
1018 }
1019 
1020 /// Determine the appropriate source input kind based on language
1021 /// options.
1023  if (LangOpts.OpenCL)
1024  return InputKind::OpenCL;
1025  if (LangOpts.CUDA)
1026  return InputKind::CUDA;
1027  if (LangOpts.ObjC1)
1028  return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1029  return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1030 }
1031 
1032 /// Compile a module file for the given module, using the options
1033 /// provided by the importing compiler instance. Returns true if the module
1034 /// was built without errors.
1035 static bool
1036 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1037  StringRef ModuleName, FrontendInputFile Input,
1038  StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1039  llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1040  [](CompilerInstance &) {},
1041  llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1042  [](CompilerInstance &) {}) {
1043  // Construct a compiler invocation for creating this module.
1044  auto Invocation =
1045  std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1046 
1047  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1048 
1049  // For any options that aren't intended to affect how a module is built,
1050  // reset them to their default values.
1051  Invocation->getLangOpts()->resetNonModularOptions();
1052  PPOpts.resetNonModularOptions();
1053 
1054  // Remove any macro definitions that are explicitly ignored by the module.
1055  // They aren't supposed to affect how the module is built anyway.
1056  HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1057  PPOpts.Macros.erase(
1058  std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1059  [&HSOpts](const std::pair<std::string, bool> &def) {
1060  StringRef MacroDef = def.first;
1061  return HSOpts.ModulesIgnoreMacros.count(
1062  llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1063  }),
1064  PPOpts.Macros.end());
1065 
1066  // If the original compiler invocation had -fmodule-name, pass it through.
1067  Invocation->getLangOpts()->ModuleName =
1068  ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1069 
1070  // Note the name of the module we're building.
1071  Invocation->getLangOpts()->CurrentModule = ModuleName;
1072 
1073  // Make sure that the failed-module structure has been allocated in
1074  // the importing instance, and propagate the pointer to the newly-created
1075  // instance.
1076  PreprocessorOptions &ImportingPPOpts
1077  = ImportingInstance.getInvocation().getPreprocessorOpts();
1078  if (!ImportingPPOpts.FailedModules)
1079  ImportingPPOpts.FailedModules =
1080  std::make_shared<PreprocessorOptions::FailedModulesSet>();
1081  PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1082 
1083  // If there is a module map file, build the module using the module map.
1084  // Set up the inputs/outputs so that we build the module from its umbrella
1085  // header.
1086  FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1087  FrontendOpts.OutputFile = ModuleFileName.str();
1088  FrontendOpts.DisableFree = false;
1089  FrontendOpts.GenerateGlobalModuleIndex = false;
1090  FrontendOpts.BuildingImplicitModule = true;
1091  FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1092  // Force implicitly-built modules to hash the content of the module file.
1093  HSOpts.ModulesHashContent = true;
1094  FrontendOpts.Inputs = {Input};
1095 
1096  // Don't free the remapped file buffers; they are owned by our caller.
1097  PPOpts.RetainRemappedFileBuffers = true;
1098 
1099  Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1100  assert(ImportingInstance.getInvocation().getModuleHash() ==
1101  Invocation->getModuleHash() && "Module hash mismatch!");
1102 
1103  // Construct a compiler instance that will be used to actually create the
1104  // module. Since we're sharing a PCMCache,
1105  // CompilerInstance::CompilerInstance is responsible for finalizing the
1106  // buffers to prevent use-after-frees.
1107  CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1108  &ImportingInstance.getPreprocessor().getPCMCache());
1109  auto &Inv = *Invocation;
1110  Instance.setInvocation(std::move(Invocation));
1111 
1112  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1113  ImportingInstance.getDiagnosticClient()),
1114  /*ShouldOwnClient=*/true);
1115 
1116  Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1117 
1118  // Note that this module is part of the module build stack, so that we
1119  // can detect cycles in the module graph.
1120  Instance.setFileManager(&ImportingInstance.getFileManager());
1121  Instance.createSourceManager(Instance.getFileManager());
1122  SourceManager &SourceMgr = Instance.getSourceManager();
1123  SourceMgr.setModuleBuildStack(
1124  ImportingInstance.getSourceManager().getModuleBuildStack());
1125  SourceMgr.pushModuleBuildStack(ModuleName,
1126  FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1127 
1128  // If we're collecting module dependencies, we need to share a collector
1129  // between all of the module CompilerInstances. Other than that, we don't
1130  // want to produce any dependency output from the module build.
1131  Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1132  Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1133 
1134  ImportingInstance.getDiagnostics().Report(ImportLoc,
1135  diag::remark_module_build)
1136  << ModuleName << ModuleFileName;
1137 
1138  PreBuildStep(Instance);
1139 
1140  // Execute the action to actually build the module in-place. Use a separate
1141  // thread so that we get a stack large enough.
1142  llvm::CrashRecoveryContext CRC;
1143  CRC.RunSafelyOnThread(
1144  [&]() {
1146  Instance.ExecuteAction(Action);
1147  },
1149 
1150  PostBuildStep(Instance);
1151 
1152  ImportingInstance.getDiagnostics().Report(ImportLoc,
1153  diag::remark_module_build_done)
1154  << ModuleName;
1155 
1156  // Delete the temporary module map file.
1157  // FIXME: Even though we're executing under crash protection, it would still
1158  // be nice to do this with RemoveFileOnSignal when we can. However, that
1159  // doesn't make sense for all clients, so clean this up manually.
1160  Instance.clearOutputFiles(/*EraseFiles=*/true);
1161 
1162  return !Instance.getDiagnostics().hasErrorOccurred();
1163 }
1164 
1165 static const FileEntry *getPublicModuleMap(const FileEntry *File,
1166  FileManager &FileMgr) {
1167  StringRef Filename = llvm::sys::path::filename(File->getName());
1168  SmallString<128> PublicFilename(File->getDir()->getName());
1169  if (Filename == "module_private.map")
1170  llvm::sys::path::append(PublicFilename, "module.map");
1171  else if (Filename == "module.private.modulemap")
1172  llvm::sys::path::append(PublicFilename, "module.modulemap");
1173  else
1174  return nullptr;
1175  return FileMgr.getFile(PublicFilename);
1176 }
1177 
1178 /// Compile a module file for the given module, using the options
1179 /// provided by the importing compiler instance. Returns true if the module
1180 /// was built without errors.
1181 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1182  SourceLocation ImportLoc,
1183  Module *Module,
1184  StringRef ModuleFileName) {
1185  InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1187 
1188  // Get or create the module map that we'll use to build this module.
1189  ModuleMap &ModMap
1190  = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1191  bool Result;
1192  if (const FileEntry *ModuleMapFile =
1193  ModMap.getContainingModuleMapFile(Module)) {
1194  // Canonicalize compilation to start with the public module map. This is
1195  // vital for submodules declarations in the private module maps to be
1196  // correctly parsed when depending on a top level module in the public one.
1197  if (const FileEntry *PublicMMFile = getPublicModuleMap(
1198  ModuleMapFile, ImportingInstance.getFileManager()))
1199  ModuleMapFile = PublicMMFile;
1200 
1201  // Use the module map where this module resides.
1202  Result = compileModuleImpl(
1203  ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1204  FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1205  ModMap.getModuleMapFileForUniquing(Module)->getName(),
1206  ModuleFileName);
1207  } else {
1208  // FIXME: We only need to fake up an input file here as a way of
1209  // transporting the module's directory to the module map parser. We should
1210  // be able to do that more directly, and parse from a memory buffer without
1211  // inventing this file.
1212  SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1213  llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1214 
1215  std::string InferredModuleMapContent;
1216  llvm::raw_string_ostream OS(InferredModuleMapContent);
1217  Module->print(OS);
1218  OS.flush();
1219 
1220  Result = compileModuleImpl(
1221  ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1222  FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1223  ModMap.getModuleMapFileForUniquing(Module)->getName(),
1224  ModuleFileName,
1225  [&](CompilerInstance &Instance) {
1226  std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1227  llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1228  ModuleMapFile = Instance.getFileManager().getVirtualFile(
1229  FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1230  Instance.getSourceManager().overrideFileContents(
1231  ModuleMapFile, std::move(ModuleMapBuffer));
1232  });
1233  }
1234 
1235  // We've rebuilt a module. If we're allowed to generate or update the global
1236  // module index, record that fact in the importing compiler instance.
1237  if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1238  ImportingInstance.setBuildGlobalModuleIndex(true);
1239  }
1240 
1241  return Result;
1242 }
1243 
1244 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1245  SourceLocation ImportLoc,
1246  SourceLocation ModuleNameLoc, Module *Module,
1247  StringRef ModuleFileName) {
1248  DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1249 
1250  auto diagnoseBuildFailure = [&] {
1251  Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1252  << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1253  };
1254 
1255  // FIXME: have LockFileManager return an error_code so that we can
1256  // avoid the mkdir when the directory already exists.
1257  StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1258  llvm::sys::fs::create_directories(Dir);
1259 
1260  while (1) {
1261  unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1262  llvm::LockFileManager Locked(ModuleFileName);
1263  switch (Locked) {
1264  case llvm::LockFileManager::LFS_Error:
1265  // PCMCache takes care of correctness and locks are only necessary for
1266  // performance. Fallback to building the module in case of any lock
1267  // related errors.
1268  Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1269  << Module->Name << Locked.getErrorMessage();
1270  // Clear out any potential leftover.
1271  Locked.unsafeRemoveLockFile();
1272  // FALLTHROUGH
1273  case llvm::LockFileManager::LFS_Owned:
1274  // We're responsible for building the module ourselves.
1275  if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1276  ModuleFileName)) {
1277  diagnoseBuildFailure();
1278  return false;
1279  }
1280  break;
1281 
1282  case llvm::LockFileManager::LFS_Shared:
1283  // Someone else is responsible for building the module. Wait for them to
1284  // finish.
1285  switch (Locked.waitForUnlock()) {
1286  case llvm::LockFileManager::Res_Success:
1287  ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1288  break;
1289  case llvm::LockFileManager::Res_OwnerDied:
1290  continue; // try again to get the lock.
1291  case llvm::LockFileManager::Res_Timeout:
1292  // Since PCMCache takes care of correctness, we try waiting for another
1293  // process to complete the build so clang does not do it done twice. If
1294  // case of timeout, build it ourselves.
1295  Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1296  << Module->Name;
1297  // Clear the lock file so that future invocations can make progress.
1298  Locked.unsafeRemoveLockFile();
1299  continue;
1300  }
1301  break;
1302  }
1303 
1304  // Try to read the module file, now that we've compiled it.
1305  ASTReader::ASTReadResult ReadResult =
1306  ImportingInstance.getModuleManager()->ReadAST(
1307  ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1308  ModuleLoadCapabilities);
1309 
1310  if (ReadResult == ASTReader::OutOfDate &&
1311  Locked == llvm::LockFileManager::LFS_Shared) {
1312  // The module may be out of date in the presence of file system races,
1313  // or if one of its imports depends on header search paths that are not
1314  // consistent with this ImportingInstance. Try again...
1315  continue;
1316  } else if (ReadResult == ASTReader::Missing) {
1317  diagnoseBuildFailure();
1318  } else if (ReadResult != ASTReader::Success &&
1319  !Diags.hasErrorOccurred()) {
1320  // The ASTReader didn't diagnose the error, so conservatively report it.
1321  diagnoseBuildFailure();
1322  }
1323  return ReadResult == ASTReader::Success;
1324  }
1325 }
1326 
1327 /// Diagnose differences between the current definition of the given
1328 /// configuration macro and the definition provided on the command line.
1329 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1330  Module *Mod, SourceLocation ImportLoc) {
1331  IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1332  SourceManager &SourceMgr = PP.getSourceManager();
1333 
1334  // If this identifier has never had a macro definition, then it could
1335  // not have changed.
1336  if (!Id->hadMacroDefinition())
1337  return;
1338  auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1339 
1340  // Find the macro definition from the command line.
1341  MacroInfo *CmdLineDefinition = nullptr;
1342  for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1343  // We only care about the predefines buffer.
1344  FileID FID = SourceMgr.getFileID(MD->getLocation());
1345  if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1346  continue;
1347  if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1348  CmdLineDefinition = DMD->getMacroInfo();
1349  break;
1350  }
1351 
1352  auto *CurrentDefinition = PP.getMacroInfo(Id);
1353  if (CurrentDefinition == CmdLineDefinition) {
1354  // Macro matches. Nothing to do.
1355  } else if (!CurrentDefinition) {
1356  // This macro was defined on the command line, then #undef'd later.
1357  // Complain.
1358  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1359  << true << ConfigMacro << Mod->getFullModuleName();
1360  auto LatestDef = LatestLocalMD->getDefinition();
1361  assert(LatestDef.isUndefined() &&
1362  "predefined macro went away with no #undef?");
1363  PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1364  << true;
1365  return;
1366  } else if (!CmdLineDefinition) {
1367  // There was no definition for this macro in the predefines buffer,
1368  // but there was a local definition. Complain.
1369  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1370  << false << ConfigMacro << Mod->getFullModuleName();
1371  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1372  diag::note_module_def_undef_here)
1373  << false;
1374  } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1375  /*Syntactically=*/true)) {
1376  // The macro definitions differ.
1377  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1378  << false << ConfigMacro << Mod->getFullModuleName();
1379  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1380  diag::note_module_def_undef_here)
1381  << false;
1382  }
1383 }
1384 
1385 /// Write a new timestamp file with the given path.
1386 static void writeTimestampFile(StringRef TimestampFile) {
1387  std::error_code EC;
1388  llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1389 }
1390 
1391 /// Prune the module cache of modules that haven't been accessed in
1392 /// a long time.
1393 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1394  struct stat StatBuf;
1395  llvm::SmallString<128> TimestampFile;
1396  TimestampFile = HSOpts.ModuleCachePath;
1397  assert(!TimestampFile.empty());
1398  llvm::sys::path::append(TimestampFile, "modules.timestamp");
1399 
1400  // Try to stat() the timestamp file.
1401  if (::stat(TimestampFile.c_str(), &StatBuf)) {
1402  // If the timestamp file wasn't there, create one now.
1403  if (errno == ENOENT) {
1404  writeTimestampFile(TimestampFile);
1405  }
1406  return;
1407  }
1408 
1409  // Check whether the time stamp is older than our pruning interval.
1410  // If not, do nothing.
1411  time_t TimeStampModTime = StatBuf.st_mtime;
1412  time_t CurrentTime = time(nullptr);
1413  if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1414  return;
1415 
1416  // Write a new timestamp file so that nobody else attempts to prune.
1417  // There is a benign race condition here, if two Clang instances happen to
1418  // notice at the same time that the timestamp is out-of-date.
1419  writeTimestampFile(TimestampFile);
1420 
1421  // Walk the entire module cache, looking for unused module files and module
1422  // indices.
1423  std::error_code EC;
1424  SmallString<128> ModuleCachePathNative;
1425  llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1426  for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1427  Dir != DirEnd && !EC; Dir.increment(EC)) {
1428  // If we don't have a directory, there's nothing to look into.
1429  if (!llvm::sys::fs::is_directory(Dir->path()))
1430  continue;
1431 
1432  // Walk all of the files within this directory.
1433  for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1434  File != FileEnd && !EC; File.increment(EC)) {
1435  // We only care about module and global module index files.
1436  StringRef Extension = llvm::sys::path::extension(File->path());
1437  if (Extension != ".pcm" && Extension != ".timestamp" &&
1438  llvm::sys::path::filename(File->path()) != "modules.idx")
1439  continue;
1440 
1441  // Look at this file. If we can't stat it, there's nothing interesting
1442  // there.
1443  if (::stat(File->path().c_str(), &StatBuf))
1444  continue;
1445 
1446  // If the file has been used recently enough, leave it there.
1447  time_t FileAccessTime = StatBuf.st_atime;
1448  if (CurrentTime - FileAccessTime <=
1449  time_t(HSOpts.ModuleCachePruneAfter)) {
1450  continue;
1451  }
1452 
1453  // Remove the file.
1454  llvm::sys::fs::remove(File->path());
1455 
1456  // Remove the timestamp file.
1457  std::string TimpestampFilename = File->path() + ".timestamp";
1458  llvm::sys::fs::remove(TimpestampFilename);
1459  }
1460 
1461  // If we removed all of the files in the directory, remove the directory
1462  // itself.
1463  if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1464  llvm::sys::fs::directory_iterator() && !EC)
1465  llvm::sys::fs::remove(Dir->path());
1466  }
1467 }
1468 
1470  if (!ModuleManager) {
1471  if (!hasASTContext())
1472  createASTContext();
1473 
1474  // If we're implicitly building modules but not currently recursively
1475  // building a module, check whether we need to prune the module cache.
1476  if (getSourceManager().getModuleBuildStack().empty() &&
1477  !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1478  getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1479  getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1481  }
1482 
1484  std::string Sysroot = HSOpts.Sysroot;
1485  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1486  std::unique_ptr<llvm::Timer> ReadTimer;
1487  if (FrontendTimerGroup)
1488  ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1489  "Reading modules",
1490  *FrontendTimerGroup);
1491  ModuleManager = new ASTReader(
1493  getFrontendOpts().ModuleFileExtensions,
1494  Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1495  /*AllowASTWithCompilerErrors=*/false,
1496  /*AllowConfigurationMismatch=*/false,
1499  std::move(ReadTimer));
1500  if (hasASTConsumer()) {
1501  ModuleManager->setDeserializationListener(
1502  getASTConsumer().GetASTDeserializationListener());
1504  getASTConsumer().GetASTMutationListener());
1505  }
1506  getASTContext().setExternalSource(ModuleManager);
1507  if (hasSema())
1508  ModuleManager->InitializeSema(getSema());
1509  if (hasASTConsumer())
1510  ModuleManager->StartTranslationUnit(&getASTConsumer());
1511 
1512  if (TheDependencyFileGenerator)
1513  TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1514  for (auto &Listener : DependencyCollectors)
1515  Listener->attachToASTReader(*ModuleManager);
1516  }
1517 }
1518 
1519 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1520  llvm::Timer Timer;
1521  if (FrontendTimerGroup)
1522  Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1523  *FrontendTimerGroup);
1524  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1525 
1526  // Helper to recursively read the module names for all modules we're adding.
1527  // We mark these as known and redirect any attempt to load that module to
1528  // the files we were handed.
1529  struct ReadModuleNames : ASTReaderListener {
1530  CompilerInstance &CI;
1532 
1533  ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1534 
1535  void ReadModuleName(StringRef ModuleName) override {
1536  LoadedModules.push_back(
1537  CI.getPreprocessor().getIdentifierInfo(ModuleName));
1538  }
1539 
1540  void registerAll() {
1541  for (auto *II : LoadedModules) {
1542  CI.KnownModules[II] = CI.getPreprocessor()
1544  .getModuleMap()
1545  .findModule(II->getName());
1546  }
1547  LoadedModules.clear();
1548  }
1549 
1550  void markAllUnavailable() {
1551  for (auto *II : LoadedModules) {
1552  if (Module *M = CI.getPreprocessor()
1554  .getModuleMap()
1555  .findModule(II->getName())) {
1556  M->HasIncompatibleModuleFile = true;
1557 
1558  // Mark module as available if the only reason it was unavailable
1559  // was missing headers.
1561  Stack.push_back(M);
1562  while (!Stack.empty()) {
1563  Module *Current = Stack.pop_back_val();
1564  if (Current->IsMissingRequirement) continue;
1565  Current->IsAvailable = true;
1566  Stack.insert(Stack.end(),
1567  Current->submodule_begin(), Current->submodule_end());
1568  }
1569  }
1570  }
1571  LoadedModules.clear();
1572  }
1573  };
1574 
1575  // If we don't already have an ASTReader, create one now.
1576  if (!ModuleManager)
1578 
1579  // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1580  // ASTReader to diagnose it, since it can produce better errors that we can.
1581  bool ConfigMismatchIsRecoverable =
1582  getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
1583  SourceLocation())
1585 
1586  auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1587  auto &ListenerRef = *Listener;
1588  ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1589  std::move(Listener));
1590 
1591  // Try to load the module file.
1592  switch (ModuleManager->ReadAST(
1594  ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) {
1595  case ASTReader::Success:
1596  // We successfully loaded the module file; remember the set of provided
1597  // modules so that we don't try to load implicit modules for them.
1598  ListenerRef.registerAll();
1599  return true;
1600 
1602  // Ignore unusable module files.
1603  getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1604  << FileName;
1605  // All modules provided by any files we tried and failed to load are now
1606  // unavailable; includes of those modules should now be handled textually.
1607  ListenerRef.markAllUnavailable();
1608  return true;
1609 
1610  default:
1611  return false;
1612  }
1613 }
1614 
1617  ModuleIdPath Path,
1619  bool IsInclusionDirective) {
1620  // Determine what file we're searching from.
1621  StringRef ModuleName = Path[0].first->getName();
1622  SourceLocation ModuleNameLoc = Path[0].second;
1623 
1624  // If we've already handled this import, just return the cached result.
1625  // This one-element cache is important to eliminate redundant diagnostics
1626  // when both the preprocessor and parser see the same import declaration.
1627  if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1628  // Make the named module visible.
1629  if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1630  ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1631  ImportLoc);
1632  return LastModuleImportResult;
1633  }
1634 
1635  clang::Module *Module = nullptr;
1636 
1637  // If we don't already have information on this module, load the module now.
1638  llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1639  = KnownModules.find(Path[0].first);
1640  if (Known != KnownModules.end()) {
1641  // Retrieve the cached top-level module.
1642  Module = Known->second;
1643  } else if (ModuleName == getLangOpts().CurrentModule) {
1644  // This is the module we're building.
1645  Module = PP->getHeaderSearchInfo().lookupModule(
1646  ModuleName, /*AllowSearch*/ true,
1647  /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
1648  /// FIXME: perhaps we should (a) look for a module using the module name
1649  // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1650  //if (Module == nullptr) {
1651  // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1652  // << ModuleName;
1653  // ModuleBuildFailed = true;
1654  // return ModuleLoadResult();
1655  //}
1656  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1657  } else {
1658  // Search for a module with the given name.
1659  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1660  !IsInclusionDirective);
1661  HeaderSearchOptions &HSOpts =
1662  PP->getHeaderSearchInfo().getHeaderSearchOpts();
1663 
1664  std::string ModuleFileName;
1665  enum ModuleSource {
1666  ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1667  } Source = ModuleNotFound;
1668 
1669  // Check to see if the module has been built as part of this compilation
1670  // via a module build pragma.
1671  auto BuiltModuleIt = BuiltModules.find(ModuleName);
1672  if (BuiltModuleIt != BuiltModules.end()) {
1673  ModuleFileName = BuiltModuleIt->second;
1674  Source = ModuleBuildPragma;
1675  }
1676 
1677  // Try to load the module from the prebuilt module path.
1678  if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1679  !HSOpts.PrebuiltModulePaths.empty())) {
1680  ModuleFileName =
1681  PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1682  if (!ModuleFileName.empty())
1683  Source = PrebuiltModulePath;
1684  }
1685 
1686  // Try to load the module from the module cache.
1687  if (Source == ModuleNotFound && Module) {
1688  ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1689  Source = ModuleCache;
1690  }
1691 
1692  if (Source == ModuleNotFound) {
1693  // We can't find a module, error out here.
1694  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1695  << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1696  ModuleBuildFailed = true;
1697  return ModuleLoadResult();
1698  }
1699 
1700  if (ModuleFileName.empty()) {
1701  if (Module && Module->HasIncompatibleModuleFile) {
1702  // We tried and failed to load a module file for this module. Fall
1703  // back to textual inclusion for its headers.
1705  }
1706 
1707  getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1708  << ModuleName;
1709  ModuleBuildFailed = true;
1710  return ModuleLoadResult();
1711  }
1712 
1713  // If we don't already have an ASTReader, create one now.
1714  if (!ModuleManager)
1716 
1717  llvm::Timer Timer;
1718  if (FrontendTimerGroup)
1719  Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1720  *FrontendTimerGroup);
1721  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1722 
1723  // Try to load the module file. If we are not trying to load from the
1724  // module cache, we don't know how to rebuild modules.
1725  unsigned ARRFlags = Source == ModuleCache ?
1728  switch (ModuleManager->ReadAST(ModuleFileName,
1729  Source == PrebuiltModulePath
1731  : Source == ModuleBuildPragma
1734  ImportLoc, ARRFlags)) {
1735  case ASTReader::Success: {
1736  if (Source != ModuleCache && !Module) {
1737  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1738  !IsInclusionDirective);
1739  if (!Module || !Module->getASTFile() ||
1740  FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1741  // Error out if Module does not refer to the file in the prebuilt
1742  // module path.
1743  getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1744  << ModuleName;
1745  ModuleBuildFailed = true;
1746  KnownModules[Path[0].first] = nullptr;
1747  return ModuleLoadResult();
1748  }
1749  }
1750  break;
1751  }
1752 
1753  case ASTReader::OutOfDate:
1754  case ASTReader::Missing: {
1755  if (Source != ModuleCache) {
1756  // We don't know the desired configuration for this module and don't
1757  // necessarily even have a module map. Since ReadAST already produces
1758  // diagnostics for these two cases, we simply error out here.
1759  ModuleBuildFailed = true;
1760  KnownModules[Path[0].first] = nullptr;
1761  return ModuleLoadResult();
1762  }
1763 
1764  // The module file is missing or out-of-date. Build it.
1765  assert(Module && "missing module file");
1766  // Check whether there is a cycle in the module graph.
1768  ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1769  for (; Pos != PosEnd; ++Pos) {
1770  if (Pos->first == ModuleName)
1771  break;
1772  }
1773 
1774  if (Pos != PosEnd) {
1775  SmallString<256> CyclePath;
1776  for (; Pos != PosEnd; ++Pos) {
1777  CyclePath += Pos->first;
1778  CyclePath += " -> ";
1779  }
1780  CyclePath += ModuleName;
1781 
1782  getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1783  << ModuleName << CyclePath;
1784  return ModuleLoadResult();
1785  }
1786 
1787  // Check whether we have already attempted to build this module (but
1788  // failed).
1789  if (getPreprocessorOpts().FailedModules &&
1790  getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1791  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1792  << ModuleName
1793  << SourceRange(ImportLoc, ModuleNameLoc);
1794  ModuleBuildFailed = true;
1795  return ModuleLoadResult();
1796  }
1797 
1798  // Try to compile and then load the module.
1799  if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1800  ModuleFileName)) {
1801  assert(getDiagnostics().hasErrorOccurred() &&
1802  "undiagnosed error in compileAndLoadModule");
1803  if (getPreprocessorOpts().FailedModules)
1804  getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1805  KnownModules[Path[0].first] = nullptr;
1806  ModuleBuildFailed = true;
1807  return ModuleLoadResult();
1808  }
1809 
1810  // Okay, we've rebuilt and now loaded the module.
1811  break;
1812  }
1813 
1815  if (Source == PrebuiltModulePath)
1816  // FIXME: We shouldn't be setting HadFatalFailure below if we only
1817  // produce a warning here!
1819  diag::warn_module_config_mismatch)
1820  << ModuleFileName;
1821  // Fall through to error out.
1822  LLVM_FALLTHROUGH;
1824  case ASTReader::HadErrors:
1826  // FIXME: The ASTReader will already have complained, but can we shoehorn
1827  // that diagnostic information into a more useful form?
1828  KnownModules[Path[0].first] = nullptr;
1829  return ModuleLoadResult();
1830 
1831  case ASTReader::Failure:
1833  // Already complained, but note now that we failed.
1834  KnownModules[Path[0].first] = nullptr;
1835  ModuleBuildFailed = true;
1836  return ModuleLoadResult();
1837  }
1838 
1839  // Cache the result of this top-level module lookup for later.
1840  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1841  }
1842 
1843  // If we never found the module, fail.
1844  if (!Module)
1845  return ModuleLoadResult();
1846 
1847  // Verify that the rest of the module path actually corresponds to
1848  // a submodule.
1849  bool MapPrivateSubModToTopLevel = false;
1850  if (Path.size() > 1) {
1851  for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1852  StringRef Name = Path[I].first->getName();
1853  clang::Module *Sub = Module->findSubmodule(Name);
1854 
1855  // If the user is requesting Foo.Private and it doesn't exist, try to
1856  // match Foo_Private and emit a warning asking for the user to write
1857  // @import Foo_Private instead. FIXME: remove this when existing clients
1858  // migrate off of Foo.Private syntax.
1859  if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1860  Module == Module->getTopLevelModule()) {
1861  SmallString<128> PrivateModule(Module->Name);
1862  PrivateModule.append("_Private");
1863 
1865  auto &II = PP->getIdentifierTable().get(
1866  PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1867  PrivPath.push_back(std::make_pair(&II, Path[0].second));
1868 
1869  if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, true,
1870  !IsInclusionDirective))
1871  Sub =
1872  loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1873  if (Sub) {
1874  MapPrivateSubModToTopLevel = true;
1875  if (!getDiagnostics().isIgnored(
1876  diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1877  getDiagnostics().Report(Path[I].second,
1878  diag::warn_no_priv_submodule_use_toplevel)
1879  << Path[I].first << Module->getFullModuleName() << PrivateModule
1880  << SourceRange(Path[0].second, Path[I].second)
1881  << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1882  PrivateModule);
1884  diag::note_private_top_level_defined);
1885  }
1886  }
1887  }
1888 
1889  if (!Sub) {
1890  // Attempt to perform typo correction to find a module name that works.
1892  unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1893 
1895  JEnd = Module->submodule_end();
1896  J != JEnd; ++J) {
1897  unsigned ED = Name.edit_distance((*J)->Name,
1898  /*AllowReplacements=*/true,
1899  BestEditDistance);
1900  if (ED <= BestEditDistance) {
1901  if (ED < BestEditDistance) {
1902  Best.clear();
1903  BestEditDistance = ED;
1904  }
1905 
1906  Best.push_back((*J)->Name);
1907  }
1908  }
1909 
1910  // If there was a clear winner, user it.
1911  if (Best.size() == 1) {
1912  getDiagnostics().Report(Path[I].second,
1913  diag::err_no_submodule_suggest)
1914  << Path[I].first << Module->getFullModuleName() << Best[0]
1915  << SourceRange(Path[0].second, Path[I-1].second)
1916  << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1917  Best[0]);
1918 
1919  Sub = Module->findSubmodule(Best[0]);
1920  }
1921  }
1922 
1923  if (!Sub) {
1924  // No submodule by this name. Complain, and don't look for further
1925  // submodules.
1926  getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1927  << Path[I].first << Module->getFullModuleName()
1928  << SourceRange(Path[0].second, Path[I-1].second);
1929  break;
1930  }
1931 
1932  Module = Sub;
1933  }
1934  }
1935 
1936  // Make the named module visible, if it's not already part of the module
1937  // we are parsing.
1938  if (ModuleName != getLangOpts().CurrentModule) {
1939  if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1940  // We have an umbrella header or directory that doesn't actually include
1941  // all of the headers within the directory it covers. Complain about
1942  // this missing submodule and recover by forgetting that we ever saw
1943  // this submodule.
1944  // FIXME: Should we detect this at module load time? It seems fairly
1945  // expensive (and rare).
1946  getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1947  << Module->getFullModuleName()
1948  << SourceRange(Path.front().second, Path.back().second);
1949 
1951  }
1952 
1953  // Check whether this module is available.
1955  getDiagnostics(), Module)) {
1956  getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1957  << SourceRange(Path.front().second, Path.back().second);
1958  LastModuleImportLoc = ImportLoc;
1959  LastModuleImportResult = ModuleLoadResult();
1960  return ModuleLoadResult();
1961  }
1962 
1963  ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1964  }
1965 
1966  // Check for any configuration macros that have changed.
1967  clang::Module *TopModule = Module->getTopLevelModule();
1968  for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1970  Module, ImportLoc);
1971  }
1972 
1973  // Resolve any remaining module using export_as for this one.
1974  getPreprocessor()
1976  .getModuleMap()
1977  .resolveLinkAsDependencies(TopModule);
1978 
1979  LastModuleImportLoc = ImportLoc;
1980  LastModuleImportResult = ModuleLoadResult(Module);
1981  return LastModuleImportResult;
1982 }
1983 
1985  StringRef ModuleName,
1986  StringRef Source) {
1987  // Avoid creating filenames with special characters.
1988  SmallString<128> CleanModuleName(ModuleName);
1989  for (auto &C : CleanModuleName)
1990  if (!isAlphanumeric(C))
1991  C = '_';
1992 
1993  // FIXME: Using a randomized filename here means that our intermediate .pcm
1994  // output is nondeterministic (as .pcm files refer to each other by name).
1995  // Can this affect the output in any way?
1996  SmallString<128> ModuleFileName;
1997  if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
1998  CleanModuleName, "pcm", ModuleFileName)) {
1999  getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
2000  << ModuleFileName << EC.message();
2001  return;
2002  }
2003  std::string ModuleMapFileName = (CleanModuleName + ".map").str();
2004 
2005  FrontendInputFile Input(
2006  ModuleMapFileName,
2007  InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2008  InputKind::ModuleMap, /*Preprocessed*/true));
2009 
2010  std::string NullTerminatedSource(Source.str());
2011 
2012  auto PreBuildStep = [&](CompilerInstance &Other) {
2013  // Create a virtual file containing our desired source.
2014  // FIXME: We shouldn't need to do this.
2015  const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2016  ModuleMapFileName, NullTerminatedSource.size(), 0);
2017  Other.getSourceManager().overrideFileContents(
2018  ModuleMapFile,
2019  llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2020 
2021  Other.BuiltModules = std::move(BuiltModules);
2022  Other.DeleteBuiltModules = false;
2023  };
2024 
2025  auto PostBuildStep = [this](CompilerInstance &Other) {
2026  BuiltModules = std::move(Other.BuiltModules);
2027  };
2028 
2029  // Build the module, inheriting any modules that we've built locally.
2030  if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2031  ModuleFileName, PreBuildStep, PostBuildStep)) {
2032  BuiltModules[ModuleName] = ModuleFileName.str();
2033  llvm::sys::RemoveFileOnSignal(ModuleFileName);
2034  }
2035 }
2036 
2039  SourceLocation ImportLoc) {
2040  if (!ModuleManager)
2042  if (!ModuleManager)
2043  return;
2044 
2045  ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2046 }
2047 
2049  SourceLocation TriggerLoc) {
2050  if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2051  return nullptr;
2052  if (!ModuleManager)
2054  // Can't do anything if we don't have the module manager.
2055  if (!ModuleManager)
2056  return nullptr;
2057  // Get an existing global index. This loads it if not already
2058  // loaded.
2059  ModuleManager->loadGlobalIndex();
2060  GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2061  // If the global index doesn't exist, create it.
2062  if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2063  hasPreprocessor()) {
2064  llvm::sys::fs::create_directories(
2065  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2068  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2069  ModuleManager->resetForReload();
2070  ModuleManager->loadGlobalIndex();
2071  GlobalIndex = ModuleManager->getGlobalIndex();
2072  }
2073  // For finding modules needing to be imported for fixit messages,
2074  // we need to make the global index cover all modules, so we do that here.
2075  if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2077  bool RecreateIndex = false;
2078  for (ModuleMap::module_iterator I = MMap.module_begin(),
2079  E = MMap.module_end(); I != E; ++I) {
2080  Module *TheModule = I->second;
2081  const FileEntry *Entry = TheModule->getASTFile();
2082  if (!Entry) {
2084  Path.push_back(std::make_pair(
2085  getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2086  std::reverse(Path.begin(), Path.end());
2087  // Load a module as hidden. This also adds it to the global index.
2088  loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2089  RecreateIndex = true;
2090  }
2091  }
2092  if (RecreateIndex) {
2095  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2096  ModuleManager->resetForReload();
2097  ModuleManager->loadGlobalIndex();
2098  GlobalIndex = ModuleManager->getGlobalIndex();
2099  }
2100  HaveFullGlobalModuleIndex = true;
2101  }
2102  return GlobalIndex;
2103 }
2104 
2105 // Check global module index for missing imports.
2106 bool
2108  SourceLocation TriggerLoc) {
2109  // Look for the symbol in non-imported modules, but only if an error
2110  // actually occurred.
2111  if (!buildingModule()) {
2112  // Load global module index, or retrieve a previously loaded one.
2114  TriggerLoc);
2115 
2116  // Only if we have a global index.
2117  if (GlobalIndex) {
2118  GlobalModuleIndex::HitSet FoundModules;
2119 
2120  // Find the modules that reference the identifier.
2121  // Note that this only finds top-level modules.
2122  // We'll let diagnoseTypo find the actual declaration module.
2123  if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2124  return true;
2125  }
2126  }
2127 
2128  return false;
2129 }
2131 
2134  ExternalSemaSrc = std::move(ESS);
2135 }
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:381
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:837
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:117
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:832
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:830
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:1212
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:678
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:1516
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
The AST file has errors.
Definition: ASTReader.h:404
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:655
std::string ModuleCachePath
The directory used for the module cache.
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:838
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:1512
void setExternalSemaSource(IntrusiveRefCntPtr< ExternalSemaSource > ESS)
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:154
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:2075
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:1525
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)
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:214
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:833
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:387
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
llvm::vfs::FileSystem & getVirtualFileSystem() const
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:1204
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)
return Out str()
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
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:194
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:317
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:36
StringRef Filename
Definition: Format.cpp:1620
bool isValid() const
bool lookupIdentifier(llvm::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.
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:1590
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:405
Defines the clang::Preprocessor interface.
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
Definition: ASTReader.h:318
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:269
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:997
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:680
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:1508
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:390
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:831
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:95
FileSystemOptions & getFileSystemOpts()
The control block was read successfully.
Definition: ASTReader.h:384
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:85
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:101
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
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:835
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:60
void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, StringRef SysRoot)
AttachDependencyGraphGen - Create a dependency graph generator, and attach it to the given preprocess...
bool PrepareToExecute(CompilerInstance &CI)
Prepare the action to execute on the given compiler instance.
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:187
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:681
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:401
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:88
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:355
File is an explicitly-loaded module.
Definition: Module.h:48
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
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.
Used for handling and querying diagnostic IDs.
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1098
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:127
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.
void setVirtualFileSystem(IntrusiveRefCntPtr< llvm::vfs::FileSystem > FS)
Replace the current virtual file system.
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:46
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
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
Definition: Preprocessor.h:916
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:824
unsigned ModuleCachePruneAfter
The time (in seconds) after which an unused module file will be considered unused and will...
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:329
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:394
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:397
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:4718
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.
static ErrorCode writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)
Write a global index into the given.
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...
IntrusiveRefCntPtr< llvm::vfs::FileSystem > getVirtualFileSystem() const
Definition: FileManager.h:226
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 ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
Definition: Diagnostic.h:513
StringRef getName() const
Definition: FileManager.h:52
virtual bool isModelParsingAction() const
Is this action invoked on a model file?