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/Preprocessor.h"
36 #include "clang/Sema/Sema.h"
39 #include "llvm/ADT/Statistic.h"
40 #include "llvm/Support/BuryPointer.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  // The module manager holds a reference to the old preprocessor (if any).
376  ModuleManager.reset();
377 
378  // Create the Preprocessor.
379  HeaderSearch *HeaderInfo =
382  PP = std::make_shared<Preprocessor>(
383  Invocation->getPreprocessorOptsPtr(), getDiagnostics(), getLangOpts(),
384  getSourceManager(), getPCMCache(), *HeaderInfo, *this,
385  /*IdentifierInfoLookup=*/nullptr,
386  /*OwnsHeaderSearch=*/true, TUKind);
388  PP->Initialize(getTarget(), getAuxTarget());
389 
390  if (PPOpts.DetailedRecord)
391  PP->createPreprocessingRecord();
392 
393  // Apply remappings to the source manager.
394  InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
395  PP->getFileManager(), PPOpts);
396 
397  // Predefine macros and configure the preprocessor.
399  getFrontendOpts());
400 
401  // Initialize the header search object. In CUDA compilations, we use the aux
402  // triple (the host triple) to initialize our header search, since we need to
403  // find the host headers in order to compile the CUDA code.
404  const llvm::Triple *HeaderSearchTriple = &PP->getTargetInfo().getTriple();
405  if (PP->getTargetInfo().getTriple().getOS() == llvm::Triple::CUDA &&
406  PP->getAuxTargetInfo())
407  HeaderSearchTriple = &PP->getAuxTargetInfo()->getTriple();
408 
409  ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
410  PP->getLangOpts(), *HeaderSearchTriple);
411 
412  PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
413 
414  if (PP->getLangOpts().Modules && PP->getLangOpts().ImplicitModules)
415  PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
416 
417  // Handle generating dependencies, if requested.
419  if (!DepOpts.OutputFile.empty())
420  TheDependencyFileGenerator.reset(
422  if (!DepOpts.DOTOutputFile.empty())
425 
426  // If we don't have a collector, but we are collecting module dependencies,
427  // then we're the top level compiler instance and need to create one.
428  if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty()) {
429  ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
430  DepOpts.ModuleDependencyOutputDir);
431  }
432 
433  // If there is a module dep collector, register with other dep collectors
434  // and also (a) collect header maps and (b) TODO: input vfs overlay files.
435  if (ModuleDepCollector) {
436  addDependencyCollector(ModuleDepCollector);
437  collectHeaderMaps(PP->getHeaderSearchInfo(), ModuleDepCollector);
438  collectIncludePCH(*this, ModuleDepCollector);
439  collectVFSEntries(*this, ModuleDepCollector);
440  }
441 
442  for (auto &Listener : DependencyCollectors)
443  Listener->attachToPreprocessor(*PP);
444 
445  // Handle generating header include information, if requested.
446  if (DepOpts.ShowHeaderIncludes)
447  AttachHeaderIncludeGen(*PP, DepOpts);
448  if (!DepOpts.HeaderIncludeOutputFile.empty()) {
449  StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
450  if (OutputPath == "-")
451  OutputPath = "";
452  AttachHeaderIncludeGen(*PP, DepOpts,
453  /*ShowAllHeaders=*/true, OutputPath,
454  /*ShowDepth=*/false);
455  }
456 
458  AttachHeaderIncludeGen(*PP, DepOpts,
459  /*ShowAllHeaders=*/true, /*OutputPath=*/"",
460  /*ShowDepth=*/true, /*MSStyle=*/true);
461  }
462 }
463 
465  // Set up the module path, including the hash for the
466  // module-creation options.
467  SmallString<256> SpecificModuleCache(getHeaderSearchOpts().ModuleCachePath);
468  if (!SpecificModuleCache.empty() && !getHeaderSearchOpts().DisableModuleHash)
469  llvm::sys::path::append(SpecificModuleCache,
471  return SpecificModuleCache.str();
472 }
473 
474 // ASTContext
475 
478  auto *Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
480  PP.getBuiltinInfo());
481  Context->InitBuiltinTypes(getTarget(), getAuxTarget());
482  setASTContext(Context);
483 }
484 
485 // ExternalASTSource
486 
488  StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
489  void *DeserializationListener, bool OwnDeserializationListener) {
491  ModuleManager = createPCHExternalASTSource(
492  Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
493  AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
495  getFrontendOpts().ModuleFileExtensions,
496  TheDependencyFileGenerator.get(),
497  DependencyCollectors,
498  DeserializationListener,
499  OwnDeserializationListener, Preamble,
501 }
502 
504  StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
505  bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
506  const PCHContainerReader &PCHContainerRdr,
507  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
508  DependencyFileGenerator *DependencyFile,
509  ArrayRef<std::shared_ptr<DependencyCollector>> DependencyCollectors,
510  void *DeserializationListener, bool OwnDeserializationListener,
511  bool Preamble, bool UseGlobalModuleIndex) {
513 
515  PP, &Context, PCHContainerRdr, Extensions,
516  Sysroot.empty() ? "" : Sysroot.data(), DisablePCHValidation,
517  AllowPCHWithCompilerErrors, /*AllowConfigurationMismatch*/ false,
518  HSOpts.ModulesValidateSystemHeaders, UseGlobalModuleIndex));
519 
520  // We need the external source to be set up before we read the AST, because
521  // eagerly-deserialized declarations may use it.
522  Context.setExternalSource(Reader.get());
523 
524  Reader->setDeserializationListener(
525  static_cast<ASTDeserializationListener *>(DeserializationListener),
526  /*TakeOwnership=*/OwnDeserializationListener);
527 
528  if (DependencyFile)
529  DependencyFile->AttachToASTReader(*Reader);
530  for (auto &Listener : DependencyCollectors)
531  Listener->attachToASTReader(*Reader);
532 
533  switch (Reader->ReadAST(Path,
534  Preamble ? serialization::MK_Preamble
536  SourceLocation(),
538  case ASTReader::Success:
539  // Set the predefines buffer as suggested by the PCH reader. Typically, the
540  // predefines buffer will be empty.
541  PP.setPredefines(Reader->getSuggestedPredefines());
542  return Reader;
543 
544  case ASTReader::Failure:
545  // Unrecoverable failure: don't even try to process the input file.
546  break;
547 
548  case ASTReader::Missing:
553  // No suitable PCH file could be found. Return an error.
554  break;
555  }
556 
557  Context.setExternalSource(nullptr);
558  return nullptr;
559 }
560 
561 // Code Completion
562 
564  StringRef Filename,
565  unsigned Line,
566  unsigned Column) {
567  // Tell the source manager to chop off the given file at a specific
568  // line and column.
569  const FileEntry *Entry = PP.getFileManager().getFile(Filename);
570  if (!Entry) {
571  PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
572  << Filename;
573  return true;
574  }
575 
576  // Truncate the named file at the given line/column.
577  PP.SetCodeCompletionPoint(Entry, Line, Column);
578  return false;
579 }
580 
583  if (!CompletionConsumer) {
586  Loc.FileName, Loc.Line, Loc.Column,
587  getFrontendOpts().CodeCompleteOpts,
588  llvm::outs()));
589  if (!CompletionConsumer)
590  return;
592  Loc.Line, Loc.Column)) {
593  setCodeCompletionConsumer(nullptr);
594  return;
595  }
596 
597  if (CompletionConsumer->isOutputBinary() &&
598  llvm::sys::ChangeStdoutToBinary()) {
599  getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
600  setCodeCompletionConsumer(nullptr);
601  }
602 }
603 
605  FrontendTimerGroup.reset(
606  new llvm::TimerGroup("frontend", "Clang front-end time report"));
607  FrontendTimer.reset(
608  new llvm::Timer("frontend", "Clang front-end timer",
609  *FrontendTimerGroup));
610 }
611 
614  StringRef Filename,
615  unsigned Line,
616  unsigned Column,
617  const CodeCompleteOptions &Opts,
618  raw_ostream &OS) {
619  if (EnableCodeCompletion(PP, Filename, Line, Column))
620  return nullptr;
621 
622  // Set up the creation routine for code-completion.
623  return new PrintingCodeCompleteConsumer(Opts, OS);
624 }
625 
627  CodeCompleteConsumer *CompletionConsumer) {
628  TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
629  TUKind, CompletionConsumer));
630  // Attach the external sema source if there is any.
631  if (ExternalSemaSrc) {
632  TheSema->addExternalSource(ExternalSemaSrc.get());
633  ExternalSemaSrc->InitializeSema(*TheSema);
634  }
635 }
636 
637 // Output Files
638 
639 void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
640  OutputFiles.push_back(std::move(OutFile));
641 }
642 
643 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
644  for (OutputFile &OF : OutputFiles) {
645  if (!OF.TempFilename.empty()) {
646  if (EraseFiles) {
647  llvm::sys::fs::remove(OF.TempFilename);
648  } else {
649  SmallString<128> NewOutFile(OF.Filename);
650 
651  // If '-working-directory' was passed, the output filename should be
652  // relative to that.
653  FileMgr->FixupRelativePath(NewOutFile);
654  if (std::error_code ec =
655  llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
656  getDiagnostics().Report(diag::err_unable_to_rename_temp)
657  << OF.TempFilename << OF.Filename << ec.message();
658 
659  llvm::sys::fs::remove(OF.TempFilename);
660  }
661  }
662  } else if (!OF.Filename.empty() && EraseFiles)
663  llvm::sys::fs::remove(OF.Filename);
664  }
665  OutputFiles.clear();
666  if (DeleteBuiltModules) {
667  for (auto &Module : BuiltModules)
668  llvm::sys::fs::remove(Module.second);
669  BuiltModules.clear();
670  }
671  NonSeekStream.reset();
672 }
673 
674 std::unique_ptr<raw_pwrite_stream>
675 CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
676  StringRef Extension) {
677  return createOutputFile(getFrontendOpts().OutputFile, Binary,
678  /*RemoveFileOnSignal=*/true, InFile, Extension,
679  /*UseTemporary=*/true);
680 }
681 
682 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
683  return llvm::make_unique<llvm::raw_null_ostream>();
684 }
685 
686 std::unique_ptr<raw_pwrite_stream>
687 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
688  bool RemoveFileOnSignal, StringRef InFile,
689  StringRef Extension, bool UseTemporary,
690  bool CreateMissingDirectories) {
691  std::string OutputPathName, TempPathName;
692  std::error_code EC;
693  std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
694  OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
695  UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
696  if (!OS) {
697  getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
698  << EC.message();
699  return nullptr;
700  }
701 
702  // Add the output file -- but don't try to remove "-", since this means we are
703  // using stdin.
705  OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
706 
707  return OS;
708 }
709 
710 std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
711  StringRef OutputPath, std::error_code &Error, bool Binary,
712  bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
713  bool UseTemporary, bool CreateMissingDirectories,
714  std::string *ResultPathName, std::string *TempPathName) {
715  assert((!CreateMissingDirectories || UseTemporary) &&
716  "CreateMissingDirectories is only allowed when using temporary files");
717 
718  std::string OutFile, TempFile;
719  if (!OutputPath.empty()) {
720  OutFile = OutputPath;
721  } else if (InFile == "-") {
722  OutFile = "-";
723  } else if (!Extension.empty()) {
724  SmallString<128> Path(InFile);
725  llvm::sys::path::replace_extension(Path, Extension);
726  OutFile = Path.str();
727  } else {
728  OutFile = "-";
729  }
730 
731  std::unique_ptr<llvm::raw_fd_ostream> OS;
732  std::string OSFile;
733 
734  if (UseTemporary) {
735  if (OutFile == "-")
736  UseTemporary = false;
737  else {
738  llvm::sys::fs::file_status Status;
739  llvm::sys::fs::status(OutputPath, Status);
740  if (llvm::sys::fs::exists(Status)) {
741  // Fail early if we can't write to the final destination.
742  if (!llvm::sys::fs::can_write(OutputPath)) {
743  Error = make_error_code(llvm::errc::operation_not_permitted);
744  return nullptr;
745  }
746 
747  // Don't use a temporary if the output is a special file. This handles
748  // things like '-o /dev/null'
749  if (!llvm::sys::fs::is_regular_file(Status))
750  UseTemporary = false;
751  }
752  }
753  }
754 
755  if (UseTemporary) {
756  // Create a temporary file.
757  // Insert -%%%%%%%% before the extension (if any), and because some tools
758  // (noticeable, clang's own GlobalModuleIndex.cpp) glob for build
759  // artifacts, also append .tmp.
760  StringRef OutputExtension = llvm::sys::path::extension(OutFile);
761  SmallString<128> TempPath =
762  StringRef(OutFile).drop_back(OutputExtension.size());
763  TempPath += "-%%%%%%%%";
764  TempPath += OutputExtension;
765  TempPath += ".tmp";
766  int fd;
767  std::error_code EC =
768  llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
769 
770  if (CreateMissingDirectories &&
771  EC == llvm::errc::no_such_file_or_directory) {
772  StringRef Parent = llvm::sys::path::parent_path(OutputPath);
773  EC = llvm::sys::fs::create_directories(Parent);
774  if (!EC) {
775  EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
776  }
777  }
778 
779  if (!EC) {
780  OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
781  OSFile = TempFile = TempPath.str();
782  }
783  // If we failed to create the temporary, fallback to writing to the file
784  // directly. This handles the corner case where we cannot write to the
785  // directory, but can write to the file.
786  }
787 
788  if (!OS) {
789  OSFile = OutFile;
790  OS.reset(new llvm::raw_fd_ostream(
791  OSFile, Error,
792  (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
793  if (Error)
794  return nullptr;
795  }
796 
797  // Make sure the out stream file gets removed if we crash.
798  if (RemoveFileOnSignal)
799  llvm::sys::RemoveFileOnSignal(OSFile);
800 
801  if (ResultPathName)
802  *ResultPathName = OutFile;
803  if (TempPathName)
804  *TempPathName = TempFile;
805 
806  if (!Binary || OS->supportsSeeking())
807  return std::move(OS);
808 
809  auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
810  assert(!NonSeekStream);
811  NonSeekStream = std::move(OS);
812  return std::move(B);
813 }
814 
815 // Initialization Utilities
816 
820  hasPreprocessor() ? &getPreprocessor().getHeaderSearchInfo() : nullptr,
822 }
823 
824 // static
826  const FrontendInputFile &Input, DiagnosticsEngine &Diags,
827  FileManager &FileMgr, SourceManager &SourceMgr, HeaderSearch *HS,
828  DependencyOutputOptions &DepOpts, const FrontendOptions &Opts) {
834 
835  if (Input.isBuffer()) {
837  Input.getBuffer(), Kind));
838  assert(SourceMgr.getMainFileID().isValid() &&
839  "Couldn't establish MainFileID!");
840  return true;
841  }
842 
843  StringRef InputFile = Input.getFile();
844 
845  // Figure out where to get and map in the main file.
846  if (InputFile != "-") {
847  const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
848  if (!File) {
849  Diags.Report(diag::err_fe_error_reading) << InputFile;
850  return false;
851  }
852 
853  // The natural SourceManager infrastructure can't currently handle named
854  // pipes, but we would at least like to accept them for the main
855  // file. Detect them here, read them with the volatile flag so FileMgr will
856  // pick up the correct size, and simply override their contents as we do for
857  // STDIN.
858  if (File->isNamedPipe()) {
859  auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
860  if (MB) {
861  // Create a new virtual file that will have the correct size.
862  File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
863  SourceMgr.overrideFileContents(File, std::move(*MB));
864  } else {
865  Diags.Report(diag::err_cannot_open_file) << InputFile
866  << MB.getError().message();
867  return false;
868  }
869  }
870 
871  SourceMgr.setMainFileID(
872  SourceMgr.createFileID(File, SourceLocation(), Kind));
873  } else {
874  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
875  llvm::MemoryBuffer::getSTDIN();
876  if (std::error_code EC = SBOrErr.getError()) {
877  Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
878  return false;
879  }
880  std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
881 
882  const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
883  SB->getBufferSize(), 0);
884  SourceMgr.setMainFileID(
885  SourceMgr.createFileID(File, SourceLocation(), Kind));
886  SourceMgr.overrideFileContents(File, std::move(SB));
887  }
888 
889  assert(SourceMgr.getMainFileID().isValid() &&
890  "Couldn't establish MainFileID!");
891  return true;
892 }
893 
894 // High-Level Operations
895 
897  assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
898  assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
899  assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
900 
901  // FIXME: Take this as an argument, once all the APIs we used have moved to
902  // taking it as an input instead of hard-coding llvm::errs.
903  raw_ostream &OS = llvm::errs();
904 
905  if (!Act.PrepareToExecute(*this))
906  return false;
907 
908  // Create the target instance.
910  getInvocation().TargetOpts));
911  if (!hasTarget())
912  return false;
913 
914  // Create TargetInfo for the other side of CUDA and OpenMP compilation.
915  if ((getLangOpts().CUDA || getLangOpts().OpenMPIsDevice) &&
916  !getFrontendOpts().AuxTriple.empty()) {
917  auto TO = std::make_shared<TargetOptions>();
918  TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
919  TO->HostTriple = getTarget().getTriple().str();
921  }
922 
923  // Inform the target of the language options.
924  //
925  // FIXME: We shouldn't need to do this, the target should be immutable once
926  // created. This complexity should be lifted elsewhere.
928 
929  // Adjust target options based on codegen options.
931 
932  // rewriter project will change target built-in bool type from its default.
933  if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
935 
936  // Validate/process some options.
937  if (getHeaderSearchOpts().Verbose)
938  OS << "clang -cc1 version " CLANG_VERSION_STRING
939  << " based upon " << BACKEND_PACKAGE_STRING
940  << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
941 
942  if (getFrontendOpts().ShowTimers)
944 
945  if (getFrontendOpts().ShowStats || !getFrontendOpts().StatsFile.empty())
946  llvm::EnableStatistics(false);
947 
948  for (const FrontendInputFile &FIF : getFrontendOpts().Inputs) {
949  // Reset the ID tables if we are reusing the SourceManager and parsing
950  // regular files.
951  if (hasSourceManager() && !Act.isModelParsingAction())
953 
954  if (Act.BeginSourceFile(*this, FIF)) {
955  Act.Execute();
956  Act.EndSourceFile();
957  }
958  }
959 
960  // Notify the diagnostic client that all files were processed.
962 
963  if (getDiagnosticOpts().ShowCarets) {
964  // We can have multiple diagnostics sharing one diagnostic client.
965  // Get the total number of warnings/errors from the client.
966  unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
967  unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
968 
969  if (NumWarnings)
970  OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
971  if (NumWarnings && NumErrors)
972  OS << " and ";
973  if (NumErrors)
974  OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
975  if (NumWarnings || NumErrors) {
976  OS << " generated";
977  if (getLangOpts().CUDA) {
978  if (!getLangOpts().CUDAIsDevice) {
979  OS << " when compiling for host";
980  } else {
981  OS << " when compiling for " << getTargetOpts().CPU;
982  }
983  }
984  OS << ".\n";
985  }
986  }
987 
988  if (getFrontendOpts().ShowStats) {
989  if (hasFileManager()) {
991  OS << '\n';
992  }
993  llvm::PrintStatistics(OS);
994  }
995  StringRef StatsFile = getFrontendOpts().StatsFile;
996  if (!StatsFile.empty()) {
997  std::error_code EC;
998  auto StatS = llvm::make_unique<llvm::raw_fd_ostream>(StatsFile, EC,
999  llvm::sys::fs::F_Text);
1000  if (EC) {
1001  getDiagnostics().Report(diag::warn_fe_unable_to_open_stats_file)
1002  << StatsFile << EC.message();
1003  } else {
1004  llvm::PrintStatisticsJSON(*StatS);
1005  }
1006  }
1007 
1008  return !getDiagnostics().getClient()->getNumErrors();
1009 }
1010 
1011 /// Determine the appropriate source input kind based on language
1012 /// options.
1014  if (LangOpts.OpenCL)
1015  return InputKind::OpenCL;
1016  if (LangOpts.CUDA)
1017  return InputKind::CUDA;
1018  if (LangOpts.ObjC)
1019  return LangOpts.CPlusPlus ? InputKind::ObjCXX : InputKind::ObjC;
1020  return LangOpts.CPlusPlus ? InputKind::CXX : InputKind::C;
1021 }
1022 
1023 /// Compile a module file for the given module, using the options
1024 /// provided by the importing compiler instance. Returns true if the module
1025 /// was built without errors.
1026 static bool
1027 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
1028  StringRef ModuleName, FrontendInputFile Input,
1029  StringRef OriginalModuleMapFile, StringRef ModuleFileName,
1030  llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
1031  [](CompilerInstance &) {},
1032  llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
1033  [](CompilerInstance &) {}) {
1034  // Construct a compiler invocation for creating this module.
1035  auto Invocation =
1036  std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
1037 
1038  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
1039 
1040  // For any options that aren't intended to affect how a module is built,
1041  // reset them to their default values.
1042  Invocation->getLangOpts()->resetNonModularOptions();
1043  PPOpts.resetNonModularOptions();
1044 
1045  // Remove any macro definitions that are explicitly ignored by the module.
1046  // They aren't supposed to affect how the module is built anyway.
1047  HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
1048  PPOpts.Macros.erase(
1049  std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
1050  [&HSOpts](const std::pair<std::string, bool> &def) {
1051  StringRef MacroDef = def.first;
1052  return HSOpts.ModulesIgnoreMacros.count(
1053  llvm::CachedHashString(MacroDef.split('=').first)) > 0;
1054  }),
1055  PPOpts.Macros.end());
1056 
1057  // If the original compiler invocation had -fmodule-name, pass it through.
1058  Invocation->getLangOpts()->ModuleName =
1059  ImportingInstance.getInvocation().getLangOpts()->ModuleName;
1060 
1061  // Note the name of the module we're building.
1062  Invocation->getLangOpts()->CurrentModule = ModuleName;
1063 
1064  // Make sure that the failed-module structure has been allocated in
1065  // the importing instance, and propagate the pointer to the newly-created
1066  // instance.
1067  PreprocessorOptions &ImportingPPOpts
1068  = ImportingInstance.getInvocation().getPreprocessorOpts();
1069  if (!ImportingPPOpts.FailedModules)
1070  ImportingPPOpts.FailedModules =
1071  std::make_shared<PreprocessorOptions::FailedModulesSet>();
1072  PPOpts.FailedModules = ImportingPPOpts.FailedModules;
1073 
1074  // If there is a module map file, build the module using the module map.
1075  // Set up the inputs/outputs so that we build the module from its umbrella
1076  // header.
1077  FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1078  FrontendOpts.OutputFile = ModuleFileName.str();
1079  FrontendOpts.DisableFree = false;
1080  FrontendOpts.GenerateGlobalModuleIndex = false;
1081  FrontendOpts.BuildingImplicitModule = true;
1082  FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
1083  // Force implicitly-built modules to hash the content of the module file.
1084  HSOpts.ModulesHashContent = true;
1085  FrontendOpts.Inputs = {Input};
1086 
1087  // Don't free the remapped file buffers; they are owned by our caller.
1088  PPOpts.RetainRemappedFileBuffers = true;
1089 
1090  Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1091  assert(ImportingInstance.getInvocation().getModuleHash() ==
1092  Invocation->getModuleHash() && "Module hash mismatch!");
1093 
1094  // Construct a compiler instance that will be used to actually create the
1095  // module. Since we're sharing a PCMCache,
1096  // CompilerInstance::CompilerInstance is responsible for finalizing the
1097  // buffers to prevent use-after-frees.
1098  CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
1099  &ImportingInstance.getPreprocessor().getPCMCache());
1100  auto &Inv = *Invocation;
1101  Instance.setInvocation(std::move(Invocation));
1102 
1103  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
1104  ImportingInstance.getDiagnosticClient()),
1105  /*ShouldOwnClient=*/true);
1106 
1107  Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
1108 
1109  // Note that this module is part of the module build stack, so that we
1110  // can detect cycles in the module graph.
1111  Instance.setFileManager(&ImportingInstance.getFileManager());
1112  Instance.createSourceManager(Instance.getFileManager());
1113  SourceManager &SourceMgr = Instance.getSourceManager();
1114  SourceMgr.setModuleBuildStack(
1115  ImportingInstance.getSourceManager().getModuleBuildStack());
1116  SourceMgr.pushModuleBuildStack(ModuleName,
1117  FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
1118 
1119  // If we're collecting module dependencies, we need to share a collector
1120  // between all of the module CompilerInstances. Other than that, we don't
1121  // want to produce any dependency output from the module build.
1122  Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
1123  Inv.getDependencyOutputOpts() = DependencyOutputOptions();
1124 
1125  ImportingInstance.getDiagnostics().Report(ImportLoc,
1126  diag::remark_module_build)
1127  << ModuleName << ModuleFileName;
1128 
1129  PreBuildStep(Instance);
1130 
1131  // Execute the action to actually build the module in-place. Use a separate
1132  // thread so that we get a stack large enough.
1133  llvm::CrashRecoveryContext CRC;
1134  CRC.RunSafelyOnThread(
1135  [&]() {
1137  Instance.ExecuteAction(Action);
1138  },
1140 
1141  PostBuildStep(Instance);
1142 
1143  ImportingInstance.getDiagnostics().Report(ImportLoc,
1144  diag::remark_module_build_done)
1145  << ModuleName;
1146 
1147  // Delete the temporary module map file.
1148  // FIXME: Even though we're executing under crash protection, it would still
1149  // be nice to do this with RemoveFileOnSignal when we can. However, that
1150  // doesn't make sense for all clients, so clean this up manually.
1151  Instance.clearOutputFiles(/*EraseFiles=*/true);
1152 
1153  return !Instance.getDiagnostics().hasErrorOccurred();
1154 }
1155 
1156 static const FileEntry *getPublicModuleMap(const FileEntry *File,
1157  FileManager &FileMgr) {
1158  StringRef Filename = llvm::sys::path::filename(File->getName());
1159  SmallString<128> PublicFilename(File->getDir()->getName());
1160  if (Filename == "module_private.map")
1161  llvm::sys::path::append(PublicFilename, "module.map");
1162  else if (Filename == "module.private.modulemap")
1163  llvm::sys::path::append(PublicFilename, "module.modulemap");
1164  else
1165  return nullptr;
1166  return FileMgr.getFile(PublicFilename);
1167 }
1168 
1169 /// Compile a module file for the given module, using the options
1170 /// provided by the importing compiler instance. Returns true if the module
1171 /// was built without errors.
1172 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
1173  SourceLocation ImportLoc,
1174  Module *Module,
1175  StringRef ModuleFileName) {
1176  InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
1178 
1179  // Get or create the module map that we'll use to build this module.
1180  ModuleMap &ModMap
1181  = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1182  bool Result;
1183  if (const FileEntry *ModuleMapFile =
1184  ModMap.getContainingModuleMapFile(Module)) {
1185  // Canonicalize compilation to start with the public module map. This is
1186  // vital for submodules declarations in the private module maps to be
1187  // correctly parsed when depending on a top level module in the public one.
1188  if (const FileEntry *PublicMMFile = getPublicModuleMap(
1189  ModuleMapFile, ImportingInstance.getFileManager()))
1190  ModuleMapFile = PublicMMFile;
1191 
1192  // Use the module map where this module resides.
1193  Result = compileModuleImpl(
1194  ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1195  FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
1196  ModMap.getModuleMapFileForUniquing(Module)->getName(),
1197  ModuleFileName);
1198  } else {
1199  // FIXME: We only need to fake up an input file here as a way of
1200  // transporting the module's directory to the module map parser. We should
1201  // be able to do that more directly, and parse from a memory buffer without
1202  // inventing this file.
1203  SmallString<128> FakeModuleMapFile(Module->Directory->getName());
1204  llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
1205 
1206  std::string InferredModuleMapContent;
1207  llvm::raw_string_ostream OS(InferredModuleMapContent);
1208  Module->print(OS);
1209  OS.flush();
1210 
1211  Result = compileModuleImpl(
1212  ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
1213  FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
1214  ModMap.getModuleMapFileForUniquing(Module)->getName(),
1215  ModuleFileName,
1216  [&](CompilerInstance &Instance) {
1217  std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
1218  llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
1219  ModuleMapFile = Instance.getFileManager().getVirtualFile(
1220  FakeModuleMapFile, InferredModuleMapContent.size(), 0);
1221  Instance.getSourceManager().overrideFileContents(
1222  ModuleMapFile, std::move(ModuleMapBuffer));
1223  });
1224  }
1225 
1226  // We've rebuilt a module. If we're allowed to generate or update the global
1227  // module index, record that fact in the importing compiler instance.
1228  if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1229  ImportingInstance.setBuildGlobalModuleIndex(true);
1230  }
1231 
1232  return Result;
1233 }
1234 
1235 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1236  SourceLocation ImportLoc,
1237  SourceLocation ModuleNameLoc, Module *Module,
1238  StringRef ModuleFileName) {
1239  DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1240 
1241  auto diagnoseBuildFailure = [&] {
1242  Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1243  << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1244  };
1245 
1246  // FIXME: have LockFileManager return an error_code so that we can
1247  // avoid the mkdir when the directory already exists.
1248  StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1249  llvm::sys::fs::create_directories(Dir);
1250 
1251  while (1) {
1252  unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1253  llvm::LockFileManager Locked(ModuleFileName);
1254  switch (Locked) {
1255  case llvm::LockFileManager::LFS_Error:
1256  // PCMCache takes care of correctness and locks are only necessary for
1257  // performance. Fallback to building the module in case of any lock
1258  // related errors.
1259  Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
1260  << Module->Name << Locked.getErrorMessage();
1261  // Clear out any potential leftover.
1262  Locked.unsafeRemoveLockFile();
1263  LLVM_FALLTHROUGH;
1264  case llvm::LockFileManager::LFS_Owned:
1265  // We're responsible for building the module ourselves.
1266  if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1267  ModuleFileName)) {
1268  diagnoseBuildFailure();
1269  return false;
1270  }
1271  break;
1272 
1273  case llvm::LockFileManager::LFS_Shared:
1274  // Someone else is responsible for building the module. Wait for them to
1275  // finish.
1276  switch (Locked.waitForUnlock()) {
1277  case llvm::LockFileManager::Res_Success:
1278  ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1279  break;
1280  case llvm::LockFileManager::Res_OwnerDied:
1281  continue; // try again to get the lock.
1282  case llvm::LockFileManager::Res_Timeout:
1283  // Since PCMCache takes care of correctness, we try waiting for another
1284  // process to complete the build so clang does not do it done twice. If
1285  // case of timeout, build it ourselves.
1286  Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
1287  << Module->Name;
1288  // Clear the lock file so that future invocations can make progress.
1289  Locked.unsafeRemoveLockFile();
1290  continue;
1291  }
1292  break;
1293  }
1294 
1295  // Try to read the module file, now that we've compiled it.
1296  ASTReader::ASTReadResult ReadResult =
1297  ImportingInstance.getModuleManager()->ReadAST(
1298  ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1299  ModuleLoadCapabilities);
1300 
1301  if (ReadResult == ASTReader::OutOfDate &&
1302  Locked == llvm::LockFileManager::LFS_Shared) {
1303  // The module may be out of date in the presence of file system races,
1304  // or if one of its imports depends on header search paths that are not
1305  // consistent with this ImportingInstance. Try again...
1306  continue;
1307  } else if (ReadResult == ASTReader::Missing) {
1308  diagnoseBuildFailure();
1309  } else if (ReadResult != ASTReader::Success &&
1310  !Diags.hasErrorOccurred()) {
1311  // The ASTReader didn't diagnose the error, so conservatively report it.
1312  diagnoseBuildFailure();
1313  }
1314  return ReadResult == ASTReader::Success;
1315  }
1316 }
1317 
1318 /// Diagnose differences between the current definition of the given
1319 /// configuration macro and the definition provided on the command line.
1320 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1321  Module *Mod, SourceLocation ImportLoc) {
1322  IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1323  SourceManager &SourceMgr = PP.getSourceManager();
1324 
1325  // If this identifier has never had a macro definition, then it could
1326  // not have changed.
1327  if (!Id->hadMacroDefinition())
1328  return;
1329  auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1330 
1331  // Find the macro definition from the command line.
1332  MacroInfo *CmdLineDefinition = nullptr;
1333  for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1334  // We only care about the predefines buffer.
1335  FileID FID = SourceMgr.getFileID(MD->getLocation());
1336  if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1337  continue;
1338  if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1339  CmdLineDefinition = DMD->getMacroInfo();
1340  break;
1341  }
1342 
1343  auto *CurrentDefinition = PP.getMacroInfo(Id);
1344  if (CurrentDefinition == CmdLineDefinition) {
1345  // Macro matches. Nothing to do.
1346  } else if (!CurrentDefinition) {
1347  // This macro was defined on the command line, then #undef'd later.
1348  // Complain.
1349  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1350  << true << ConfigMacro << Mod->getFullModuleName();
1351  auto LatestDef = LatestLocalMD->getDefinition();
1352  assert(LatestDef.isUndefined() &&
1353  "predefined macro went away with no #undef?");
1354  PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1355  << true;
1356  return;
1357  } else if (!CmdLineDefinition) {
1358  // There was no definition for this macro in the predefines buffer,
1359  // but there was a local definition. Complain.
1360  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1361  << false << ConfigMacro << Mod->getFullModuleName();
1362  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1363  diag::note_module_def_undef_here)
1364  << false;
1365  } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1366  /*Syntactically=*/true)) {
1367  // The macro definitions differ.
1368  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1369  << false << ConfigMacro << Mod->getFullModuleName();
1370  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1371  diag::note_module_def_undef_here)
1372  << false;
1373  }
1374 }
1375 
1376 /// Write a new timestamp file with the given path.
1377 static void writeTimestampFile(StringRef TimestampFile) {
1378  std::error_code EC;
1379  llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1380 }
1381 
1382 /// Prune the module cache of modules that haven't been accessed in
1383 /// a long time.
1384 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1385  struct stat StatBuf;
1386  llvm::SmallString<128> TimestampFile;
1387  TimestampFile = HSOpts.ModuleCachePath;
1388  assert(!TimestampFile.empty());
1389  llvm::sys::path::append(TimestampFile, "modules.timestamp");
1390 
1391  // Try to stat() the timestamp file.
1392  if (::stat(TimestampFile.c_str(), &StatBuf)) {
1393  // If the timestamp file wasn't there, create one now.
1394  if (errno == ENOENT) {
1395  writeTimestampFile(TimestampFile);
1396  }
1397  return;
1398  }
1399 
1400  // Check whether the time stamp is older than our pruning interval.
1401  // If not, do nothing.
1402  time_t TimeStampModTime = StatBuf.st_mtime;
1403  time_t CurrentTime = time(nullptr);
1404  if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1405  return;
1406 
1407  // Write a new timestamp file so that nobody else attempts to prune.
1408  // There is a benign race condition here, if two Clang instances happen to
1409  // notice at the same time that the timestamp is out-of-date.
1410  writeTimestampFile(TimestampFile);
1411 
1412  // Walk the entire module cache, looking for unused module files and module
1413  // indices.
1414  std::error_code EC;
1415  SmallString<128> ModuleCachePathNative;
1416  llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1417  for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1418  Dir != DirEnd && !EC; Dir.increment(EC)) {
1419  // If we don't have a directory, there's nothing to look into.
1420  if (!llvm::sys::fs::is_directory(Dir->path()))
1421  continue;
1422 
1423  // Walk all of the files within this directory.
1424  for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1425  File != FileEnd && !EC; File.increment(EC)) {
1426  // We only care about module and global module index files.
1427  StringRef Extension = llvm::sys::path::extension(File->path());
1428  if (Extension != ".pcm" && Extension != ".timestamp" &&
1429  llvm::sys::path::filename(File->path()) != "modules.idx")
1430  continue;
1431 
1432  // Look at this file. If we can't stat it, there's nothing interesting
1433  // there.
1434  if (::stat(File->path().c_str(), &StatBuf))
1435  continue;
1436 
1437  // If the file has been used recently enough, leave it there.
1438  time_t FileAccessTime = StatBuf.st_atime;
1439  if (CurrentTime - FileAccessTime <=
1440  time_t(HSOpts.ModuleCachePruneAfter)) {
1441  continue;
1442  }
1443 
1444  // Remove the file.
1445  llvm::sys::fs::remove(File->path());
1446 
1447  // Remove the timestamp file.
1448  std::string TimpestampFilename = File->path() + ".timestamp";
1449  llvm::sys::fs::remove(TimpestampFilename);
1450  }
1451 
1452  // If we removed all of the files in the directory, remove the directory
1453  // itself.
1454  if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1455  llvm::sys::fs::directory_iterator() && !EC)
1456  llvm::sys::fs::remove(Dir->path());
1457  }
1458 }
1459 
1461  if (!ModuleManager) {
1462  if (!hasASTContext())
1463  createASTContext();
1464 
1465  // If we're implicitly building modules but not currently recursively
1466  // building a module, check whether we need to prune the module cache.
1467  if (getSourceManager().getModuleBuildStack().empty() &&
1468  !getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty() &&
1469  getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1470  getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1472  }
1473 
1475  std::string Sysroot = HSOpts.Sysroot;
1476  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1477  std::unique_ptr<llvm::Timer> ReadTimer;
1478  if (FrontendTimerGroup)
1479  ReadTimer = llvm::make_unique<llvm::Timer>("reading_modules",
1480  "Reading modules",
1481  *FrontendTimerGroup);
1482  ModuleManager = new ASTReader(
1484  getFrontendOpts().ModuleFileExtensions,
1485  Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1486  /*AllowASTWithCompilerErrors=*/false,
1487  /*AllowConfigurationMismatch=*/false,
1490  std::move(ReadTimer));
1491  if (hasASTConsumer()) {
1492  ModuleManager->setDeserializationListener(
1493  getASTConsumer().GetASTDeserializationListener());
1495  getASTConsumer().GetASTMutationListener());
1496  }
1497  getASTContext().setExternalSource(ModuleManager);
1498  if (hasSema())
1499  ModuleManager->InitializeSema(getSema());
1500  if (hasASTConsumer())
1501  ModuleManager->StartTranslationUnit(&getASTConsumer());
1502 
1503  if (TheDependencyFileGenerator)
1504  TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1505  for (auto &Listener : DependencyCollectors)
1506  Listener->attachToASTReader(*ModuleManager);
1507  }
1508 }
1509 
1510 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1511  llvm::Timer Timer;
1512  if (FrontendTimerGroup)
1513  Timer.init("preloading." + FileName.str(), "Preloading " + FileName.str(),
1514  *FrontendTimerGroup);
1515  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1516 
1517  // Helper to recursively read the module names for all modules we're adding.
1518  // We mark these as known and redirect any attempt to load that module to
1519  // the files we were handed.
1520  struct ReadModuleNames : ASTReaderListener {
1521  CompilerInstance &CI;
1523 
1524  ReadModuleNames(CompilerInstance &CI) : CI(CI) {}
1525 
1526  void ReadModuleName(StringRef ModuleName) override {
1527  LoadedModules.push_back(
1528  CI.getPreprocessor().getIdentifierInfo(ModuleName));
1529  }
1530 
1531  void registerAll() {
1532  for (auto *II : LoadedModules) {
1533  CI.KnownModules[II] = CI.getPreprocessor()
1535  .getModuleMap()
1536  .findModule(II->getName());
1537  }
1538  LoadedModules.clear();
1539  }
1540 
1541  void markAllUnavailable() {
1542  for (auto *II : LoadedModules) {
1543  if (Module *M = CI.getPreprocessor()
1545  .getModuleMap()
1546  .findModule(II->getName())) {
1547  M->HasIncompatibleModuleFile = true;
1548 
1549  // Mark module as available if the only reason it was unavailable
1550  // was missing headers.
1552  Stack.push_back(M);
1553  while (!Stack.empty()) {
1554  Module *Current = Stack.pop_back_val();
1555  if (Current->IsMissingRequirement) continue;
1556  Current->IsAvailable = true;
1557  Stack.insert(Stack.end(),
1558  Current->submodule_begin(), Current->submodule_end());
1559  }
1560  }
1561  }
1562  LoadedModules.clear();
1563  }
1564  };
1565 
1566  // If we don't already have an ASTReader, create one now.
1567  if (!ModuleManager)
1569 
1570  // If -Wmodule-file-config-mismatch is mapped as an error or worse, allow the
1571  // ASTReader to diagnose it, since it can produce better errors that we can.
1572  bool ConfigMismatchIsRecoverable =
1573  getDiagnostics().getDiagnosticLevel(diag::warn_module_config_mismatch,
1574  SourceLocation())
1576 
1577  auto Listener = llvm::make_unique<ReadModuleNames>(*this);
1578  auto &ListenerRef = *Listener;
1579  ASTReader::ListenerScope ReadModuleNamesListener(*ModuleManager,
1580  std::move(Listener));
1581 
1582  // Try to load the module file.
1583  switch (ModuleManager->ReadAST(
1585  ConfigMismatchIsRecoverable ? ASTReader::ARR_ConfigurationMismatch : 0)) {
1586  case ASTReader::Success:
1587  // We successfully loaded the module file; remember the set of provided
1588  // modules so that we don't try to load implicit modules for them.
1589  ListenerRef.registerAll();
1590  return true;
1591 
1593  // Ignore unusable module files.
1594  getDiagnostics().Report(SourceLocation(), diag::warn_module_config_mismatch)
1595  << FileName;
1596  // All modules provided by any files we tried and failed to load are now
1597  // unavailable; includes of those modules should now be handled textually.
1598  ListenerRef.markAllUnavailable();
1599  return true;
1600 
1601  default:
1602  return false;
1603  }
1604 }
1605 
1608  ModuleIdPath Path,
1610  bool IsInclusionDirective) {
1611  // Determine what file we're searching from.
1612  StringRef ModuleName = Path[0].first->getName();
1613  SourceLocation ModuleNameLoc = Path[0].second;
1614 
1615  // If we've already handled this import, just return the cached result.
1616  // This one-element cache is important to eliminate redundant diagnostics
1617  // when both the preprocessor and parser see the same import declaration.
1618  if (ImportLoc.isValid() && LastModuleImportLoc == ImportLoc) {
1619  // Make the named module visible.
1620  if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1621  ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1622  ImportLoc);
1623  return LastModuleImportResult;
1624  }
1625 
1626  clang::Module *Module = nullptr;
1627 
1628  // If we don't already have information on this module, load the module now.
1629  llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1630  = KnownModules.find(Path[0].first);
1631  if (Known != KnownModules.end()) {
1632  // Retrieve the cached top-level module.
1633  Module = Known->second;
1634  } else if (ModuleName == getLangOpts().CurrentModule) {
1635  // This is the module we're building.
1636  Module = PP->getHeaderSearchInfo().lookupModule(
1637  ModuleName, /*AllowSearch*/ true,
1638  /*AllowExtraModuleMapSearch*/ !IsInclusionDirective);
1639  /// FIXME: perhaps we should (a) look for a module using the module name
1640  // to file map (PrebuiltModuleFiles) and (b) diagnose if still not found?
1641  //if (Module == nullptr) {
1642  // getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1643  // << ModuleName;
1644  // ModuleBuildFailed = true;
1645  // return ModuleLoadResult();
1646  //}
1647  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1648  } else {
1649  // Search for a module with the given name.
1650  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1651  !IsInclusionDirective);
1652  HeaderSearchOptions &HSOpts =
1653  PP->getHeaderSearchInfo().getHeaderSearchOpts();
1654 
1655  std::string ModuleFileName;
1656  enum ModuleSource {
1657  ModuleNotFound, ModuleCache, PrebuiltModulePath, ModuleBuildPragma
1658  } Source = ModuleNotFound;
1659 
1660  // Check to see if the module has been built as part of this compilation
1661  // via a module build pragma.
1662  auto BuiltModuleIt = BuiltModules.find(ModuleName);
1663  if (BuiltModuleIt != BuiltModules.end()) {
1664  ModuleFileName = BuiltModuleIt->second;
1665  Source = ModuleBuildPragma;
1666  }
1667 
1668  // Try to load the module from the prebuilt module path.
1669  if (Source == ModuleNotFound && (!HSOpts.PrebuiltModuleFiles.empty() ||
1670  !HSOpts.PrebuiltModulePaths.empty())) {
1671  ModuleFileName =
1672  PP->getHeaderSearchInfo().getPrebuiltModuleFileName(ModuleName);
1673  if (!ModuleFileName.empty())
1674  Source = PrebuiltModulePath;
1675  }
1676 
1677  // Try to load the module from the module cache.
1678  if (Source == ModuleNotFound && Module) {
1679  ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
1680  Source = ModuleCache;
1681  }
1682 
1683  if (Source == ModuleNotFound) {
1684  // We can't find a module, error out here.
1685  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1686  << ModuleName << SourceRange(ImportLoc, ModuleNameLoc);
1687  ModuleBuildFailed = true;
1688  return ModuleLoadResult();
1689  }
1690 
1691  if (ModuleFileName.empty()) {
1692  if (Module && Module->HasIncompatibleModuleFile) {
1693  // We tried and failed to load a module file for this module. Fall
1694  // back to textual inclusion for its headers.
1696  }
1697 
1698  getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1699  << ModuleName;
1700  ModuleBuildFailed = true;
1701  return ModuleLoadResult();
1702  }
1703 
1704  // If we don't already have an ASTReader, create one now.
1705  if (!ModuleManager)
1707 
1708  llvm::Timer Timer;
1709  if (FrontendTimerGroup)
1710  Timer.init("loading." + ModuleFileName, "Loading " + ModuleFileName,
1711  *FrontendTimerGroup);
1712  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1713 
1714  // Try to load the module file. If we are not trying to load from the
1715  // module cache, we don't know how to rebuild modules.
1716  unsigned ARRFlags = Source == ModuleCache ?
1718  Source == PrebuiltModulePath ?
1719  0 :
1721  switch (ModuleManager->ReadAST(ModuleFileName,
1722  Source == PrebuiltModulePath
1724  : Source == ModuleBuildPragma
1727  ImportLoc, ARRFlags)) {
1728  case ASTReader::Success: {
1729  if (Source != ModuleCache && !Module) {
1730  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName, true,
1731  !IsInclusionDirective);
1732  if (!Module || !Module->getASTFile() ||
1733  FileMgr->getFile(ModuleFileName) != Module->getASTFile()) {
1734  // Error out if Module does not refer to the file in the prebuilt
1735  // module path.
1736  getDiagnostics().Report(ModuleNameLoc, diag::err_module_prebuilt)
1737  << ModuleName;
1738  ModuleBuildFailed = true;
1739  KnownModules[Path[0].first] = nullptr;
1740  return ModuleLoadResult();
1741  }
1742  }
1743  break;
1744  }
1745 
1746  case ASTReader::OutOfDate:
1747  case ASTReader::Missing: {
1748  if (Source != ModuleCache) {
1749  // We don't know the desired configuration for this module and don't
1750  // necessarily even have a module map. Since ReadAST already produces
1751  // diagnostics for these two cases, we simply error out here.
1752  ModuleBuildFailed = true;
1753  KnownModules[Path[0].first] = nullptr;
1754  return ModuleLoadResult();
1755  }
1756 
1757  // The module file is missing or out-of-date. Build it.
1758  assert(Module && "missing module file");
1759  // Check whether there is a cycle in the module graph.
1761  ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1762  for (; Pos != PosEnd; ++Pos) {
1763  if (Pos->first == ModuleName)
1764  break;
1765  }
1766 
1767  if (Pos != PosEnd) {
1768  SmallString<256> CyclePath;
1769  for (; Pos != PosEnd; ++Pos) {
1770  CyclePath += Pos->first;
1771  CyclePath += " -> ";
1772  }
1773  CyclePath += ModuleName;
1774 
1775  getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1776  << ModuleName << CyclePath;
1777  return ModuleLoadResult();
1778  }
1779 
1780  // Check whether we have already attempted to build this module (but
1781  // failed).
1782  if (getPreprocessorOpts().FailedModules &&
1783  getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1784  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1785  << ModuleName
1786  << SourceRange(ImportLoc, ModuleNameLoc);
1787  ModuleBuildFailed = true;
1788  return ModuleLoadResult();
1789  }
1790 
1791  // Try to compile and then load the module.
1792  if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1793  ModuleFileName)) {
1794  assert(getDiagnostics().hasErrorOccurred() &&
1795  "undiagnosed error in compileAndLoadModule");
1796  if (getPreprocessorOpts().FailedModules)
1797  getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1798  KnownModules[Path[0].first] = nullptr;
1799  ModuleBuildFailed = true;
1800  return ModuleLoadResult();
1801  }
1802 
1803  // Okay, we've rebuilt and now loaded the module.
1804  break;
1805  }
1806 
1808  if (Source == PrebuiltModulePath)
1809  // FIXME: We shouldn't be setting HadFatalFailure below if we only
1810  // produce a warning here!
1812  diag::warn_module_config_mismatch)
1813  << ModuleFileName;
1814  // Fall through to error out.
1815  LLVM_FALLTHROUGH;
1817  case ASTReader::HadErrors:
1819  // FIXME: The ASTReader will already have complained, but can we shoehorn
1820  // that diagnostic information into a more useful form?
1821  KnownModules[Path[0].first] = nullptr;
1822  return ModuleLoadResult();
1823 
1824  case ASTReader::Failure:
1826  // Already complained, but note now that we failed.
1827  KnownModules[Path[0].first] = nullptr;
1828  ModuleBuildFailed = true;
1829  return ModuleLoadResult();
1830  }
1831 
1832  // Cache the result of this top-level module lookup for later.
1833  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1834  }
1835 
1836  // If we never found the module, fail.
1837  if (!Module)
1838  return ModuleLoadResult();
1839 
1840  // Verify that the rest of the module path actually corresponds to
1841  // a submodule.
1842  bool MapPrivateSubModToTopLevel = false;
1843  if (Path.size() > 1) {
1844  for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1845  StringRef Name = Path[I].first->getName();
1846  clang::Module *Sub = Module->findSubmodule(Name);
1847 
1848  // If the user is requesting Foo.Private and it doesn't exist, try to
1849  // match Foo_Private and emit a warning asking for the user to write
1850  // @import Foo_Private instead. FIXME: remove this when existing clients
1851  // migrate off of Foo.Private syntax.
1852  if (!Sub && PP->getLangOpts().ImplicitModules && Name == "Private" &&
1853  Module == Module->getTopLevelModule()) {
1854  SmallString<128> PrivateModule(Module->Name);
1855  PrivateModule.append("_Private");
1856 
1858  auto &II = PP->getIdentifierTable().get(
1859  PrivateModule, PP->getIdentifierInfo(Module->Name)->getTokenID());
1860  PrivPath.push_back(std::make_pair(&II, Path[0].second));
1861 
1862  if (PP->getHeaderSearchInfo().lookupModule(PrivateModule, true,
1863  !IsInclusionDirective))
1864  Sub =
1865  loadModule(ImportLoc, PrivPath, Visibility, IsInclusionDirective);
1866  if (Sub) {
1867  MapPrivateSubModToTopLevel = true;
1868  if (!getDiagnostics().isIgnored(
1869  diag::warn_no_priv_submodule_use_toplevel, ImportLoc)) {
1870  getDiagnostics().Report(Path[I].second,
1871  diag::warn_no_priv_submodule_use_toplevel)
1872  << Path[I].first << Module->getFullModuleName() << PrivateModule
1873  << SourceRange(Path[0].second, Path[I].second)
1874  << FixItHint::CreateReplacement(SourceRange(Path[0].second),
1875  PrivateModule);
1877  diag::note_private_top_level_defined);
1878  }
1879  }
1880  }
1881 
1882  if (!Sub) {
1883  // Attempt to perform typo correction to find a module name that works.
1885  unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1886 
1888  JEnd = Module->submodule_end();
1889  J != JEnd; ++J) {
1890  unsigned ED = Name.edit_distance((*J)->Name,
1891  /*AllowReplacements=*/true,
1892  BestEditDistance);
1893  if (ED <= BestEditDistance) {
1894  if (ED < BestEditDistance) {
1895  Best.clear();
1896  BestEditDistance = ED;
1897  }
1898 
1899  Best.push_back((*J)->Name);
1900  }
1901  }
1902 
1903  // If there was a clear winner, user it.
1904  if (Best.size() == 1) {
1905  getDiagnostics().Report(Path[I].second,
1906  diag::err_no_submodule_suggest)
1907  << Path[I].first << Module->getFullModuleName() << Best[0]
1908  << SourceRange(Path[0].second, Path[I-1].second)
1909  << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1910  Best[0]);
1911 
1912  Sub = Module->findSubmodule(Best[0]);
1913  }
1914  }
1915 
1916  if (!Sub) {
1917  // No submodule by this name. Complain, and don't look for further
1918  // submodules.
1919  getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1920  << Path[I].first << Module->getFullModuleName()
1921  << SourceRange(Path[0].second, Path[I-1].second);
1922  break;
1923  }
1924 
1925  Module = Sub;
1926  }
1927  }
1928 
1929  // Make the named module visible, if it's not already part of the module
1930  // we are parsing.
1931  if (ModuleName != getLangOpts().CurrentModule) {
1932  if (!Module->IsFromModuleFile && !MapPrivateSubModToTopLevel) {
1933  // We have an umbrella header or directory that doesn't actually include
1934  // all of the headers within the directory it covers. Complain about
1935  // this missing submodule and recover by forgetting that we ever saw
1936  // this submodule.
1937  // FIXME: Should we detect this at module load time? It seems fairly
1938  // expensive (and rare).
1939  getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1940  << Module->getFullModuleName()
1941  << SourceRange(Path.front().second, Path.back().second);
1942 
1944  }
1945 
1946  // Check whether this module is available.
1948  getDiagnostics(), Module)) {
1949  getDiagnostics().Report(ImportLoc, diag::note_module_import_here)
1950  << SourceRange(Path.front().second, Path.back().second);
1951  LastModuleImportLoc = ImportLoc;
1952  LastModuleImportResult = ModuleLoadResult();
1953  return ModuleLoadResult();
1954  }
1955 
1956  ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1957  }
1958 
1959  // Check for any configuration macros that have changed.
1960  clang::Module *TopModule = Module->getTopLevelModule();
1961  for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1963  Module, ImportLoc);
1964  }
1965 
1966  // Resolve any remaining module using export_as for this one.
1967  getPreprocessor()
1969  .getModuleMap()
1970  .resolveLinkAsDependencies(TopModule);
1971 
1972  LastModuleImportLoc = ImportLoc;
1973  LastModuleImportResult = ModuleLoadResult(Module);
1974  return LastModuleImportResult;
1975 }
1976 
1978  StringRef ModuleName,
1979  StringRef Source) {
1980  // Avoid creating filenames with special characters.
1981  SmallString<128> CleanModuleName(ModuleName);
1982  for (auto &C : CleanModuleName)
1983  if (!isAlphanumeric(C))
1984  C = '_';
1985 
1986  // FIXME: Using a randomized filename here means that our intermediate .pcm
1987  // output is nondeterministic (as .pcm files refer to each other by name).
1988  // Can this affect the output in any way?
1989  SmallString<128> ModuleFileName;
1990  if (std::error_code EC = llvm::sys::fs::createTemporaryFile(
1991  CleanModuleName, "pcm", ModuleFileName)) {
1992  getDiagnostics().Report(ImportLoc, diag::err_fe_unable_to_open_output)
1993  << ModuleFileName << EC.message();
1994  return;
1995  }
1996  std::string ModuleMapFileName = (CleanModuleName + ".map").str();
1997 
1998  FrontendInputFile Input(
1999  ModuleMapFileName,
2000  InputKind(getLanguageFromOptions(*Invocation->getLangOpts()),
2001  InputKind::ModuleMap, /*Preprocessed*/true));
2002 
2003  std::string NullTerminatedSource(Source.str());
2004 
2005  auto PreBuildStep = [&](CompilerInstance &Other) {
2006  // Create a virtual file containing our desired source.
2007  // FIXME: We shouldn't need to do this.
2008  const FileEntry *ModuleMapFile = Other.getFileManager().getVirtualFile(
2009  ModuleMapFileName, NullTerminatedSource.size(), 0);
2010  Other.getSourceManager().overrideFileContents(
2011  ModuleMapFile,
2012  llvm::MemoryBuffer::getMemBuffer(NullTerminatedSource.c_str()));
2013 
2014  Other.BuiltModules = std::move(BuiltModules);
2015  Other.DeleteBuiltModules = false;
2016  };
2017 
2018  auto PostBuildStep = [this](CompilerInstance &Other) {
2019  BuiltModules = std::move(Other.BuiltModules);
2020  };
2021 
2022  // Build the module, inheriting any modules that we've built locally.
2023  if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
2024  ModuleFileName, PreBuildStep, PostBuildStep)) {
2025  BuiltModules[ModuleName] = ModuleFileName.str();
2026  llvm::sys::RemoveFileOnSignal(ModuleFileName);
2027  }
2028 }
2029 
2032  SourceLocation ImportLoc) {
2033  if (!ModuleManager)
2035  if (!ModuleManager)
2036  return;
2037 
2038  ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
2039 }
2040 
2042  SourceLocation TriggerLoc) {
2043  if (getPreprocessor().getHeaderSearchInfo().getModuleCachePath().empty())
2044  return nullptr;
2045  if (!ModuleManager)
2047  // Can't do anything if we don't have the module manager.
2048  if (!ModuleManager)
2049  return nullptr;
2050  // Get an existing global index. This loads it if not already
2051  // loaded.
2052  ModuleManager->loadGlobalIndex();
2053  GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
2054  // If the global index doesn't exist, create it.
2055  if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
2056  hasPreprocessor()) {
2057  llvm::sys::fs::create_directories(
2058  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2061  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2062  ModuleManager->resetForReload();
2063  ModuleManager->loadGlobalIndex();
2064  GlobalIndex = ModuleManager->getGlobalIndex();
2065  }
2066  // For finding modules needing to be imported for fixit messages,
2067  // we need to make the global index cover all modules, so we do that here.
2068  if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
2070  bool RecreateIndex = false;
2071  for (ModuleMap::module_iterator I = MMap.module_begin(),
2072  E = MMap.module_end(); I != E; ++I) {
2073  Module *TheModule = I->second;
2074  const FileEntry *Entry = TheModule->getASTFile();
2075  if (!Entry) {
2077  Path.push_back(std::make_pair(
2078  getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
2079  std::reverse(Path.begin(), Path.end());
2080  // Load a module as hidden. This also adds it to the global index.
2081  loadModule(TheModule->DefinitionLoc, Path, Module::Hidden, false);
2082  RecreateIndex = true;
2083  }
2084  }
2085  if (RecreateIndex) {
2088  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
2089  ModuleManager->resetForReload();
2090  ModuleManager->loadGlobalIndex();
2091  GlobalIndex = ModuleManager->getGlobalIndex();
2092  }
2093  HaveFullGlobalModuleIndex = true;
2094  }
2095  return GlobalIndex;
2096 }
2097 
2098 // Check global module index for missing imports.
2099 bool
2101  SourceLocation TriggerLoc) {
2102  // Look for the symbol in non-imported modules, but only if an error
2103  // actually occurred.
2104  if (!buildingModule()) {
2105  // Load global module index, or retrieve a previously loaded one.
2107  TriggerLoc);
2108 
2109  // Only if we have a global index.
2110  if (GlobalIndex) {
2111  GlobalModuleIndex::HitSet FoundModules;
2112 
2113  // Find the modules that reference the identifier.
2114  // Note that this only finds top-level modules.
2115  // We'll let diagnoseTypo find the actual declaration module.
2116  if (GlobalIndex->lookupIdentifier(Name, FoundModules))
2117  return true;
2118  }
2119  }
2120 
2121  return false;
2122 }
2123 void CompilerInstance::resetAndLeakSema() { llvm::BuryPointer(takeSema()); }
2124 
2127  ExternalSemaSrc = std::move(ESS);
2128 }
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:921
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:744
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:507
std::string DwarfDebugFlags
The string to embed in the debug information for the compile unit, if non-empty.
std::vector< std::string > PrebuiltModulePaths
The directories used to load prebuilt module files.
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:825
std::string DOTOutputFile
The file to write GraphViz-formatted header dependencies to.
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:553
VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to c...
void createFrontendTimer()
Create the frontend timer and replace any existing one with it.
bool RemappedFilesKeepOriginalName
True if the SourceManager should report the original file name for contents of files that were remapp...
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:122
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:820
void createDiagnostics(DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)
Create the diagnostics engine using the invocation&#39;s diagnostic options and replace any existing one ...
submodule_iterator submodule_begin()
Definition: Module.h:556
static void writeTimestampFile(StringRef TimestampFile)
Write a new timestamp file with the given path.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
Format getFormat() const
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h: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:818
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Abstract base class for actions which can be performed by the frontend.
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Definition: ModuleMap.cpp: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:1292
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:515
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.
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1485
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:826
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:100
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:1494
Definition: Format.h:2072
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:821
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:219
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:1629
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:981
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:602
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:819
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:96
void overrideFileContents(const FileEntry *SourceFile, llvm::MemoryBuffer *Buffer, bool DoNotFree)
Override the contents of the given source file by providing an already-allocated buffer.
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:96
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:86
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:102
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:1495
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:1521
All of the names in this module are hidden.
Definition: Module.h:269
File is an implicitly-loaded module.
Definition: Module.h:45
unsigned ModulesValidateSystemHeaders
Whether to validate system input files when a module is loaded.
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h: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:1552
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:212
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:831
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:89
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:1091
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.
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:900
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:812
unsigned ModuleCachePruneAfter
The time (in seconds) after which an unused module file will be considered unused and will...
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:354
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:816
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:234
std::string DiagnosticLogFile
The file to log diagnostic output to.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
bool ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
Definition: Diagnostic.h:511
StringRef getName() const
Definition: FileManager.h:52
virtual bool isModelParsingAction() const
Is this action invoked on a model file?