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