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