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