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