clang  3.7.0
CompilerInstance.cpp
Go to the documentation of this file.
1 //===--- CompilerInstance.cpp ---------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/Decl.h"
14 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Basic/Version.h"
19 #include "clang/Config/config.h"
27 #include "clang/Frontend/Utils.h"
29 #include "clang/Lex/HeaderSearch.h"
30 #include "clang/Lex/PTHManager.h"
31 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Sema/Sema.h"
36 #include "llvm/ADT/Statistic.h"
37 #include "llvm/Support/CrashRecoveryContext.h"
38 #include "llvm/Support/Errc.h"
39 #include "llvm/Support/FileSystem.h"
40 #include "llvm/Support/Host.h"
41 #include "llvm/Support/LockFileManager.h"
42 #include "llvm/Support/MemoryBuffer.h"
43 #include "llvm/Support/Path.h"
44 #include "llvm/Support/Program.h"
45 #include "llvm/Support/Signals.h"
46 #include "llvm/Support/Timer.h"
47 #include "llvm/Support/raw_ostream.h"
48 #include <sys/stat.h>
49 #include <system_error>
50 #include <time.h>
51 
52 using namespace clang;
53 
54 CompilerInstance::CompilerInstance(
55  std::shared_ptr<PCHContainerOperations> PCHContainerOps,
56  bool BuildingModule)
57  : ModuleLoader(BuildingModule), Invocation(new CompilerInvocation()),
58  ModuleManager(nullptr), ThePCHContainerOperations(PCHContainerOps),
59  BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false),
60  ModuleBuildFailed(false) {}
61 
63  assert(OutputFiles.empty() && "Still output files in flight?");
64 }
65 
67  Invocation = Value;
68 }
69 
71  return (BuildGlobalModuleIndex ||
72  (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
74  !ModuleBuildFailed;
75 }
76 
78  Diagnostics = Value;
79 }
80 
82  Target = Value;
83 }
84 
86  FileMgr = Value;
87  if (Value)
88  VirtualFileSystem = Value->getVirtualFileSystem();
89  else
90  VirtualFileSystem.reset();
91 }
92 
94  SourceMgr = Value;
95 }
96 
98 
100 
102  TheSema.reset(S);
103 }
104 
105 void CompilerInstance::setASTConsumer(std::unique_ptr<ASTConsumer> Value) {
106  Consumer = std::move(Value);
107 }
108 
110  CompletionConsumer.reset(Value);
111 }
112 
113 std::unique_ptr<Sema> CompilerInstance::takeSema() {
114  return std::move(TheSema);
115 }
116 
118  return ModuleManager;
119 }
121  ModuleManager = Reader;
122 }
123 
124 std::shared_ptr<ModuleDependencyCollector>
126  return ModuleDepCollector;
127 }
128 
130  std::shared_ptr<ModuleDependencyCollector> Collector) {
131  ModuleDepCollector = Collector;
132 }
133 
134 // Diagnostics
135 static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
136  const CodeGenOptions *CodeGenOpts,
137  DiagnosticsEngine &Diags) {
138  std::error_code EC;
139  std::unique_ptr<raw_ostream> StreamOwner;
140  raw_ostream *OS = &llvm::errs();
141  if (DiagOpts->DiagnosticLogFile != "-") {
142  // Create the output stream.
143  auto FileOS = llvm::make_unique<llvm::raw_fd_ostream>(
144  DiagOpts->DiagnosticLogFile, EC,
145  llvm::sys::fs::F_Append | llvm::sys::fs::F_Text);
146  if (EC) {
147  Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
148  << DiagOpts->DiagnosticLogFile << EC.message();
149  } else {
150  FileOS->SetUnbuffered();
151  FileOS->SetUseAtomicWrites(true);
152  OS = FileOS.get();
153  StreamOwner = std::move(FileOS);
154  }
155  }
156 
157  // Chain in the diagnostic client which will log the diagnostics.
158  auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
159  std::move(StreamOwner));
160  if (CodeGenOpts)
161  Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
162  assert(Diags.ownsClient());
163  Diags.setClient(
164  new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
165 }
166 
168  DiagnosticsEngine &Diags,
169  StringRef OutputFile) {
170  auto SerializedConsumer =
171  clang::serialized_diags::create(OutputFile, DiagOpts);
172 
173  if (Diags.ownsClient()) {
175  Diags.takeClient(), std::move(SerializedConsumer)));
176  } else {
178  Diags.getClient(), std::move(SerializedConsumer)));
179  }
180 }
181 
183  bool ShouldOwnClient) {
184  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
185  ShouldOwnClient, &getCodeGenOpts());
186 }
187 
190  DiagnosticConsumer *Client,
191  bool ShouldOwnClient,
192  const CodeGenOptions *CodeGenOpts) {
195  Diags(new DiagnosticsEngine(DiagID, Opts));
196 
197  // Create the diagnostic client for reporting errors or for
198  // implementing -verify.
199  if (Client) {
200  Diags->setClient(Client, ShouldOwnClient);
201  } else
202  Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
203 
204  // Chain in -verify checker, if requested.
205  if (Opts->VerifyDiagnostics)
206  Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
207 
208  // Chain in -diagnostic-log-file dumper, if requested.
209  if (!Opts->DiagnosticLogFile.empty())
210  SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
211 
212  if (!Opts->DiagnosticSerializationFile.empty())
213  SetupSerializedDiagnostics(Opts, *Diags,
215 
216  // Configure our handling of diagnostics.
217  ProcessWarningOptions(*Diags, *Opts);
218 
219  return Diags;
220 }
221 
222 // File Manager
223 
225  if (!hasVirtualFileSystem()) {
226  // TODO: choose the virtual file system based on the CompilerInvocation.
228  }
229  FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
230 }
231 
232 // Source Manager
233 
235  SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
236 }
237 
238 // Initialize the remapping of files to alternative contents, e.g.,
239 // those specified through other files.
242  FileManager &FileMgr,
243  const PreprocessorOptions &InitOpts) {
244  // Remap files in the source manager (with buffers).
245  for (const auto &RB : InitOpts.RemappedFileBuffers) {
246  // Create the file entry for the file that we're mapping from.
247  const FileEntry *FromFile =
248  FileMgr.getVirtualFile(RB.first, RB.second->getBufferSize(), 0);
249  if (!FromFile) {
250  Diags.Report(diag::err_fe_remap_missing_from_file) << RB.first;
251  if (!InitOpts.RetainRemappedFileBuffers)
252  delete RB.second;
253  continue;
254  }
255 
256  // Override the contents of the "from" file with the contents of
257  // the "to" file.
258  SourceMgr.overrideFileContents(FromFile, RB.second,
259  InitOpts.RetainRemappedFileBuffers);
260  }
261 
262  // Remap files in the source manager (with other files).
263  for (const auto &RF : InitOpts.RemappedFiles) {
264  // Find the file that we're mapping to.
265  const FileEntry *ToFile = FileMgr.getFile(RF.second);
266  if (!ToFile) {
267  Diags.Report(diag::err_fe_remap_missing_to_file) << RF.first << RF.second;
268  continue;
269  }
270 
271  // Create the file entry for the file that we're mapping from.
272  const FileEntry *FromFile =
273  FileMgr.getVirtualFile(RF.first, ToFile->getSize(), 0);
274  if (!FromFile) {
275  Diags.Report(diag::err_fe_remap_missing_from_file) << RF.first;
276  continue;
277  }
278 
279  // Override the contents of the "from" file with the contents of
280  // the "to" file.
281  SourceMgr.overrideFileContents(FromFile, ToFile);
282  }
283 
286 }
287 
288 // Preprocessor
289 
291  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
292 
293  // Create a PTH manager if we are using some form of a token cache.
294  PTHManager *PTHMgr = nullptr;
295  if (!PPOpts.TokenCache.empty())
296  PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
297 
298  // Create the Preprocessor.
299  HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
301  getDiagnostics(),
302  getLangOpts(),
303  &getTarget());
305  getSourceManager(), *HeaderInfo, *this, PTHMgr,
306  /*OwnsHeaderSearch=*/true, TUKind);
307  PP->Initialize(getTarget());
308 
309  // Note that this is different then passing PTHMgr to Preprocessor's ctor.
310  // That argument is used as the IdentifierInfoLookup argument to
311  // IdentifierTable's ctor.
312  if (PTHMgr) {
313  PTHMgr->setPreprocessor(&*PP);
314  PP->setPTHManager(PTHMgr);
315  }
316 
317  if (PPOpts.DetailedRecord)
318  PP->createPreprocessingRecord();
319 
320  // Apply remappings to the source manager.
321  InitializeFileRemapping(PP->getDiagnostics(), PP->getSourceManager(),
322  PP->getFileManager(), PPOpts);
323 
324  // Predefine macros and configure the preprocessor.
326  getFrontendOpts());
327 
328  // Initialize the header search object.
329  ApplyHeaderSearchOptions(PP->getHeaderSearchInfo(), getHeaderSearchOpts(),
330  PP->getLangOpts(), PP->getTargetInfo().getTriple());
331 
332  PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
333 
334  if (PP->getLangOpts().Modules)
335  PP->getHeaderSearchInfo().setModuleCachePath(getSpecificModuleCachePath());
336 
337  // Handle generating dependencies, if requested.
339  if (!DepOpts.OutputFile.empty())
340  TheDependencyFileGenerator.reset(
342  if (!DepOpts.DOTOutputFile.empty())
345 
346  for (auto &Listener : DependencyCollectors)
347  Listener->attachToPreprocessor(*PP);
348 
349  // If we don't have a collector, but we are collecting module dependencies,
350  // then we're the top level compiler instance and need to create one.
351  if (!ModuleDepCollector && !DepOpts.ModuleDependencyOutputDir.empty())
352  ModuleDepCollector = std::make_shared<ModuleDependencyCollector>(
353  DepOpts.ModuleDependencyOutputDir);
354 
355  // Handle generating header include information, if requested.
356  if (DepOpts.ShowHeaderIncludes)
358  if (!DepOpts.HeaderIncludeOutputFile.empty()) {
359  StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
360  if (OutputPath == "-")
361  OutputPath = "";
362  AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
363  /*ShowDepth=*/false);
364  }
365 
366  if (DepOpts.PrintShowIncludes) {
367  AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
368  /*ShowDepth=*/true, /*MSStyle=*/true);
369  }
370 }
371 
373  // Set up the module path, including the hash for the
374  // module-creation options.
375  SmallString<256> SpecificModuleCache(
376  getHeaderSearchOpts().ModuleCachePath);
377  if (!getHeaderSearchOpts().DisableModuleHash)
378  llvm::sys::path::append(SpecificModuleCache,
379  getInvocation().getModuleHash());
380  return SpecificModuleCache.str();
381 }
382 
383 // ASTContext
384 
389  PP.getBuiltinInfo());
391 }
392 
393 // ExternalASTSource
394 
396  StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors,
397  void *DeserializationListener, bool OwnDeserializationListener) {
398  bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
399  ModuleManager = createPCHExternalASTSource(
400  Path, getHeaderSearchOpts().Sysroot, DisablePCHValidation,
401  AllowPCHWithCompilerErrors, getPreprocessor(), getASTContext(),
402  getPCHContainerReader(), DeserializationListener,
403  OwnDeserializationListener, Preamble,
404  getFrontendOpts().UseGlobalModuleIndex);
405 }
406 
408  StringRef Path, StringRef Sysroot, bool DisablePCHValidation,
409  bool AllowPCHWithCompilerErrors, Preprocessor &PP, ASTContext &Context,
410  const PCHContainerReader &PCHContainerRdr,
411  void *DeserializationListener, bool OwnDeserializationListener,
412  bool Preamble, bool UseGlobalModuleIndex) {
414 
416  PP, Context, PCHContainerRdr, Sysroot.empty() ? "" : Sysroot.data(),
417  DisablePCHValidation, AllowPCHWithCompilerErrors,
418  /*AllowConfigurationMismatch*/ false, HSOpts.ModulesValidateSystemHeaders,
419  UseGlobalModuleIndex));
420 
421  // We need the external source to be set up before we read the AST, because
422  // eagerly-deserialized declarations may use it.
423  Context.setExternalSource(Reader.get());
424 
425  Reader->setDeserializationListener(
426  static_cast<ASTDeserializationListener *>(DeserializationListener),
427  /*TakeOwnership=*/OwnDeserializationListener);
428  switch (Reader->ReadAST(Path,
429  Preamble ? serialization::MK_Preamble
431  SourceLocation(),
433  case ASTReader::Success:
434  // Set the predefines buffer as suggested by the PCH reader. Typically, the
435  // predefines buffer will be empty.
436  PP.setPredefines(Reader->getSuggestedPredefines());
437  return Reader;
438 
439  case ASTReader::Failure:
440  // Unrecoverable failure: don't even try to process the input file.
441  break;
442 
443  case ASTReader::Missing:
448  // No suitable PCH file could be found. Return an error.
449  break;
450  }
451 
452  Context.setExternalSource(nullptr);
453  return nullptr;
454 }
455 
456 // Code Completion
457 
459  const std::string &Filename,
460  unsigned Line,
461  unsigned Column) {
462  // Tell the source manager to chop off the given file at a specific
463  // line and column.
464  const FileEntry *Entry = PP.getFileManager().getFile(Filename);
465  if (!Entry) {
466  PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
467  << Filename;
468  return true;
469  }
470 
471  // Truncate the named file at the given line/column.
472  PP.SetCodeCompletionPoint(Entry, Line, Column);
473  return false;
474 }
475 
478  if (!CompletionConsumer) {
481  Loc.FileName, Loc.Line, Loc.Column,
482  getFrontendOpts().CodeCompleteOpts,
483  llvm::outs()));
484  if (!CompletionConsumer)
485  return;
487  Loc.Line, Loc.Column)) {
488  setCodeCompletionConsumer(nullptr);
489  return;
490  }
491 
492  if (CompletionConsumer->isOutputBinary() &&
493  llvm::sys::ChangeStdoutToBinary()) {
494  getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
495  setCodeCompletionConsumer(nullptr);
496  }
497 }
498 
500  FrontendTimerGroup.reset(new llvm::TimerGroup("Clang front-end time report"));
501  FrontendTimer.reset(
502  new llvm::Timer("Clang front-end timer", *FrontendTimerGroup));
503 }
504 
507  StringRef Filename,
508  unsigned Line,
509  unsigned Column,
510  const CodeCompleteOptions &Opts,
511  raw_ostream &OS) {
512  if (EnableCodeCompletion(PP, Filename, Line, Column))
513  return nullptr;
514 
515  // Set up the creation routine for code-completion.
516  return new PrintingCodeCompleteConsumer(Opts, OS);
517 }
518 
520  CodeCompleteConsumer *CompletionConsumer) {
521  TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
522  TUKind, CompletionConsumer));
523 }
524 
525 // Output Files
526 
527 void CompilerInstance::addOutputFile(OutputFile &&OutFile) {
528  assert(OutFile.OS && "Attempt to add empty stream to output list!");
529  OutputFiles.push_back(std::move(OutFile));
530 }
531 
532 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
533  for (OutputFile &OF : OutputFiles) {
534  // Manually close the stream before we rename it.
535  OF.OS.reset();
536 
537  if (!OF.TempFilename.empty()) {
538  if (EraseFiles) {
539  llvm::sys::fs::remove(OF.TempFilename);
540  } else {
541  SmallString<128> NewOutFile(OF.Filename);
542 
543  // If '-working-directory' was passed, the output filename should be
544  // relative to that.
545  FileMgr->FixupRelativePath(NewOutFile);
546  if (std::error_code ec =
547  llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
548  getDiagnostics().Report(diag::err_unable_to_rename_temp)
549  << OF.TempFilename << OF.Filename << ec.message();
550 
551  llvm::sys::fs::remove(OF.TempFilename);
552  }
553  }
554  } else if (!OF.Filename.empty() && EraseFiles)
555  llvm::sys::fs::remove(OF.Filename);
556 
557  }
558  OutputFiles.clear();
559  NonSeekStream.reset();
560 }
561 
562 raw_pwrite_stream *
563 CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
564  StringRef Extension) {
565  return createOutputFile(getFrontendOpts().OutputFile, Binary,
566  /*RemoveFileOnSignal=*/true, InFile, Extension,
567  /*UseTemporary=*/true);
568 }
569 
570 llvm::raw_null_ostream *CompilerInstance::createNullOutputFile() {
571  auto OS = llvm::make_unique<llvm::raw_null_ostream>();
572  llvm::raw_null_ostream *Ret = OS.get();
573  addOutputFile(OutputFile("", "", std::move(OS)));
574  return Ret;
575 }
576 
577 raw_pwrite_stream *
578 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
579  bool RemoveFileOnSignal, StringRef InFile,
580  StringRef Extension, bool UseTemporary,
581  bool CreateMissingDirectories) {
582  std::string OutputPathName, TempPathName;
583  std::error_code EC;
584  std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
585  OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
586  UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
587  if (!OS) {
588  getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
589  << EC.message();
590  return nullptr;
591  }
592 
593  raw_pwrite_stream *Ret = OS.get();
594  // Add the output file -- but don't try to remove "-", since this means we are
595  // using stdin.
596  addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
597  TempPathName, std::move(OS)));
598 
599  return Ret;
600 }
601 
602 std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
603  StringRef OutputPath, std::error_code &Error, bool Binary,
604  bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
605  bool UseTemporary, bool CreateMissingDirectories,
606  std::string *ResultPathName, std::string *TempPathName) {
607  assert((!CreateMissingDirectories || UseTemporary) &&
608  "CreateMissingDirectories is only allowed when using temporary files");
609 
610  std::string OutFile, TempFile;
611  if (!OutputPath.empty()) {
612  OutFile = OutputPath;
613  } else if (InFile == "-") {
614  OutFile = "-";
615  } else if (!Extension.empty()) {
616  SmallString<128> Path(InFile);
617  llvm::sys::path::replace_extension(Path, Extension);
618  OutFile = Path.str();
619  } else {
620  OutFile = "-";
621  }
622 
623  std::unique_ptr<llvm::raw_fd_ostream> OS;
624  std::string OSFile;
625 
626  if (UseTemporary) {
627  if (OutFile == "-")
628  UseTemporary = false;
629  else {
630  llvm::sys::fs::file_status Status;
631  llvm::sys::fs::status(OutputPath, Status);
632  if (llvm::sys::fs::exists(Status)) {
633  // Fail early if we can't write to the final destination.
634  if (!llvm::sys::fs::can_write(OutputPath))
635  return nullptr;
636 
637  // Don't use a temporary if the output is a special file. This handles
638  // things like '-o /dev/null'
639  if (!llvm::sys::fs::is_regular_file(Status))
640  UseTemporary = false;
641  }
642  }
643  }
644 
645  if (UseTemporary) {
646  // Create a temporary file.
647  SmallString<128> TempPath;
648  TempPath = OutFile;
649  TempPath += "-%%%%%%%%";
650  int fd;
651  std::error_code EC =
652  llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
653 
654  if (CreateMissingDirectories &&
655  EC == llvm::errc::no_such_file_or_directory) {
656  StringRef Parent = llvm::sys::path::parent_path(OutputPath);
657  EC = llvm::sys::fs::create_directories(Parent);
658  if (!EC) {
659  EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
660  }
661  }
662 
663  if (!EC) {
664  OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
665  OSFile = TempFile = TempPath.str();
666  }
667  // If we failed to create the temporary, fallback to writing to the file
668  // directly. This handles the corner case where we cannot write to the
669  // directory, but can write to the file.
670  }
671 
672  if (!OS) {
673  OSFile = OutFile;
674  OS.reset(new llvm::raw_fd_ostream(
675  OSFile, Error,
676  (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
677  if (Error)
678  return nullptr;
679  }
680 
681  // Make sure the out stream file gets removed if we crash.
682  if (RemoveFileOnSignal)
683  llvm::sys::RemoveFileOnSignal(OSFile);
684 
685  if (ResultPathName)
686  *ResultPathName = OutFile;
687  if (TempPathName)
688  *TempPathName = TempFile;
689 
690  if (!Binary || OS->supportsSeeking())
691  return std::move(OS);
692 
693  auto B = llvm::make_unique<llvm::buffer_ostream>(*OS);
694  assert(!NonSeekStream);
695  NonSeekStream = std::move(OS);
696  return std::move(B);
697 }
698 
699 // Initialization Utilities
700 
702  return InitializeSourceManager(Input, getDiagnostics(),
704  getFrontendOpts());
705 }
706 
708  DiagnosticsEngine &Diags,
709  FileManager &FileMgr,
711  const FrontendOptions &Opts) {
714 
715  if (Input.isBuffer()) {
716  SourceMgr.setMainFileID(SourceMgr.createFileID(
717  std::unique_ptr<llvm::MemoryBuffer>(Input.getBuffer()), Kind));
718  assert(!SourceMgr.getMainFileID().isInvalid() &&
719  "Couldn't establish MainFileID!");
720  return true;
721  }
722 
723  StringRef InputFile = Input.getFile();
724 
725  // Figure out where to get and map in the main file.
726  if (InputFile != "-") {
727  const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
728  if (!File) {
729  Diags.Report(diag::err_fe_error_reading) << InputFile;
730  return false;
731  }
732 
733  // The natural SourceManager infrastructure can't currently handle named
734  // pipes, but we would at least like to accept them for the main
735  // file. Detect them here, read them with the volatile flag so FileMgr will
736  // pick up the correct size, and simply override their contents as we do for
737  // STDIN.
738  if (File->isNamedPipe()) {
739  auto MB = FileMgr.getBufferForFile(File, /*isVolatile=*/true);
740  if (MB) {
741  // Create a new virtual file that will have the correct size.
742  File = FileMgr.getVirtualFile(InputFile, (*MB)->getBufferSize(), 0);
743  SourceMgr.overrideFileContents(File, std::move(*MB));
744  } else {
745  Diags.Report(diag::err_cannot_open_file) << InputFile
746  << MB.getError().message();
747  return false;
748  }
749  }
750 
751  SourceMgr.setMainFileID(
752  SourceMgr.createFileID(File, SourceLocation(), Kind));
753  } else {
754  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> SBOrErr =
755  llvm::MemoryBuffer::getSTDIN();
756  if (std::error_code EC = SBOrErr.getError()) {
757  Diags.Report(diag::err_fe_error_reading_stdin) << EC.message();
758  return false;
759  }
760  std::unique_ptr<llvm::MemoryBuffer> SB = std::move(SBOrErr.get());
761 
762  const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
763  SB->getBufferSize(), 0);
764  SourceMgr.setMainFileID(
765  SourceMgr.createFileID(File, SourceLocation(), Kind));
766  SourceMgr.overrideFileContents(File, std::move(SB));
767  }
768 
769  assert(!SourceMgr.getMainFileID().isInvalid() &&
770  "Couldn't establish MainFileID!");
771  return true;
772 }
773 
774 // High-Level Operations
775 
777  assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
778  assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
779  assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
780 
781  // FIXME: Take this as an argument, once all the APIs we used have moved to
782  // taking it as an input instead of hard-coding llvm::errs.
783  raw_ostream &OS = llvm::errs();
784 
785  // Create the target instance.
787  getInvocation().TargetOpts));
788  if (!hasTarget())
789  return false;
790 
791  // Inform the target of the language options.
792  //
793  // FIXME: We shouldn't need to do this, the target should be immutable once
794  // created. This complexity should be lifted elsewhere.
796 
797  // rewriter project will change target built-in bool type from its default.
798  if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
800 
801  // Validate/process some options.
803  OS << "clang -cc1 version " CLANG_VERSION_STRING
804  << " based upon " << BACKEND_PACKAGE_STRING
805  << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
806 
807  if (getFrontendOpts().ShowTimers)
809 
810  if (getFrontendOpts().ShowStats)
811  llvm::EnableStatistics();
812 
813  for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
814  // Reset the ID tables if we are reusing the SourceManager and parsing
815  // regular files.
816  if (hasSourceManager() && !Act.isModelParsingAction())
818 
819  if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
820  Act.Execute();
821  Act.EndSourceFile();
822  }
823  }
824 
825  // Notify the diagnostic client that all files were processed.
827 
828  if (getDiagnosticOpts().ShowCarets) {
829  // We can have multiple diagnostics sharing one diagnostic client.
830  // Get the total number of warnings/errors from the client.
831  unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
832  unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
833 
834  if (NumWarnings)
835  OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
836  if (NumWarnings && NumErrors)
837  OS << " and ";
838  if (NumErrors)
839  OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
840  if (NumWarnings || NumErrors)
841  OS << " generated.\n";
842  }
843 
846  OS << "\n";
847  }
848 
849  return !getDiagnostics().getClient()->getNumErrors();
850 }
851 
852 /// \brief Determine the appropriate source input kind based on language
853 /// options.
855  if (LangOpts.OpenCL)
856  return IK_OpenCL;
857  if (LangOpts.CUDA)
858  return IK_CUDA;
859  if (LangOpts.ObjC1)
860  return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
861  return LangOpts.CPlusPlus? IK_CXX : IK_C;
862 }
863 
864 /// \brief Compile a module file for the given module, using the options
865 /// provided by the importing compiler instance. Returns true if the module
866 /// was built without errors.
867 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
868  SourceLocation ImportLoc,
869  Module *Module,
870  StringRef ModuleFileName) {
871  ModuleMap &ModMap
872  = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
873 
874  // Construct a compiler invocation for creating this module.
876  (new CompilerInvocation(ImportingInstance.getInvocation()));
877 
878  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
879 
880  // For any options that aren't intended to affect how a module is built,
881  // reset them to their default values.
882  Invocation->getLangOpts()->resetNonModularOptions();
883  PPOpts.resetNonModularOptions();
884 
885  // Remove any macro definitions that are explicitly ignored by the module.
886  // They aren't supposed to affect how the module is built anyway.
887  const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
888  PPOpts.Macros.erase(
889  std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
890  [&HSOpts](const std::pair<std::string, bool> &def) {
891  StringRef MacroDef = def.first;
892  return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
893  }),
894  PPOpts.Macros.end());
895 
896  // Note the name of the module we're building.
897  Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
898 
899  // Make sure that the failed-module structure has been allocated in
900  // the importing instance, and propagate the pointer to the newly-created
901  // instance.
902  PreprocessorOptions &ImportingPPOpts
903  = ImportingInstance.getInvocation().getPreprocessorOpts();
904  if (!ImportingPPOpts.FailedModules)
906  PPOpts.FailedModules = ImportingPPOpts.FailedModules;
907 
908  // If there is a module map file, build the module using the module map.
909  // Set up the inputs/outputs so that we build the module from its umbrella
910  // header.
911  FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
912  FrontendOpts.OutputFile = ModuleFileName.str();
913  FrontendOpts.DisableFree = false;
914  FrontendOpts.GenerateGlobalModuleIndex = false;
915  FrontendOpts.Inputs.clear();
916  InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
917 
918  // Don't free the remapped file buffers; they are owned by our caller.
919  PPOpts.RetainRemappedFileBuffers = true;
920 
921  Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
922  assert(ImportingInstance.getInvocation().getModuleHash() ==
923  Invocation->getModuleHash() && "Module hash mismatch!");
924 
925  // Construct a compiler instance that will be used to actually create the
926  // module.
927  CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
928  /*BuildingModule=*/true);
929  Instance.setInvocation(&*Invocation);
930 
931  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
932  ImportingInstance.getDiagnosticClient()),
933  /*ShouldOwnClient=*/true);
934 
935  Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
936 
937  // Note that this module is part of the module build stack, so that we
938  // can detect cycles in the module graph.
939  Instance.setFileManager(&ImportingInstance.getFileManager());
940  Instance.createSourceManager(Instance.getFileManager());
941  SourceManager &SourceMgr = Instance.getSourceManager();
942  SourceMgr.setModuleBuildStack(
943  ImportingInstance.getSourceManager().getModuleBuildStack());
944  SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
945  FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
946 
947  // If we're collecting module dependencies, we need to share a collector
948  // between all of the module CompilerInstances.
949  Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
950 
951  // Get or create the module map that we'll use to build this module.
952  std::string InferredModuleMapContent;
953  if (const FileEntry *ModuleMapFile =
954  ModMap.getContainingModuleMapFile(Module)) {
955  // Use the module map where this module resides.
956  FrontendOpts.Inputs.emplace_back(ModuleMapFile->getName(), IK);
957  } else {
958  SmallString<128> FakeModuleMapFile(Module->Directory->getName());
959  llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
960  FrontendOpts.Inputs.emplace_back(FakeModuleMapFile, IK);
961 
962  llvm::raw_string_ostream OS(InferredModuleMapContent);
963  Module->print(OS);
964  OS.flush();
965 
966  std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
967  llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
968  ModuleMapFile = Instance.getFileManager().getVirtualFile(
969  FakeModuleMapFile, InferredModuleMapContent.size(), 0);
970  SourceMgr.overrideFileContents(ModuleMapFile, std::move(ModuleMapBuffer));
971  }
972 
973  // Construct a module-generating action. Passing through the module map is
974  // safe because the FileManager is shared between the compiler instances.
975  GenerateModuleAction CreateModuleAction(
976  ModMap.getModuleMapFileForUniquing(Module), Module->IsSystem);
977 
978  ImportingInstance.getDiagnostics().Report(ImportLoc,
979  diag::remark_module_build)
980  << Module->Name << ModuleFileName;
981 
982  // Execute the action to actually build the module in-place. Use a separate
983  // thread so that we get a stack large enough.
984  const unsigned ThreadStackSize = 8 << 20;
985  llvm::CrashRecoveryContext CRC;
986  CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
987  ThreadStackSize);
988 
989  ImportingInstance.getDiagnostics().Report(ImportLoc,
990  diag::remark_module_build_done)
991  << Module->Name;
992 
993  // Delete the temporary module map file.
994  // FIXME: Even though we're executing under crash protection, it would still
995  // be nice to do this with RemoveFileOnSignal when we can. However, that
996  // doesn't make sense for all clients, so clean this up manually.
997  Instance.clearOutputFiles(/*EraseFiles=*/true);
998 
999  // We've rebuilt a module. If we're allowed to generate or update the global
1000  // module index, record that fact in the importing compiler instance.
1001  if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
1002  ImportingInstance.setBuildGlobalModuleIndex(true);
1003  }
1004 
1005  return !Instance.getDiagnostics().hasErrorOccurred();
1006 }
1007 
1008 static bool compileAndLoadModule(CompilerInstance &ImportingInstance,
1009  SourceLocation ImportLoc,
1010  SourceLocation ModuleNameLoc, Module *Module,
1011  StringRef ModuleFileName) {
1012  DiagnosticsEngine &Diags = ImportingInstance.getDiagnostics();
1013 
1014  auto diagnoseBuildFailure = [&] {
1015  Diags.Report(ModuleNameLoc, diag::err_module_not_built)
1016  << Module->Name << SourceRange(ImportLoc, ModuleNameLoc);
1017  };
1018 
1019  // FIXME: have LockFileManager return an error_code so that we can
1020  // avoid the mkdir when the directory already exists.
1021  StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
1022  llvm::sys::fs::create_directories(Dir);
1023 
1024  while (1) {
1025  unsigned ModuleLoadCapabilities = ASTReader::ARR_Missing;
1026  llvm::LockFileManager Locked(ModuleFileName);
1027  switch (Locked) {
1028  case llvm::LockFileManager::LFS_Error:
1029  Diags.Report(ModuleNameLoc, diag::err_module_lock_failure)
1030  << Module->Name;
1031  return false;
1032 
1033  case llvm::LockFileManager::LFS_Owned:
1034  // We're responsible for building the module ourselves.
1035  if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
1036  ModuleFileName)) {
1037  diagnoseBuildFailure();
1038  return false;
1039  }
1040  break;
1041 
1042  case llvm::LockFileManager::LFS_Shared:
1043  // Someone else is responsible for building the module. Wait for them to
1044  // finish.
1045  switch (Locked.waitForUnlock()) {
1046  case llvm::LockFileManager::Res_Success:
1047  ModuleLoadCapabilities |= ASTReader::ARR_OutOfDate;
1048  break;
1049  case llvm::LockFileManager::Res_OwnerDied:
1050  continue; // try again to get the lock.
1051  case llvm::LockFileManager::Res_Timeout:
1052  Diags.Report(ModuleNameLoc, diag::err_module_lock_timeout)
1053  << Module->Name;
1054  // Clear the lock file so that future invokations can make progress.
1055  Locked.unsafeRemoveLockFile();
1056  return false;
1057  }
1058  break;
1059  }
1060 
1061  // Try to read the module file, now that we've compiled it.
1062  ASTReader::ASTReadResult ReadResult =
1063  ImportingInstance.getModuleManager()->ReadAST(
1064  ModuleFileName, serialization::MK_ImplicitModule, ImportLoc,
1065  ModuleLoadCapabilities);
1066 
1067  if (ReadResult == ASTReader::OutOfDate &&
1068  Locked == llvm::LockFileManager::LFS_Shared) {
1069  // The module may be out of date in the presence of file system races,
1070  // or if one of its imports depends on header search paths that are not
1071  // consistent with this ImportingInstance. Try again...
1072  continue;
1073  } else if (ReadResult == ASTReader::Missing) {
1074  diagnoseBuildFailure();
1075  } else if (ReadResult != ASTReader::Success &&
1076  !Diags.hasErrorOccurred()) {
1077  // The ASTReader didn't diagnose the error, so conservatively report it.
1078  diagnoseBuildFailure();
1079  }
1080  return ReadResult == ASTReader::Success;
1081  }
1082 }
1083 
1084 /// \brief Diagnose differences between the current definition of the given
1085 /// configuration macro and the definition provided on the command line.
1086 static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
1087  Module *Mod, SourceLocation ImportLoc) {
1088  IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
1090 
1091  // If this identifier has never had a macro definition, then it could
1092  // not have changed.
1093  if (!Id->hadMacroDefinition())
1094  return;
1095  auto *LatestLocalMD = PP.getLocalMacroDirectiveHistory(Id);
1096 
1097  // Find the macro definition from the command line.
1098  MacroInfo *CmdLineDefinition = nullptr;
1099  for (auto *MD = LatestLocalMD; MD; MD = MD->getPrevious()) {
1100  // We only care about the predefines buffer.
1101  FileID FID = SourceMgr.getFileID(MD->getLocation());
1102  if (FID.isInvalid() || FID != PP.getPredefinesFileID())
1103  continue;
1104  if (auto *DMD = dyn_cast<DefMacroDirective>(MD))
1105  CmdLineDefinition = DMD->getMacroInfo();
1106  break;
1107  }
1108 
1109  auto *CurrentDefinition = PP.getMacroInfo(Id);
1110  if (CurrentDefinition == CmdLineDefinition) {
1111  // Macro matches. Nothing to do.
1112  } else if (!CurrentDefinition) {
1113  // This macro was defined on the command line, then #undef'd later.
1114  // Complain.
1115  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1116  << true << ConfigMacro << Mod->getFullModuleName();
1117  auto LatestDef = LatestLocalMD->getDefinition();
1118  assert(LatestDef.isUndefined() &&
1119  "predefined macro went away with no #undef?");
1120  PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
1121  << true;
1122  return;
1123  } else if (!CmdLineDefinition) {
1124  // There was no definition for this macro in the predefines buffer,
1125  // but there was a local definition. Complain.
1126  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1127  << false << ConfigMacro << Mod->getFullModuleName();
1128  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1129  diag::note_module_def_undef_here)
1130  << false;
1131  } else if (!CurrentDefinition->isIdenticalTo(*CmdLineDefinition, PP,
1132  /*Syntactically=*/true)) {
1133  // The macro definitions differ.
1134  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
1135  << false << ConfigMacro << Mod->getFullModuleName();
1136  PP.Diag(CurrentDefinition->getDefinitionLoc(),
1137  diag::note_module_def_undef_here)
1138  << false;
1139  }
1140 }
1141 
1142 /// \brief Write a new timestamp file with the given path.
1143 static void writeTimestampFile(StringRef TimestampFile) {
1144  std::error_code EC;
1145  llvm::raw_fd_ostream Out(TimestampFile.str(), EC, llvm::sys::fs::F_None);
1146 }
1147 
1148 /// \brief Prune the module cache of modules that haven't been accessed in
1149 /// a long time.
1150 static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1151  struct stat StatBuf;
1152  llvm::SmallString<128> TimestampFile;
1153  TimestampFile = HSOpts.ModuleCachePath;
1154  llvm::sys::path::append(TimestampFile, "modules.timestamp");
1155 
1156  // Try to stat() the timestamp file.
1157  if (::stat(TimestampFile.c_str(), &StatBuf)) {
1158  // If the timestamp file wasn't there, create one now.
1159  if (errno == ENOENT) {
1160  writeTimestampFile(TimestampFile);
1161  }
1162  return;
1163  }
1164 
1165  // Check whether the time stamp is older than our pruning interval.
1166  // If not, do nothing.
1167  time_t TimeStampModTime = StatBuf.st_mtime;
1168  time_t CurrentTime = time(nullptr);
1169  if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1170  return;
1171 
1172  // Write a new timestamp file so that nobody else attempts to prune.
1173  // There is a benign race condition here, if two Clang instances happen to
1174  // notice at the same time that the timestamp is out-of-date.
1175  writeTimestampFile(TimestampFile);
1176 
1177  // Walk the entire module cache, looking for unused module files and module
1178  // indices.
1179  std::error_code EC;
1180  SmallString<128> ModuleCachePathNative;
1181  llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1182  for (llvm::sys::fs::directory_iterator Dir(ModuleCachePathNative, EC), DirEnd;
1183  Dir != DirEnd && !EC; Dir.increment(EC)) {
1184  // If we don't have a directory, there's nothing to look into.
1185  if (!llvm::sys::fs::is_directory(Dir->path()))
1186  continue;
1187 
1188  // Walk all of the files within this directory.
1189  for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1190  File != FileEnd && !EC; File.increment(EC)) {
1191  // We only care about module and global module index files.
1192  StringRef Extension = llvm::sys::path::extension(File->path());
1193  if (Extension != ".pcm" && Extension != ".timestamp" &&
1194  llvm::sys::path::filename(File->path()) != "modules.idx")
1195  continue;
1196 
1197  // Look at this file. If we can't stat it, there's nothing interesting
1198  // there.
1199  if (::stat(File->path().c_str(), &StatBuf))
1200  continue;
1201 
1202  // If the file has been used recently enough, leave it there.
1203  time_t FileAccessTime = StatBuf.st_atime;
1204  if (CurrentTime - FileAccessTime <=
1205  time_t(HSOpts.ModuleCachePruneAfter)) {
1206  continue;
1207  }
1208 
1209  // Remove the file.
1210  llvm::sys::fs::remove(File->path());
1211 
1212  // Remove the timestamp file.
1213  std::string TimpestampFilename = File->path() + ".timestamp";
1214  llvm::sys::fs::remove(TimpestampFilename);
1215  }
1216 
1217  // If we removed all of the files in the directory, remove the directory
1218  // itself.
1219  if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1220  llvm::sys::fs::directory_iterator() && !EC)
1221  llvm::sys::fs::remove(Dir->path());
1222  }
1223 }
1224 
1226  if (!ModuleManager) {
1227  if (!hasASTContext())
1228  createASTContext();
1229 
1230  // If we're implicitly building modules but not currently recursively
1231  // building a module, check whether we need to prune the module cache.
1232  if (getLangOpts().ImplicitModules &&
1233  getSourceManager().getModuleBuildStack().empty() &&
1234  getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1235  getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1237  }
1238 
1240  std::string Sysroot = HSOpts.Sysroot;
1241  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1242  std::unique_ptr<llvm::Timer> ReadTimer;
1243  if (FrontendTimerGroup)
1244  ReadTimer = llvm::make_unique<llvm::Timer>("Reading modules",
1245  *FrontendTimerGroup);
1246  ModuleManager = new ASTReader(
1248  Sysroot.empty() ? "" : Sysroot.c_str(), PPOpts.DisablePCHValidation,
1249  /*AllowASTWithCompilerErrors=*/false,
1250  /*AllowConfigurationMismatch=*/false,
1253  std::move(ReadTimer));
1254  if (hasASTConsumer()) {
1255  ModuleManager->setDeserializationListener(
1256  getASTConsumer().GetASTDeserializationListener());
1258  getASTConsumer().GetASTMutationListener());
1259  }
1260  getASTContext().setExternalSource(ModuleManager);
1261  if (hasSema())
1262  ModuleManager->InitializeSema(getSema());
1263  if (hasASTConsumer())
1264  ModuleManager->StartTranslationUnit(&getASTConsumer());
1265  }
1266 }
1267 
1268 bool CompilerInstance::loadModuleFile(StringRef FileName) {
1269  llvm::Timer Timer;
1270  if (FrontendTimerGroup)
1271  Timer.init("Preloading " + FileName.str(), *FrontendTimerGroup);
1272  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1273 
1274  // Helper to recursively read the module names for all modules we're adding.
1275  // We mark these as known and redirect any attempt to load that module to
1276  // the files we were handed.
1277  struct ReadModuleNames : ASTReaderListener {
1278  CompilerInstance &CI;
1279  std::vector<StringRef> ModuleFileStack;
1280  std::vector<StringRef> ModuleNameStack;
1281  bool Failed;
1282  bool TopFileIsModule;
1283 
1284  ReadModuleNames(CompilerInstance &CI)
1285  : CI(CI), Failed(false), TopFileIsModule(false) {}
1286 
1287  bool needsImportVisitation() const override { return true; }
1288 
1289  void visitImport(StringRef FileName) override {
1290  if (!CI.ExplicitlyLoadedModuleFiles.insert(FileName).second) {
1291  if (ModuleFileStack.size() == 0)
1292  TopFileIsModule = true;
1293  return;
1294  }
1295 
1296  ModuleFileStack.push_back(FileName);
1297  ModuleNameStack.push_back(StringRef());
1299  CI.getPCHContainerReader(),
1300  *this)) {
1301  CI.getDiagnostics().Report(
1303  ? diag::err_module_file_invalid
1304  : diag::err_module_file_not_found)
1305  << FileName;
1306  for (int I = ModuleFileStack.size() - 2; I >= 0; --I)
1308  diag::note_module_file_imported_by)
1309  << ModuleFileStack[I]
1310  << !ModuleNameStack[I].empty() << ModuleNameStack[I];
1311  Failed = true;
1312  }
1313  ModuleNameStack.pop_back();
1314  ModuleFileStack.pop_back();
1315  }
1316 
1317  void ReadModuleName(StringRef ModuleName) override {
1318  if (ModuleFileStack.size() == 1)
1319  TopFileIsModule = true;
1320  ModuleNameStack.back() = ModuleName;
1321 
1322  auto &ModuleFile = CI.ModuleFileOverrides[ModuleName];
1323  if (!ModuleFile.empty() &&
1324  CI.getFileManager().getFile(ModuleFile) !=
1325  CI.getFileManager().getFile(ModuleFileStack.back()))
1327  diag::err_conflicting_module_files)
1328  << ModuleName << ModuleFile << ModuleFileStack.back();
1329  ModuleFile = ModuleFileStack.back();
1330  }
1331  } RMN(*this);
1332 
1333  // If we don't already have an ASTReader, create one now.
1334  if (!ModuleManager)
1336 
1337  // Tell the module manager about this module file.
1338  if (getModuleManager()->getModuleManager().addKnownModuleFile(FileName)) {
1339  getDiagnostics().Report(SourceLocation(), diag::err_module_file_not_found)
1340  << FileName;
1341  return false;
1342  }
1343 
1344  // Build our mapping of module names to module files from this file
1345  // and its imports.
1346  RMN.visitImport(FileName);
1347 
1348  if (RMN.Failed)
1349  return false;
1350 
1351  // If we never found a module name for the top file, then it's not a module,
1352  // it's a PCH or preamble or something.
1353  if (!RMN.TopFileIsModule) {
1354  getDiagnostics().Report(SourceLocation(), diag::err_module_file_not_module)
1355  << FileName;
1356  return false;
1357  }
1358 
1359  return true;
1360 }
1361 
1364  ModuleIdPath Path,
1366  bool IsInclusionDirective) {
1367  // Determine what file we're searching from.
1368  StringRef ModuleName = Path[0].first->getName();
1369  SourceLocation ModuleNameLoc = Path[0].second;
1370 
1371  // If we've already handled this import, just return the cached result.
1372  // This one-element cache is important to eliminate redundant diagnostics
1373  // when both the preprocessor and parser see the same import declaration.
1374  if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1375  // Make the named module visible.
1376  if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule &&
1377  ModuleName != getLangOpts().ImplementationOfModule)
1378  ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1379  ImportLoc);
1380  return LastModuleImportResult;
1381  }
1382 
1383  clang::Module *Module = nullptr;
1384 
1385  // If we don't already have information on this module, load the module now.
1386  llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1387  = KnownModules.find(Path[0].first);
1388  if (Known != KnownModules.end()) {
1389  // Retrieve the cached top-level module.
1390  Module = Known->second;
1391  } else if (ModuleName == getLangOpts().CurrentModule ||
1392  ModuleName == getLangOpts().ImplementationOfModule) {
1393  // This is the module we're building.
1394  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1395  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1396  } else {
1397  // Search for a module with the given name.
1398  Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1399  if (!Module) {
1400  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1401  << ModuleName
1402  << SourceRange(ImportLoc, ModuleNameLoc);
1403  ModuleBuildFailed = true;
1404  return ModuleLoadResult();
1405  }
1406 
1407  auto Override = ModuleFileOverrides.find(ModuleName);
1408  bool Explicit = Override != ModuleFileOverrides.end();
1409  if (!Explicit && !getLangOpts().ImplicitModules) {
1410  getDiagnostics().Report(ModuleNameLoc, diag::err_module_build_disabled)
1411  << ModuleName;
1412  ModuleBuildFailed = true;
1413  return ModuleLoadResult();
1414  }
1415 
1416  std::string ModuleFileName =
1417  Explicit ? Override->second
1418  : PP->getHeaderSearchInfo().getModuleFileName(Module);
1419 
1420  // If we don't already have an ASTReader, create one now.
1421  if (!ModuleManager)
1423 
1424  if (TheDependencyFileGenerator)
1425  TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1426 
1427  if (ModuleDepCollector)
1428  ModuleDepCollector->attachToASTReader(*ModuleManager);
1429 
1430  for (auto &Listener : DependencyCollectors)
1431  Listener->attachToASTReader(*ModuleManager);
1432 
1433  llvm::Timer Timer;
1434  if (FrontendTimerGroup)
1435  Timer.init("Loading " + ModuleFileName, *FrontendTimerGroup);
1436  llvm::TimeRegion TimeLoading(FrontendTimerGroup ? &Timer : nullptr);
1437 
1438  // Try to load the module file.
1439  unsigned ARRFlags =
1441  switch (ModuleManager->ReadAST(ModuleFileName,
1444  ImportLoc, ARRFlags)) {
1445  case ASTReader::Success:
1446  break;
1447 
1448  case ASTReader::OutOfDate:
1449  case ASTReader::Missing: {
1450  if (Explicit) {
1451  // ReadAST has already complained for us.
1453  KnownModules[Path[0].first] = nullptr;
1454  return ModuleLoadResult();
1455  }
1456 
1457  // The module file is missing or out-of-date. Build it.
1458  assert(Module && "missing module file");
1459  // Check whether there is a cycle in the module graph.
1461  ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1462  for (; Pos != PosEnd; ++Pos) {
1463  if (Pos->first == ModuleName)
1464  break;
1465  }
1466 
1467  if (Pos != PosEnd) {
1468  SmallString<256> CyclePath;
1469  for (; Pos != PosEnd; ++Pos) {
1470  CyclePath += Pos->first;
1471  CyclePath += " -> ";
1472  }
1473  CyclePath += ModuleName;
1474 
1475  getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1476  << ModuleName << CyclePath;
1477  return ModuleLoadResult();
1478  }
1479 
1480  // Check whether we have already attempted to build this module (but
1481  // failed).
1482  if (getPreprocessorOpts().FailedModules &&
1483  getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1484  getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1485  << ModuleName
1486  << SourceRange(ImportLoc, ModuleNameLoc);
1487  ModuleBuildFailed = true;
1488  return ModuleLoadResult();
1489  }
1490 
1491  // Try to compile and then load the module.
1492  if (!compileAndLoadModule(*this, ImportLoc, ModuleNameLoc, Module,
1493  ModuleFileName)) {
1494  assert(getDiagnostics().hasErrorOccurred() &&
1495  "undiagnosed error in compileAndLoadModule");
1496  if (getPreprocessorOpts().FailedModules)
1497  getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1498  KnownModules[Path[0].first] = nullptr;
1499  ModuleBuildFailed = true;
1500  return ModuleLoadResult();
1501  }
1502 
1503  // Okay, we've rebuilt and now loaded the module.
1504  break;
1505  }
1506 
1509  case ASTReader::HadErrors:
1511  // FIXME: The ASTReader will already have complained, but can we showhorn
1512  // that diagnostic information into a more useful form?
1513  KnownModules[Path[0].first] = nullptr;
1514  return ModuleLoadResult();
1515 
1516  case ASTReader::Failure:
1518  // Already complained, but note now that we failed.
1519  KnownModules[Path[0].first] = nullptr;
1520  ModuleBuildFailed = true;
1521  return ModuleLoadResult();
1522  }
1523 
1524  // Cache the result of this top-level module lookup for later.
1525  Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1526  }
1527 
1528  // If we never found the module, fail.
1529  if (!Module)
1530  return ModuleLoadResult();
1531 
1532  // Verify that the rest of the module path actually corresponds to
1533  // a submodule.
1534  if (Path.size() > 1) {
1535  for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1536  StringRef Name = Path[I].first->getName();
1537  clang::Module *Sub = Module->findSubmodule(Name);
1538 
1539  if (!Sub) {
1540  // Attempt to perform typo correction to find a module name that works.
1542  unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1543 
1545  JEnd = Module->submodule_end();
1546  J != JEnd; ++J) {
1547  unsigned ED = Name.edit_distance((*J)->Name,
1548  /*AllowReplacements=*/true,
1549  BestEditDistance);
1550  if (ED <= BestEditDistance) {
1551  if (ED < BestEditDistance) {
1552  Best.clear();
1553  BestEditDistance = ED;
1554  }
1555 
1556  Best.push_back((*J)->Name);
1557  }
1558  }
1559 
1560  // If there was a clear winner, user it.
1561  if (Best.size() == 1) {
1562  getDiagnostics().Report(Path[I].second,
1563  diag::err_no_submodule_suggest)
1564  << Path[I].first << Module->getFullModuleName() << Best[0]
1565  << SourceRange(Path[0].second, Path[I-1].second)
1566  << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1567  Best[0]);
1568 
1569  Sub = Module->findSubmodule(Best[0]);
1570  }
1571  }
1572 
1573  if (!Sub) {
1574  // No submodule by this name. Complain, and don't look for further
1575  // submodules.
1576  getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1577  << Path[I].first << Module->getFullModuleName()
1578  << SourceRange(Path[0].second, Path[I-1].second);
1579  break;
1580  }
1581 
1582  Module = Sub;
1583  }
1584  }
1585 
1586  // Don't make the module visible if we are in the implementation.
1587  if (ModuleName == getLangOpts().ImplementationOfModule)
1588  return ModuleLoadResult(Module, false);
1589 
1590  // Make the named module visible, if it's not already part of the module
1591  // we are parsing.
1592  if (ModuleName != getLangOpts().CurrentModule) {
1593  if (!Module->IsFromModuleFile) {
1594  // We have an umbrella header or directory that doesn't actually include
1595  // all of the headers within the directory it covers. Complain about
1596  // this missing submodule and recover by forgetting that we ever saw
1597  // this submodule.
1598  // FIXME: Should we detect this at module load time? It seems fairly
1599  // expensive (and rare).
1600  getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1601  << Module->getFullModuleName()
1602  << SourceRange(Path.front().second, Path.back().second);
1603 
1604  return ModuleLoadResult(nullptr, true);
1605  }
1606 
1607  // Check whether this module is available.
1608  clang::Module::Requirement Requirement;
1610  if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1611  MissingHeader)) {
1612  if (MissingHeader.FileNameLoc.isValid()) {
1613  getDiagnostics().Report(MissingHeader.FileNameLoc,
1614  diag::err_module_header_missing)
1615  << MissingHeader.IsUmbrella << MissingHeader.FileName;
1616  } else {
1617  getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1618  << Module->getFullModuleName()
1619  << Requirement.second << Requirement.first
1620  << SourceRange(Path.front().second, Path.back().second);
1621  }
1622  LastModuleImportLoc = ImportLoc;
1623  LastModuleImportResult = ModuleLoadResult();
1624  return ModuleLoadResult();
1625  }
1626 
1627  ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc);
1628  }
1629 
1630  // Check for any configuration macros that have changed.
1631  clang::Module *TopModule = Module->getTopLevelModule();
1632  for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1634  Module, ImportLoc);
1635  }
1636 
1637  LastModuleImportLoc = ImportLoc;
1638  LastModuleImportResult = ModuleLoadResult(Module, false);
1639  return LastModuleImportResult;
1640 }
1641 
1644  SourceLocation ImportLoc) {
1645  if (!ModuleManager)
1647  if (!ModuleManager)
1648  return;
1649 
1650  ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc);
1651 }
1652 
1654  SourceLocation TriggerLoc) {
1655  if (!ModuleManager)
1657  // Can't do anything if we don't have the module manager.
1658  if (!ModuleManager)
1659  return nullptr;
1660  // Get an existing global index. This loads it if not already
1661  // loaded.
1662  ModuleManager->loadGlobalIndex();
1663  GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1664  // If the global index doesn't exist, create it.
1665  if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
1666  hasPreprocessor()) {
1667  llvm::sys::fs::create_directories(
1668  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1671  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1672  ModuleManager->resetForReload();
1673  ModuleManager->loadGlobalIndex();
1674  GlobalIndex = ModuleManager->getGlobalIndex();
1675  }
1676  // For finding modules needing to be imported for fixit messages,
1677  // we need to make the global index cover all modules, so we do that here.
1678  if (!HaveFullGlobalModuleIndex && GlobalIndex && !buildingModule()) {
1680  bool RecreateIndex = false;
1681  for (ModuleMap::module_iterator I = MMap.module_begin(),
1682  E = MMap.module_end(); I != E; ++I) {
1683  Module *TheModule = I->second;
1684  const FileEntry *Entry = TheModule->getASTFile();
1685  if (!Entry) {
1687  Path.push_back(std::make_pair(
1688  getPreprocessor().getIdentifierInfo(TheModule->Name), TriggerLoc));
1689  std::reverse(Path.begin(), Path.end());
1690  // Load a module as hidden. This also adds it to the global index.
1691  loadModule(TheModule->DefinitionLoc, Path,
1692  Module::Hidden, false);
1693  RecreateIndex = true;
1694  }
1695  }
1696  if (RecreateIndex) {
1699  getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
1700  ModuleManager->resetForReload();
1701  ModuleManager->loadGlobalIndex();
1702  GlobalIndex = ModuleManager->getGlobalIndex();
1703  }
1704  HaveFullGlobalModuleIndex = true;
1705  }
1706  return GlobalIndex;
1707 }
1708 
1709 // Check global module index for missing imports.
1710 bool
1712  SourceLocation TriggerLoc) {
1713  // Look for the symbol in non-imported modules, but only if an error
1714  // actually occurred.
1715  if (!buildingModule()) {
1716  // Load global module index, or retrieve a previously loaded one.
1718  TriggerLoc);
1719 
1720  // Only if we have a global index.
1721  if (GlobalIndex) {
1722  GlobalModuleIndex::HitSet FoundModules;
1723 
1724  // Find the modules that reference the identifier.
1725  // Note that this only finds top-level modules.
1726  // We'll let diagnoseTypo find the actual declaration module.
1727  if (GlobalIndex->lookupIdentifier(Name, FoundModules))
1728  return true;
1729  }
1730  }
1731 
1732  return false;
1733 }
void AttachHeaderIncludeGen(Preprocessor &PP, bool ShowAllHeaders=false, StringRef OutputPath="", bool ShowDepth=true, bool MSStyle=false)
std::string OutputFile
The output file, if any.
SourceManager & getSourceManager() const
Definition: Preprocessor.h:682
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:806
static bool compileAndLoadModule(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName)
Defines the clang::ASTContext interface.
virtual bool isModelParsingAction() const
Is this action invoked on a model file?
LangOptions & getLangOpts()
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
Definition: ASTReader.h:316
ASTContext & getASTContext() const
std::string Name
The name of this module.
Definition: Basic/Module.h:52
CompilerInvocation & getInvocation()
PreprocessorOptions & getPreprocessorOpts()
std::vector< std::pair< std::string, bool > > Macros
std::string ModuleDependencyOutputDir
The directory to copy module dependencies to when collecting them.
DiagnosticConsumer * getClient()
Definition: Diagnostic.h:368
module_iterator module_begin() const
Definition: ModuleMap.h:467
std::string DwarfDebugFlags
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:687
std::string DOTOutputFile
The file to write GraphViz-formatted header dependencies to.
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:115
void setCodeCompletionConsumer(CodeCompleteConsumer *Value)
vfs::FileSystem & getVirtualFileSystem() const
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)
submodule_iterator submodule_begin()
Definition: Basic/Module.h:467
static void writeTimestampFile(StringRef TimestampFile)
Write a new timestamp file with the given path.
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Basic/Module.h:361
Defines the SourceManager interface.
IntrusiveRefCntPtr< FileSystem > getRealFileSystem()
Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Definition: Preprocessor.h:922
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Abstract base class for actions which can be performed by the frontend.
DiagnosticOptions & getDiagnosticOpts()
bool hasErrorOccurred() const
Definition: Diagnostic.h:573
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, ASTReaderListener &Listener)
Read the control block for the named AST file.
Definition: ASTReader.cpp:3968
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1118
bool InitializeSourceManager(const FrontendInputFile &Input)
std::unique_ptr< DiagnosticConsumer > takeClient()
Return the current diagnostic client along with ownership of that client.
Definition: Diagnostic.h:376
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
Definition: ASTReader.h:1317
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
The AST file has errors.
Definition: ASTReader.h:333
TargetInfo & getTarget() const
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
const FileEntry * getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Basic/Module.h:377
SourceManager & getSourceManager() const
Return the current source manager.
static PTHManager * Create(StringRef file, DiagnosticsEngine &Diags)
Definition: PTHLexer.cpp:434
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1309
DependencyOutputOptions & getDependencyOutputOpts()
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:585
std::string ModuleCachePath
The directory used for the module cache.
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:688
void setPredefines(const char *P)
Set the predefines for this Preprocessor.
Definition: Preprocessor.h:917
off_t getSize() const
Definition: FileManager.h:86
The client can handle an AST file that cannot load because it is missing.
Definition: ASTReader.h:1314
virtual void adjust(const LangOptions &Opts)
Set forced language options.
std::string getFullModuleName() const
Retrieve the full name of this module, including the path from its top-level module.
void setMainFileID(FileID FID)
Set the file ID for the main source file.
unsigned getNumWarnings() const
Definition: Diagnostic.h:1318
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
Definition: Diagnostic.cpp:92
static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts, DiagnosticsEngine &Diags, StringRef OutputFile)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
void createFileManager()
Create the file manager and replace any existing one with it.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
llvm::SetVector< std::string > ModulesIgnoreMacros
The set of macro names that should be ignored for the purposes of computing the module hash...
A source location that has been parsed on the command line.
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:846
unsigned DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
CodeGenOptions & getCodeGenOpts()
bool buildingModule() const
Returns true if this instance is building a module.
Definition: ModuleLoader.h:67
llvm::MemoryBuffer * getBuffer() const
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
ASTConsumer & getASTConsumer() const
Describes a module or submodule.
Definition: Basic/Module.h:49
FileManager & getFileManager() const
Definition: Preprocessor.h:681
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.
void setBuildGlobalModuleIndex(bool Build)
Set the flag indicating whether we should (re)build the global module index.
bool isAvailable() const
Determine whether this module is available for use within the current translation unit...
Definition: Basic/Module.h:313
FrontendOptions & getFrontendOpts()
IntrusiveRefCntPtr< vfs::FileSystem > getVirtualFileSystem() const
Definition: FileManager.h:223
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
DiagnosticConsumer & getDiagnosticClient() const
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:135
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:683
IntrusiveRefCntPtr< FailedModulesSet > FailedModules
The set of modules that failed to build.
module_iterator module_end() const
Definition: ModuleMap.h:468
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)
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Basic/Module.h:162
const FileEntry * getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
Definition: ModuleMap.cpp:810
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
submodule_iterator submodule_end()
Definition: Basic/Module.h:469
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
HeaderSearchOptions & getHeaderSearchOpts()
static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro, Module *Mod, SourceLocation ImportLoc)
Diagnose differences between the current definition of the given configuration macro and the definiti...
The AST file itself appears corrupted.
Definition: ASTReader.h:321
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
bool isInvalid() const
std::vector< Module * >::iterator submodule_iterator
Definition: Basic/Module.h:464
void createPCHExternalASTSource(StringRef Path, bool DisablePCHValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
bool hasVirtualFileSystem() const
std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers
The set of file-to-buffer remappings, which take existing files on the system (the first part of each...
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:151
static ErrorCode writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, StringRef Path)
Write a global index into the given.
llvm::StringMap< Module * >::const_iterator module_iterator
Definition: ModuleMap.h:466
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Basic/Module.h:172
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
static DependencyFileGenerator * CreateAndAttachToPreprocessor(Preprocessor &PP, const DependencyOutputOptions &Opts)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
void setPreprocessor(Preprocessor *Value)
Replace the current preprocessor.
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts, const CodeGenOptions *CodeGenOpts, DiagnosticsEngine &Diags)
std::string CurrentModule
The name of the current module.
Definition: LangOptions.h:96
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
void setVirtualFileSystem(IntrusiveRefCntPtr< vfs::FileSystem > FS)
Replace the current virtual file system.
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:33
ASTContext * Context
Exposes information about the current target.
A simple code-completion consumer that prints the results it receives in a simple format...
void setInvocation(CompilerInvocation *Value)
setInvocation - Replace the current invocation.
unsigned ModuleCachePruneInterval
The interval (in seconds) between pruning operations.
static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts)
Determine the appropriate source input kind based on language options.
HeaderSearchOptions & getHeaderSearchOpts() const
Retrieve the header-search options with which this header search was initialized. ...
Definition: HeaderSearch.h:274
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
std::string getSpecificModuleCachePath()
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...
SourceManager & SourceMgr
Definition: Format.cpp:1205
Defines version macros and version-related utility functions for Clang.
Defines the clang::Preprocessor interface.
void createASTContext()
Create the AST context.
unsigned ShowHeaderIncludes
Show header inclusions (-H).
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:7387
An input file for the front end.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
static bool EnableCodeCompletion(Preprocessor &PP, const std::string &Filename, unsigned Line, unsigned Column)
void addOutputFile(OutputFile &&OutFile)
unsigned BestEditDistance
The client can't handle any AST loading failures.
Definition: ASTReader.h:1311
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Basic/Module.h:372
The AST file was missing.
Definition: ASTReader.h:323
bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
std::unique_ptr< Sema > takeSema()
Options controlling the behavior of code completion.
const DirectoryEntry * Directory
The build directory of this module. This is the directory in which the module is notionally built...
Definition: Basic/Module.h:64
void overrideFileContents(const FileEntry *SourceFile, llvm::MemoryBuffer *Buffer, bool DoNotFree)
Override the contents of the given source file by providing an already-allocated buffer.
bool hasSourceManager() const
FileSystemOptions & getFileSystemOpts()
bool isNamedPipe() const
Check whether the file is a named pipe (and thus can't be opened by the native FileManager methods)...
Definition: FileManager.h:99
The control block was read successfully. Aside from failures, the AST file is safe to read into the c...
Definition: ASTReader.h:319
#define false
Definition: stdbool.h:33
Kind
void setPreprocessor(Preprocessor *pp)
Definition: PTHManager.h:134
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)
File is a PCH file treated as the preamble.
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
const PCHContainerReader & getPCHContainerReader() const
bool Execute()
Set the source manager's main input file, and run the action.
File is a PCH file treated as such.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
AnnotatedLine & Line
bool isValid() const
Return true if this is a valid SourceLocation object.
Options for controlling the compiler diagnostics engine.
static bool compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, Module *Module, StringRef ModuleFileName)
Compile a module file for the given module, using the options provided by the importing compiler inst...
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:1346
All of the names in this module are hidden.
Definition: Basic/Module.h:207
File is an implicitly-loaded module.
unsigned ModulesValidateSystemHeaders
Whether to validate system input files when a module is loaded.
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:685
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:53
void AttachDependencyGraphGen(Preprocessor &PP, StringRef OutputFile, StringRef SysRoot)
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic co...
Definition: Diagnostic.h:1376
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
Definition: Warnings.cpp:44
const FileEntry * getVirtualFile(StringRef Filename, off_t Size, time_t ModificationTime)
Retrieve a file entry for a "virtual" file that acts as if there were a file with the given name on d...
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
FileID getMainFileID() const
Returns the FileID of the main source file.
void createPreprocessor(TranslationUnitKind TUKind)
void resetNonModularOptions()
Reset any options that are not considered when building a module.
A global index for a set of module files, providing information about the identifiers within those mo...
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:331
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:676
const char * getName() const
Definition: FileManager.h:45
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
Definition: Preprocessor.h:765
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...
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
Definition: ASTReader.cpp:642
llvm::raw_null_ostream * createNullOutputFile()
Stored information about a header directive that was found in the module map file but has not been re...
Definition: Basic/Module.h:132
PreprocessorOptions & getPreprocessorOpts()
static void InitializeFileRemapping(DiagnosticsEngine &Diags, SourceManager &SourceMgr, FileManager &FileMgr, const PreprocessorOptions &InitOpts)
StringRef getFile() const
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:302
File is an explicitly-loaded module.
FileManager & getFileManager() const
Return the current file manager to the caller.
bool loadModuleFile(StringRef FileName)
std::unique_ptr< DiagnosticConsumer > create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords=false)
Returns a DiagnosticConsumer that serializes diagnostics to a bitcode file.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
Used for handling and querying diagnostic IDs.
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:873
Helper class for holding the data necessary to invoke the compiler.
static void pruneModuleCache(const HeaderSearchOptions &HSOpts)
Prune the module cache of modules that haven't been accessed in a long time.
FrontendOptions - Options for controlling the behavior of the frontend.
Abstract interface for a module loader.
Definition: ModuleLoader.h:56
std::string ImplementationOfModule
The name of the module that the translation unit is an implementation of. Prevents semantic imports...
Definition: LangOptions.h:101
Defines the Diagnostic-related interfaces.
Encapsulates the data about a macro definition (e.g. its tokens).
Definition: MacroInfo.h:34
SourceLocation DefinitionLoc
The location of the module definition.
Definition: Basic/Module.h:55
void clearOutputFiles(bool EraseFiles)
void BuryPointer(const void *Ptr)
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Definition: ModuleMap.cpp:818
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:101
bool isInvalid() const
MacroDirective * getLocalMacroDirectiveHistory(const IdentifierInfo *II) const
Given an identifier, return the latest non-imported macro directive for that identifier.
void setOverridenFilesKeepOriginalName(bool value)
Set true if the SourceManager should report the original file name for contents of files that were ov...
std::pair< std::string, bool > Requirement
An individual requirement: a feature name and a flag indicating the required state of that feature...
Definition: Basic/Module.h:144
void setTarget(TargetInfo *Value)
Replace the current diagnostics engine.
unsigned DisableFree
Disable memory freeing on exit.
raw_pwrite_stream * createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
unsigned ModuleCachePruneAfter
The time (in seconds) after which an unused module file will be considered unused and will...
std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const
void InitializePreprocessor(Preprocessor &PP, const PreprocessorOptions &PPOpts, const PCHContainerReader &PCHContainerRdr, const FrontendOptions &FEOpts)
void setModuleBuildStack(ModuleBuildStack stack)
Set the module build stack.
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:163
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:115
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
const StringRef Input
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:326
A SourceLocation and its associated SourceManager.
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Basic/Module.h:205
void PrintStats() const
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Basic/Module.h:278
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
unsigned getNumErrors() const
Definition: Diagnostic.h:1317
The AST file was written by a different version of Clang.
Definition: ASTReader.h:328
#define CLANG_VERSION_STRING
A string that describes the Clang version number, e.g., "1.0".
Definition: Version.h:30
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)
GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Load, create, or return global module. This function returns an existing global module index...
void InitBuiltinTypes(const TargetInfo &Target)
Initialize built-in types.
Definition: ASTContext.cpp:953
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment. In this case there should b...
bool ownsClient() const
Determine whether this DiagnosticsEngine object own its client.
Definition: Diagnostic.h:372
A trivial tuple used to represent a source range.
unsigned PrintShowIncludes
Print cl.exe style /showIncludes info.
raw_pwrite_stream * createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
This class handles loading and caching of source files into memory.
void setDiagnostics(DiagnosticsEngine *Value)
setDiagnostics - Replace the current diagnostics engine.
std::string DiagnosticLogFile
The file to log diagnostic output to.
unsigned Column
Definition: Format.cpp:1202
std::string TokenCache
If given, a PTH cache file to use for speeding up header parsing.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:96
bool lookupIdentifier(StringRef Name, HitSet &Hits)
Look for all of the module files with information about the given identifier, e.g., a global function, variable, or type with that name.