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