clang  9.0.0svn
FrontendAction.cpp
Go to the documentation of this file.
1 //===--- FrontendAction.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "clang/AST/ASTConsumer.h"
11 #include "clang/AST/ASTContext.h"
12 #include "clang/AST/DeclGroup.h"
13 #include "clang/Frontend/ASTUnit.h"
19 #include "clang/Frontend/Utils.h"
20 #include "clang/Lex/HeaderSearch.h"
22 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Parse/ParseAST.h"
28 #include "llvm/Support/BuryPointer.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/FileSystem.h"
31 #include "llvm/Support/Path.h"
32 #include "llvm/Support/Timer.h"
33 #include "llvm/Support/raw_ostream.h"
34 #include <system_error>
35 using namespace clang;
36 
37 LLVM_INSTANTIATE_REGISTRY(FrontendPluginRegistry)
38 
39 namespace {
40 
41 class DelegatingDeserializationListener : public ASTDeserializationListener {
43  bool DeletePrevious;
44 
45 public:
46  explicit DelegatingDeserializationListener(
47  ASTDeserializationListener *Previous, bool DeletePrevious)
48  : Previous(Previous), DeletePrevious(DeletePrevious) {}
49  ~DelegatingDeserializationListener() override {
50  if (DeletePrevious)
51  delete Previous;
52  }
53 
54  void ReaderInitialized(ASTReader *Reader) override {
55  if (Previous)
56  Previous->ReaderInitialized(Reader);
57  }
58  void IdentifierRead(serialization::IdentID ID,
59  IdentifierInfo *II) override {
60  if (Previous)
61  Previous->IdentifierRead(ID, II);
62  }
63  void TypeRead(serialization::TypeIdx Idx, QualType T) override {
64  if (Previous)
65  Previous->TypeRead(Idx, T);
66  }
67  void DeclRead(serialization::DeclID ID, const Decl *D) override {
68  if (Previous)
69  Previous->DeclRead(ID, D);
70  }
71  void SelectorRead(serialization::SelectorID ID, Selector Sel) override {
72  if (Previous)
73  Previous->SelectorRead(ID, Sel);
74  }
75  void MacroDefinitionRead(serialization::PreprocessedEntityID PPID,
76  MacroDefinitionRecord *MD) override {
77  if (Previous)
78  Previous->MacroDefinitionRead(PPID, MD);
79  }
80 };
81 
82 /// Dumps deserialized declarations.
83 class DeserializedDeclsDumper : public DelegatingDeserializationListener {
84 public:
85  explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous,
86  bool DeletePrevious)
87  : DelegatingDeserializationListener(Previous, DeletePrevious) {}
88 
89  void DeclRead(serialization::DeclID ID, const Decl *D) override {
90  llvm::outs() << "PCH DECL: " << D->getDeclKindName();
91  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
92  llvm::outs() << " - ";
93  ND->printQualifiedName(llvm::outs());
94  }
95  llvm::outs() << "\n";
96 
97  DelegatingDeserializationListener::DeclRead(ID, D);
98  }
99 };
100 
101 /// Checks deserialized declarations and emits error if a name
102 /// matches one given in command-line using -error-on-deserialized-decl.
103 class DeserializedDeclsChecker : public DelegatingDeserializationListener {
104  ASTContext &Ctx;
105  std::set<std::string> NamesToCheck;
106 
107 public:
108  DeserializedDeclsChecker(ASTContext &Ctx,
109  const std::set<std::string> &NamesToCheck,
110  ASTDeserializationListener *Previous,
111  bool DeletePrevious)
112  : DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx),
113  NamesToCheck(NamesToCheck) {}
114 
115  void DeclRead(serialization::DeclID ID, const Decl *D) override {
116  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
117  if (NamesToCheck.find(ND->getNameAsString()) != NamesToCheck.end()) {
118  unsigned DiagID
120  "%0 was deserialized");
121  Ctx.getDiagnostics().Report(Ctx.getFullLoc(D->getLocation()), DiagID)
122  << ND->getNameAsString();
123  }
124 
125  DelegatingDeserializationListener::DeclRead(ID, D);
126  }
127 };
128 
129 } // end anonymous namespace
130 
131 FrontendAction::FrontendAction() : Instance(nullptr) {}
132 
134 
136  std::unique_ptr<ASTUnit> AST) {
137  this->CurrentInput = CurrentInput;
138  CurrentASTUnit = std::move(AST);
139 }
140 
144  CI.getLangOpts().CurrentModule, /*AllowSearch*/false);
145 }
146 
147 std::unique_ptr<ASTConsumer>
148 FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
149  StringRef InFile) {
150  std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
151  if (!Consumer)
152  return nullptr;
153 
154  // Validate -add-plugin args.
155  bool FoundAllPlugins = true;
156  for (const std::string &Arg : CI.getFrontendOpts().AddPluginActions) {
157  bool Found = false;
158  for (FrontendPluginRegistry::iterator it = FrontendPluginRegistry::begin(),
159  ie = FrontendPluginRegistry::end();
160  it != ie; ++it) {
161  if (it->getName() == Arg)
162  Found = true;
163  }
164  if (!Found) {
165  CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name) << Arg;
166  FoundAllPlugins = false;
167  }
168  }
169  if (!FoundAllPlugins)
170  return nullptr;
171 
172  // If there are no registered plugins we don't need to wrap the consumer
173  if (FrontendPluginRegistry::begin() == FrontendPluginRegistry::end())
174  return Consumer;
175 
176  // If this is a code completion run, avoid invoking the plugin consumers
177  if (CI.hasCodeCompletionConsumer())
178  return Consumer;
179 
180  // Collect the list of plugins that go before the main action (in Consumers)
181  // or after it (in AfterConsumers)
182  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
183  std::vector<std::unique_ptr<ASTConsumer>> AfterConsumers;
184  for (FrontendPluginRegistry::iterator it = FrontendPluginRegistry::begin(),
185  ie = FrontendPluginRegistry::end();
186  it != ie; ++it) {
187  std::unique_ptr<PluginASTAction> P = it->instantiate();
188  PluginASTAction::ActionType ActionType = P->getActionType();
189  if (ActionType == PluginASTAction::Cmdline) {
190  // This is O(|plugins| * |add_plugins|), but since both numbers are
191  // way below 50 in practice, that's ok.
192  for (size_t i = 0, e = CI.getFrontendOpts().AddPluginActions.size();
193  i != e; ++i) {
194  if (it->getName() == CI.getFrontendOpts().AddPluginActions[i]) {
196  break;
197  }
198  }
199  }
200  if ((ActionType == PluginASTAction::AddBeforeMainAction ||
201  ActionType == PluginASTAction::AddAfterMainAction) &&
202  P->ParseArgs(CI, CI.getFrontendOpts().PluginArgs[it->getName()])) {
203  std::unique_ptr<ASTConsumer> PluginConsumer = P->CreateASTConsumer(CI, InFile);
204  if (ActionType == PluginASTAction::AddBeforeMainAction) {
205  Consumers.push_back(std::move(PluginConsumer));
206  } else {
207  AfterConsumers.push_back(std::move(PluginConsumer));
208  }
209  }
210  }
211 
212  // Add to Consumers the main consumer, then all the plugins that go after it
213  Consumers.push_back(std::move(Consumer));
214  for (auto &C : AfterConsumers) {
215  Consumers.push_back(std::move(C));
216  }
217 
218  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
219 }
220 
221 /// For preprocessed files, if the first line is the linemarker and specifies
222 /// the original source file name, use that name as the input file name.
223 /// Returns the location of the first token after the line marker directive.
224 ///
225 /// \param CI The compiler instance.
226 /// \param InputFile Populated with the filename from the line marker.
227 /// \param IsModuleMap If \c true, add a line note corresponding to this line
228 /// directive. (We need to do this because the directive will not be
229 /// visited by the preprocessor.)
231  std::string &InputFile,
232  bool IsModuleMap = false) {
233  auto &SourceMgr = CI.getSourceManager();
234  auto MainFileID = SourceMgr.getMainFileID();
235 
236  bool Invalid = false;
237  const auto *MainFileBuf = SourceMgr.getBuffer(MainFileID, &Invalid);
238  if (Invalid)
239  return SourceLocation();
240 
241  std::unique_ptr<Lexer> RawLexer(
242  new Lexer(MainFileID, MainFileBuf, SourceMgr, CI.getLangOpts()));
243 
244  // If the first line has the syntax of
245  //
246  // # NUM "FILENAME"
247  //
248  // we use FILENAME as the input file name.
249  Token T;
250  if (RawLexer->LexFromRawLexer(T) || T.getKind() != tok::hash)
251  return SourceLocation();
252  if (RawLexer->LexFromRawLexer(T) || T.isAtStartOfLine() ||
253  T.getKind() != tok::numeric_constant)
254  return SourceLocation();
255 
256  unsigned LineNo;
257  SourceLocation LineNoLoc = T.getLocation();
258  if (IsModuleMap) {
259  llvm::SmallString<16> Buffer;
260  if (Lexer::getSpelling(LineNoLoc, Buffer, SourceMgr, CI.getLangOpts())
261  .getAsInteger(10, LineNo))
262  return SourceLocation();
263  }
264 
265  RawLexer->LexFromRawLexer(T);
266  if (T.isAtStartOfLine() || T.getKind() != tok::string_literal)
267  return SourceLocation();
268 
269  StringLiteralParser Literal(T, CI.getPreprocessor());
270  if (Literal.hadError)
271  return SourceLocation();
272  RawLexer->LexFromRawLexer(T);
273  if (T.isNot(tok::eof) && !T.isAtStartOfLine())
274  return SourceLocation();
275  InputFile = Literal.GetString().str();
276 
277  if (IsModuleMap)
279  LineNoLoc, LineNo, SourceMgr.getLineTableFilenameID(InputFile), false,
280  false, SrcMgr::C_User_ModuleMap);
281 
282  return T.getLocation();
283 }
284 
285 static SmallVectorImpl<char> &
286 operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) {
287  Includes.append(RHS.begin(), RHS.end());
288  return Includes;
289 }
290 
291 static void addHeaderInclude(StringRef HeaderName,
292  SmallVectorImpl<char> &Includes,
293  const LangOptions &LangOpts,
294  bool IsExternC) {
295  if (IsExternC && LangOpts.CPlusPlus)
296  Includes += "extern \"C\" {\n";
297  if (LangOpts.ObjC)
298  Includes += "#import \"";
299  else
300  Includes += "#include \"";
301 
302  Includes += HeaderName;
303 
304  Includes += "\"\n";
305  if (IsExternC && LangOpts.CPlusPlus)
306  Includes += "}\n";
307 }
308 
309 /// Collect the set of header includes needed to construct the given
310 /// module and update the TopHeaders file set of the module.
311 ///
312 /// \param Module The module we're collecting includes from.
313 ///
314 /// \param Includes Will be augmented with the set of \#includes or \#imports
315 /// needed to load all of the named headers.
316 static std::error_code collectModuleHeaderIncludes(
317  const LangOptions &LangOpts, FileManager &FileMgr, DiagnosticsEngine &Diag,
318  ModuleMap &ModMap, clang::Module *Module, SmallVectorImpl<char> &Includes) {
319  // Don't collect any headers for unavailable modules.
320  if (!Module->isAvailable())
321  return std::error_code();
322 
323  // Resolve all lazy header directives to header files.
324  ModMap.resolveHeaderDirectives(Module);
325 
326  // If any headers are missing, we can't build this module. In most cases,
327  // diagnostics for this should have already been produced; we only get here
328  // if explicit stat information was provided.
329  // FIXME: If the name resolves to a file with different stat information,
330  // produce a better diagnostic.
331  if (!Module->MissingHeaders.empty()) {
332  auto &MissingHeader = Module->MissingHeaders.front();
333  Diag.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
334  << MissingHeader.IsUmbrella << MissingHeader.FileName;
335  return std::error_code();
336  }
337 
338  // Add includes for each of these headers.
339  for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
340  for (Module::Header &H : Module->Headers[HK]) {
341  Module->addTopHeader(H.Entry);
342  // Use the path as specified in the module map file. We'll look for this
343  // file relative to the module build directory (the directory containing
344  // the module map file) so this will find the same file that we found
345  // while parsing the module map.
346  addHeaderInclude(H.NameAsWritten, Includes, LangOpts, Module->IsExternC);
347  }
348  }
349  // Note that Module->PrivateHeaders will not be a TopHeader.
350 
351  if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
352  Module->addTopHeader(UmbrellaHeader.Entry);
353  if (Module->Parent)
354  // Include the umbrella header for submodules.
355  addHeaderInclude(UmbrellaHeader.NameAsWritten, Includes, LangOpts,
356  Module->IsExternC);
357  } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
358  // Add all of the headers we find in this subdirectory.
359  std::error_code EC;
360  SmallString<128> DirNative;
361  llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative);
362 
363  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
364  for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
365  Dir != End && !EC; Dir.increment(EC)) {
366  // Check whether this entry has an extension typically associated with
367  // headers.
368  if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
369  .Cases(".h", ".H", ".hh", ".hpp", true)
370  .Default(false))
371  continue;
372 
373  const FileEntry *Header = FileMgr.getFile(Dir->path());
374  // FIXME: This shouldn't happen unless there is a file system race. Is
375  // that worth diagnosing?
376  if (!Header)
377  continue;
378 
379  // If this header is marked 'unavailable' in this module, don't include
380  // it.
381  if (ModMap.isHeaderUnavailableInModule(Header, Module))
382  continue;
383 
384  // Compute the relative path from the directory to this file.
385  SmallVector<StringRef, 16> Components;
386  auto PathIt = llvm::sys::path::rbegin(Dir->path());
387  for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
388  Components.push_back(*PathIt);
389  SmallString<128> RelativeHeader(UmbrellaDir.NameAsWritten);
390  for (auto It = Components.rbegin(), End = Components.rend(); It != End;
391  ++It)
392  llvm::sys::path::append(RelativeHeader, *It);
393 
394  // Include this header as part of the umbrella directory.
395  Module->addTopHeader(Header);
396  addHeaderInclude(RelativeHeader, Includes, LangOpts, Module->IsExternC);
397  }
398 
399  if (EC)
400  return EC;
401  }
402 
403  // Recurse into submodules.
405  SubEnd = Module->submodule_end();
406  Sub != SubEnd; ++Sub)
407  if (std::error_code Err = collectModuleHeaderIncludes(
408  LangOpts, FileMgr, Diag, ModMap, *Sub, Includes))
409  return Err;
410 
411  return std::error_code();
412 }
413 
414 static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem,
415  bool IsPreprocessed,
416  std::string &PresumedModuleMapFile,
417  unsigned &Offset) {
418  auto &SrcMgr = CI.getSourceManager();
420 
421  // Map the current input to a file.
422  FileID ModuleMapID = SrcMgr.getMainFileID();
423  const FileEntry *ModuleMap = SrcMgr.getFileEntryForID(ModuleMapID);
424 
425  // If the module map is preprocessed, handle the initial line marker;
426  // line directives are not part of the module map syntax in general.
427  Offset = 0;
428  if (IsPreprocessed) {
429  SourceLocation EndOfLineMarker =
430  ReadOriginalFileName(CI, PresumedModuleMapFile, /*IsModuleMap*/ true);
431  if (EndOfLineMarker.isValid())
432  Offset = CI.getSourceManager().getDecomposedLoc(EndOfLineMarker).second;
433  }
434 
435  // Load the module map file.
436  if (HS.loadModuleMapFile(ModuleMap, IsSystem, ModuleMapID, &Offset,
437  PresumedModuleMapFile))
438  return true;
439 
440  if (SrcMgr.getBuffer(ModuleMapID)->getBufferSize() == Offset)
441  Offset = 0;
442 
443  return false;
444 }
445 
447  StringRef ModuleMapFilename) {
448  if (CI.getLangOpts().CurrentModule.empty()) {
449  CI.getDiagnostics().Report(diag::err_missing_module_name);
450 
451  // FIXME: Eventually, we could consider asking whether there was just
452  // a single module described in the module map, and use that as a
453  // default. Then it would be fairly trivial to just "compile" a module
454  // map with a single module (the common case).
455  return nullptr;
456  }
457 
458  // Dig out the module definition.
461  /*AllowSearch=*/false);
462  if (!M) {
463  CI.getDiagnostics().Report(diag::err_missing_module)
464  << CI.getLangOpts().CurrentModule << ModuleMapFilename;
465 
466  return nullptr;
467  }
468 
469  // Check whether we can build this module at all.
471  CI.getDiagnostics(), M))
472  return nullptr;
473 
474  // Inform the preprocessor that includes from within the input buffer should
475  // be resolved relative to the build directory of the module map file.
477 
478  // If the module was inferred from a different module map (via an expanded
479  // umbrella module definition), track that fact.
480  // FIXME: It would be preferable to fill this in as part of processing
481  // the module map, rather than adding it after the fact.
482  StringRef OriginalModuleMapName = CI.getFrontendOpts().OriginalModuleMap;
483  if (!OriginalModuleMapName.empty()) {
484  auto *OriginalModuleMap =
485  CI.getFileManager().getFile(OriginalModuleMapName,
486  /*openFile*/ true);
487  if (!OriginalModuleMap) {
488  CI.getDiagnostics().Report(diag::err_module_map_not_found)
489  << OriginalModuleMapName;
490  return nullptr;
491  }
492  if (OriginalModuleMap != CI.getSourceManager().getFileEntryForID(
494  M->IsInferred = true;
496  .setInferredModuleAllowedBy(M, OriginalModuleMap);
497  }
498  }
499 
500  // If we're being run from the command-line, the module build stack will not
501  // have been filled in yet, so complete it now in order to allow us to detect
502  // module cycles.
503  SourceManager &SourceMgr = CI.getSourceManager();
504  if (SourceMgr.getModuleBuildStack().empty())
506  FullSourceLoc(SourceLocation(), SourceMgr));
507  return M;
508 }
509 
510 /// Compute the input buffer that should be used to build the specified module.
511 static std::unique_ptr<llvm::MemoryBuffer>
513  FileManager &FileMgr = CI.getFileManager();
514 
515  // Collect the set of #includes we need to build the module.
516  SmallString<256> HeaderContents;
517  std::error_code Err = std::error_code();
518  if (Module::Header UmbrellaHeader = M->getUmbrellaHeader())
519  addHeaderInclude(UmbrellaHeader.NameAsWritten, HeaderContents,
520  CI.getLangOpts(), M->IsExternC);
522  CI.getLangOpts(), FileMgr, CI.getDiagnostics(),
524  HeaderContents);
525 
526  if (Err) {
527  CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
528  << M->getFullModuleName() << Err.message();
529  return nullptr;
530  }
531 
532  return llvm::MemoryBuffer::getMemBufferCopy(
533  HeaderContents, Module::getModuleInputBufferName());
534 }
535 
537  const FrontendInputFile &RealInput) {
538  FrontendInputFile Input(RealInput);
539  assert(!Instance && "Already processing a source file!");
540  assert(!Input.isEmpty() && "Unexpected empty filename!");
541  setCurrentInput(Input);
542  setCompilerInstance(&CI);
543 
544  bool HasBegunSourceFile = false;
545  bool ReplayASTFile = Input.getKind().getFormat() == InputKind::Precompiled &&
547  if (!BeginInvocation(CI))
548  goto failure;
549 
550  // If we're replaying the build of an AST file, import it and set up
551  // the initial state from its build.
552  if (ReplayASTFile) {
554 
555  // The AST unit populates its own diagnostics engine rather than ours.
557  new DiagnosticsEngine(Diags->getDiagnosticIDs(),
558  &Diags->getDiagnosticOptions()));
559  ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
560 
561  // FIXME: What if the input is a memory buffer?
562  StringRef InputFile = Input.getFile();
563 
564  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
566  ASTDiags, CI.getFileSystemOpts(), CI.getCodeGenOpts().DebugTypeExtRefs);
567  if (!AST)
568  goto failure;
569 
570  // Options relating to how we treat the input (but not what we do with it)
571  // are inherited from the AST unit.
572  CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts();
573  CI.getPreprocessorOpts() = AST->getPreprocessorOpts();
574  CI.getLangOpts() = AST->getLangOpts();
575 
576  // Set the shared objects, these are reset when we finish processing the
577  // file, otherwise the CompilerInstance will happily destroy them.
578  CI.setFileManager(&AST->getFileManager());
580  CI.getSourceManager().initializeForReplay(AST->getSourceManager());
581 
582  // Preload all the module files loaded transitively by the AST unit. Also
583  // load all module map files that were parsed as part of building the AST
584  // unit.
585  if (auto ASTReader = AST->getASTReader()) {
586  auto &MM = ASTReader->getModuleManager();
587  auto &PrimaryModule = MM.getPrimaryModule();
588 
589  for (serialization::ModuleFile &MF : MM)
590  if (&MF != &PrimaryModule)
591  CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName);
592 
593  ASTReader->visitTopLevelModuleMaps(PrimaryModule,
594  [&](const FileEntry *FE) {
595  CI.getFrontendOpts().ModuleMapFiles.push_back(FE->getName());
596  });
597  }
598 
599  // Set up the input file for replay purposes.
600  auto Kind = AST->getInputKind();
601  if (Kind.getFormat() == InputKind::ModuleMap) {
602  Module *ASTModule =
603  AST->getPreprocessor().getHeaderSearchInfo().lookupModule(
604  AST->getLangOpts().CurrentModule, /*AllowSearch*/ false);
605  assert(ASTModule && "module file does not define its own module");
606  Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind);
607  } else {
608  auto &OldSM = AST->getSourceManager();
609  FileID ID = OldSM.getMainFileID();
610  if (auto *File = OldSM.getFileEntryForID(ID))
611  Input = FrontendInputFile(File->getName(), Kind);
612  else
613  Input = FrontendInputFile(OldSM.getBuffer(ID), Kind);
614  }
615  setCurrentInput(Input, std::move(AST));
616  }
617 
618  // AST files follow a very different path, since they share objects via the
619  // AST unit.
620  if (Input.getKind().getFormat() == InputKind::Precompiled) {
621  assert(!usesPreprocessorOnly() && "this case was handled above");
622  assert(hasASTFileSupport() &&
623  "This action does not have AST file support!");
624 
626 
627  // FIXME: What if the input is a memory buffer?
628  StringRef InputFile = Input.getFile();
629 
630  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
631  InputFile, CI.getPCHContainerReader(), ASTUnit::LoadEverything, Diags,
632  CI.getFileSystemOpts(), CI.getCodeGenOpts().DebugTypeExtRefs);
633 
634  if (!AST)
635  goto failure;
636 
637  // Inform the diagnostic client we are processing a source file.
638  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
639  HasBegunSourceFile = true;
640 
641  // Set the shared objects, these are reset when we finish processing the
642  // file, otherwise the CompilerInstance will happily destroy them.
643  CI.setFileManager(&AST->getFileManager());
644  CI.setSourceManager(&AST->getSourceManager());
645  CI.setPreprocessor(AST->getPreprocessorPtr());
646  Preprocessor &PP = CI.getPreprocessor();
648  PP.getLangOpts());
649  CI.setASTContext(&AST->getASTContext());
650 
651  setCurrentInput(Input, std::move(AST));
652 
653  // Initialize the action.
654  if (!BeginSourceFileAction(CI))
655  goto failure;
656 
657  // Create the AST consumer.
658  CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
659  if (!CI.hasASTConsumer())
660  goto failure;
661 
662  return true;
663  }
664 
665  // Set up the file and source managers, if needed.
666  if (!CI.hasFileManager()) {
667  if (!CI.createFileManager()) {
668  goto failure;
669  }
670  }
671  if (!CI.hasSourceManager())
673 
674  // Set up embedding for any specified files. Do this before we load any
675  // source files, including the primary module map for the compilation.
676  for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
677  if (const auto *FE = CI.getFileManager().getFile(F, /*openFile*/true))
679  else
680  CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;
681  }
684 
685  // IR files bypass the rest of initialization.
686  if (Input.getKind().getLanguage() == InputKind::LLVM_IR) {
687  assert(hasIRSupport() &&
688  "This action does not have IR file support!");
689 
690  // Inform the diagnostic client we are processing a source file.
691  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
692  HasBegunSourceFile = true;
693 
694  // Initialize the action.
695  if (!BeginSourceFileAction(CI))
696  goto failure;
697 
698  // Initialize the main file entry.
699  if (!CI.InitializeSourceManager(CurrentInput))
700  goto failure;
701 
702  return true;
703  }
704 
705  // If the implicit PCH include is actually a directory, rather than
706  // a single file, search for a suitable PCH file in that directory.
707  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
708  FileManager &FileMgr = CI.getFileManager();
710  StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
711  std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
712  if (const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude)) {
713  std::error_code EC;
714  SmallString<128> DirNative;
715  llvm::sys::path::native(PCHDir->getName(), DirNative);
716  bool Found = false;
717  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
718  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
719  DirEnd;
720  Dir != DirEnd && !EC; Dir.increment(EC)) {
721  // Check whether this is an acceptable AST file.
723  Dir->path(), FileMgr, CI.getPCHContainerReader(),
725  SpecificModuleCachePath)) {
726  PPOpts.ImplicitPCHInclude = Dir->path();
727  Found = true;
728  break;
729  }
730  }
731 
732  if (!Found) {
733  CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
734  goto failure;
735  }
736  }
737  }
738 
739  // Set up the preprocessor if needed. When parsing model files the
740  // preprocessor of the original source is reused.
741  if (!isModelParsingAction())
743 
744  // Inform the diagnostic client we are processing a source file.
746  &CI.getPreprocessor());
747  HasBegunSourceFile = true;
748 
749  // Initialize the main file entry.
750  if (!CI.InitializeSourceManager(Input))
751  goto failure;
752 
753  // For module map files, we first parse the module map and synthesize a
754  // "<module-includes>" buffer before more conventional processing.
755  if (Input.getKind().getFormat() == InputKind::ModuleMap) {
756  CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleMap);
757 
758  std::string PresumedModuleMapFile;
759  unsigned OffsetToContents;
760  if (loadModuleMapForModuleBuild(CI, Input.isSystem(),
761  Input.isPreprocessed(),
762  PresumedModuleMapFile, OffsetToContents))
763  goto failure;
764 
765  auto *CurrentModule = prepareToBuildModule(CI, Input.getFile());
766  if (!CurrentModule)
767  goto failure;
768 
769  CurrentModule->PresumedModuleMapFile = PresumedModuleMapFile;
770 
771  if (OffsetToContents)
772  // If the module contents are in the same file, skip to them.
773  CI.getPreprocessor().setSkipMainFilePreamble(OffsetToContents, true);
774  else {
775  // Otherwise, convert the module description to a suitable input buffer.
776  auto Buffer = getInputBufferForModule(CI, CurrentModule);
777  if (!Buffer)
778  goto failure;
779 
780  // Reinitialize the main file entry to refer to the new input.
781  auto Kind = CurrentModule->IsSystem ? SrcMgr::C_System : SrcMgr::C_User;
782  auto &SourceMgr = CI.getSourceManager();
783  auto BufferID = SourceMgr.createFileID(std::move(Buffer), Kind);
784  assert(BufferID.isValid() && "couldn't creaate module buffer ID");
785  SourceMgr.setMainFileID(BufferID);
786  }
787  }
788 
789  // Initialize the action.
790  if (!BeginSourceFileAction(CI))
791  goto failure;
792 
793  // If we were asked to load any module map files, do so now.
794  for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) {
795  if (auto *File = CI.getFileManager().getFile(Filename))
797  File, /*IsSystem*/false);
798  else
799  CI.getDiagnostics().Report(diag::err_module_map_not_found) << Filename;
800  }
801 
802  // Add a module declaration scope so that modules from -fmodule-map-file
803  // arguments may shadow modules found implicitly in search paths.
804  CI.getPreprocessor()
806  .getModuleMap()
808 
809  // Create the AST context and consumer unless this is a preprocessor only
810  // action.
811  if (!usesPreprocessorOnly()) {
812  // Parsing a model file should reuse the existing ASTContext.
813  if (!isModelParsingAction())
814  CI.createASTContext();
815 
816  // For preprocessed files, check if the first line specifies the original
817  // source file name with a linemarker.
818  std::string PresumedInputFile = getCurrentFileOrBufferName();
819  if (Input.isPreprocessed())
820  ReadOriginalFileName(CI, PresumedInputFile);
821 
822  std::unique_ptr<ASTConsumer> Consumer =
823  CreateWrappedASTConsumer(CI, PresumedInputFile);
824  if (!Consumer)
825  goto failure;
826 
827  // FIXME: should not overwrite ASTMutationListener when parsing model files?
828  if (!isModelParsingAction())
829  CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
830 
831  if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
832  // Convert headers to PCH and chain them.
833  IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
834  source = createChainedIncludesSource(CI, FinalReader);
835  if (!source)
836  goto failure;
837  CI.setModuleManager(static_cast<ASTReader *>(FinalReader.get()));
838  CI.getASTContext().setExternalSource(source);
839  } else if (CI.getLangOpts().Modules ||
840  !CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
841  // Use PCM or PCH.
842  assert(hasPCHSupport() && "This action does not have PCH support!");
843  ASTDeserializationListener *DeserialListener =
844  Consumer->GetASTDeserializationListener();
845  bool DeleteDeserialListener = false;
847  DeserialListener = new DeserializedDeclsDumper(DeserialListener,
848  DeleteDeserialListener);
849  DeleteDeserialListener = true;
850  }
852  DeserialListener = new DeserializedDeclsChecker(
853  CI.getASTContext(),
855  DeserialListener, DeleteDeserialListener);
856  DeleteDeserialListener = true;
857  }
858  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
862  CI.getPreprocessorOpts().AllowPCHWithCompilerErrors, DeserialListener,
863  DeleteDeserialListener);
864  if (!CI.getASTContext().getExternalSource())
865  goto failure;
866  }
867  // If modules are enabled, create the module manager before creating
868  // any builtins, so that all declarations know that they might be
869  // extended by an external source.
870  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
872  CI.createModuleManager();
873  CI.getModuleManager()->setDeserializationListener(DeserialListener,
874  DeleteDeserialListener);
875  }
876  }
877 
878  CI.setASTConsumer(std::move(Consumer));
879  if (!CI.hasASTConsumer())
880  goto failure;
881  }
882 
883  // Initialize built-in info as long as we aren't using an external AST
884  // source.
885  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
887  Preprocessor &PP = CI.getPreprocessor();
889  PP.getLangOpts());
890  } else {
891  // FIXME: If this is a problem, recover from it by creating a multiplex
892  // source.
893  assert((!CI.getLangOpts().Modules || CI.getModuleManager()) &&
894  "modules enabled but created an external source that "
895  "doesn't support modules");
896  }
897 
898  // If we were asked to load any module files, do so now.
899  for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
900  if (!CI.loadModuleFile(ModuleFile))
901  goto failure;
902 
903  // If there is a layout overrides file, attach an external AST source that
904  // provides the layouts from that file.
905  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
908  Override(new LayoutOverrideSource(
910  CI.getASTContext().setExternalSource(Override);
911  }
912 
913  return true;
914 
915  // If we failed, reset state since the client will not end up calling the
916  // matching EndSourceFile().
917 failure:
918  if (HasBegunSourceFile)
920  CI.clearOutputFiles(/*EraseFiles=*/true);
921  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
923  setCompilerInstance(nullptr);
924  return false;
925 }
926 
929 
930  if (CI.hasFrontendTimer()) {
931  llvm::TimeRegion Timer(CI.getFrontendTimer());
932  ExecuteAction();
933  }
934  else ExecuteAction();
935 
936  // If we are supposed to rebuild the global module index, do so now unless
937  // there were any module-build failures.
938  if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
939  CI.hasPreprocessor()) {
940  StringRef Cache =
942  if (!Cache.empty())
945  }
946 
947  return true;
948 }
949 
952 
953  // Inform the diagnostic client we are done with this source file.
955 
956  // Inform the preprocessor we are done.
957  if (CI.hasPreprocessor())
959 
960  // Finalize the action.
962 
963  // Sema references the ast consumer, so reset sema first.
964  //
965  // FIXME: There is more per-file stuff we could just drop here?
966  bool DisableFree = CI.getFrontendOpts().DisableFree;
967  if (DisableFree) {
968  CI.resetAndLeakSema();
970  llvm::BuryPointer(CI.takeASTConsumer().get());
971  } else {
972  CI.setSema(nullptr);
973  CI.setASTContext(nullptr);
974  CI.setASTConsumer(nullptr);
975  }
976 
977  if (CI.getFrontendOpts().ShowStats) {
978  llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFile() << "':\n";
983  llvm::errs() << "\n";
984  }
985 
986  // Cleanup the output streams, and erase the output files if instructed by the
987  // FrontendAction.
988  CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
989 
990  if (isCurrentFileAST()) {
991  if (DisableFree) {
995  llvm::BuryPointer(std::move(CurrentASTUnit));
996  } else {
997  CI.setPreprocessor(nullptr);
998  CI.setSourceManager(nullptr);
999  CI.setFileManager(nullptr);
1000  }
1001  }
1002 
1003  setCompilerInstance(nullptr);
1005  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
1006 }
1007 
1010 }
1011 
1012 //===----------------------------------------------------------------------===//
1013 // Utility Actions
1014 //===----------------------------------------------------------------------===//
1015 
1018  if (!CI.hasPreprocessor())
1019  return;
1020 
1021  // FIXME: Move the truncation aspect of this into Sema, we delayed this till
1022  // here so the source manager would be initialized.
1023  if (hasCodeCompletionSupport() &&
1026 
1027  // Use a code completion consumer?
1028  CodeCompleteConsumer *CompletionConsumer = nullptr;
1029  if (CI.hasCodeCompletionConsumer())
1030  CompletionConsumer = &CI.getCodeCompletionConsumer();
1031 
1032  if (!CI.hasSema())
1033  CI.createSema(getTranslationUnitKind(), CompletionConsumer);
1034 
1037 }
1038 
1039 void PluginASTAction::anchor() { }
1040 
1041 std::unique_ptr<ASTConsumer>
1043  StringRef InFile) {
1044  llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
1045 }
1046 
1048  return WrappedAction->PrepareToExecuteAction(CI);
1049 }
1050 std::unique_ptr<ASTConsumer>
1052  StringRef InFile) {
1053  return WrappedAction->CreateASTConsumer(CI, InFile);
1054 }
1056  return WrappedAction->BeginInvocation(CI);
1057 }
1059  WrappedAction->setCurrentInput(getCurrentInput());
1060  WrappedAction->setCompilerInstance(&CI);
1061  auto Ret = WrappedAction->BeginSourceFileAction(CI);
1062  // BeginSourceFileAction may change CurrentInput, e.g. during module builds.
1063  setCurrentInput(WrappedAction->getCurrentInput());
1064  return Ret;
1065 }
1067  WrappedAction->ExecuteAction();
1068 }
1070  WrappedAction->EndSourceFileAction();
1071 }
1072 
1074  return WrappedAction->usesPreprocessorOnly();
1075 }
1077  return WrappedAction->getTranslationUnitKind();
1078 }
1080  return WrappedAction->hasPCHSupport();
1081 }
1083  return WrappedAction->hasASTFileSupport();
1084 }
1086  return WrappedAction->hasIRSupport();
1087 }
1089  return WrappedAction->hasCodeCompletionSupport();
1090 }
1091 
1093  std::unique_ptr<FrontendAction> WrappedAction)
1094  : WrappedAction(std::move(WrappedAction)) {}
1095 
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:916
Defines the clang::ASTContext interface.
static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts, const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts, StringRef ExistingModuleCachePath)
Determine whether the given AST file is acceptable to load into a translation unit with the given lan...
Definition: ASTReader.cpp:4954
static unsigned getSpelling(const Token &Tok, const char *&Buffer, const SourceManager &SourceMgr, const LangOptions &LangOpts, bool *Invalid=nullptr)
getSpelling - This method is used to get the spelling of a token into a preallocated buffer...
Definition: Lexer.cpp:388
void setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap)
Definition: ModuleMap.cpp:1231
LangOptions & getLangOpts()
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred...
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
PreprocessorOptions & getPreprocessorOpts()
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens...
Definition: Lexer.h:76
bool hasErrorOccurred() const
Definition: Diagnostic.h:748
Smart pointer class that efficiently represents Objective-C method names.
SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders
Headers that are mentioned in the module map file but could not be found on the file system...
Definition: Module.h:194
A (possibly-)qualified type.
Definition: Type.h:643
const char * getDeclKindName() const
Definition: DeclBase.cpp:122
FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
Create the file manager and replace any existing one with it.
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:560
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
IntrusiveRefCntPtr< ExternalSemaSource > createChainedIncludesSource(CompilerInstance &CI, IntrusiveRefCntPtr< ExternalSemaSource > &Reader)
The ChainedIncludesSource class converts headers to chained PCHs in memory, mainly for testing...
void PrintStats() const
Print some statistics to stderr that indicate how well the hashing is doing.
void EndSourceFile()
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
submodule_iterator submodule_begin()
Definition: Module.h:563
TypePropertyCache< Private > Cache
Definition: Type.cpp:3597
virtual bool hasIRSupport() const
Does this action support use with IR files?
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
Format getFormat() const
unsigned IsExternC
Whether this is an &#39;extern "C"&#39; module (which implicitly puts all headers in it within an &#39;extern "C"...
Definition: Module.h:237
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Load everything, including Sema.
Definition: ASTUnit.h:678
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
void EndSourceFile()
Inform the preprocessor callbacks that processing is complete.
StringRef P
virtual bool usesPreprocessorOnly() const =0
Does this action only use the preprocessor?
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Provide a default implementation which returns aborts; this method should never be called by Frontend...
virtual bool hasASTFileSupport() const
Does this action support use with AST files?
DiagnosticsEngine & getDiagnostics() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1296
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file...
virtual void IdentifierRead(serialization::IdentID ID, IdentifierInfo *II)
An identifier was deserialized from the AST file.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
ASTContext & getASTContext() const
void setModuleManager(IntrusiveRefCntPtr< ASTReader > Reader)
static SourceLocation ReadOriginalFileName(CompilerInstance &CI, std::string &InputFile, bool IsModuleMap=false)
For preprocessed files, if the first line is the linemarker and specifies the original source file na...
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
virtual void EndSourceFile()
Callback to inform the diagnostic client that processing of a source file has ended.
Definition: Diagnostic.h:1521
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:660
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:913
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
Definition: Module.h:101
long i
Definition: xmmintrin.h:1456
tok::TokenKind getKind() const
Definition: Token.h:92
One of these records is kept for each identifier that is lexed.
static StringRef getModuleInputBufferName()
Definition: Module.h:581
virtual void ReaderInitialized(ASTReader *Reader)
The ASTReader was initialized.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
Record the location of a macro definition.
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
void resolveHeaderDirectives(const FileEntry *File) const
Resolve all lazy header directives for the specified file.
Definition: ModuleMap.cpp:1150
Definition: Format.h:2261
Module * getCurrentModule() const
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:489
bool isHeaderUnavailableInModule(const FileEntry *Header, const Module *RequestingModule) const
Determine whether the given header is unavailable as part of the specified module.
Definition: ModuleMap.cpp:672
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
CodeGenOptions & getCodeGenOpts()
void finishModuleDeclarationScope()
Creates a new declaration scope for module names, allowing previously defined modules to shadow defin...
Definition: ModuleMap.h:562
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:903
Compiling a module from a module map.
Definition: LangOptions.h:78
std::vector< std::string > ModulesEmbedFiles
The list of files to embed into the compiled module file.
Describes a module or submodule.
Definition: Module.h:64
Execute the action before the main action.
CompilerInstance & getCompilerInstance() const
bool hasPCHSupport() const override
Does this action support use with PCH?
Action is determined by the cc1 command-line.
unsigned ShowStats
Show frontend performance metrics and statistics.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:213
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:908
FrontendOptions & getFrontendOpts()
static std::unique_ptr< ASTUnit > LoadFromASTFile(const std::string &Filename, const PCHContainerReader &PCHContainerRdr, WhatToLoad ToLoad, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, const FileSystemOptions &FileSystemOpts, bool UseDebugInfo=false, bool OnlyLocalDecls=false, ArrayRef< RemappedFile > RemappedFiles=None, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, bool AllowPCHWithCompilerErrors=false, bool UserFilesAreVolatile=false)
Create a ASTUnit from an AST file.
Definition: ASTUnit.cpp:755
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1657
StringRef getCurrentFileOrBufferName() const
Load options and the preprocessor state.
Definition: ASTUnit.h:672
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:148
Module * Parent
The parent of this module.
Definition: Module.h:92
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
Definition: Module.h:240
static Module * prepareToBuildModule(CompilerInstance &CI, StringRef ModuleMapFilename)
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value...
unsigned SkipFunctionBodies
Skip over function bodies to speed up parsing in cases you do not need them (e.g. ...
bool loadModuleMapFile(const FileEntry *File, bool IsSystem, FileID ID=FileID(), unsigned *Offset=nullptr, StringRef OriginalModuleMapFile=StringRef())
Read the contents of the given module map file.
submodule_iterator submodule_end()
Definition: Module.h:565
virtual bool BeginInvocation(CompilerInstance &CI)
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
InputKind getKind() const
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
bool BeginInvocation(CompilerInstance &CI) override
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
HeaderSearchOptions & getHeaderSearchOpts()
bool DisablePCHValidation
When true, disables most of the normal validation performed on precompiled headers.
CodeCompleteConsumer & getCodeCompletionConsumer() const
static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem, bool IsPreprocessed, std::string &PresumedModuleMapFile, unsigned &Offset)
virtual void SelectorRead(serialization::SelectorID iD, Selector Sel)
A selector was read from the AST file.
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.
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:158
void initializeForReplay(const SourceManager &Old)
Initialize this source manager suitably to replay the compilation described by Old.
StringRef getModuleCachePath() const
Retrieve the path to the module cache.
Definition: HeaderSearch.h:334
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
virtual void DeclRead(serialization::DeclID ID, const Decl *D)
A decl was deserialized from the AST file.
llvm::Registry< PluginASTAction > FrontendPluginRegistry
The frontend plugin registry.
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:227
const DirectoryEntry * getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
StringRef Filename
Definition: Format.cpp:1709
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
void setCurrentInput(const FrontendInputFile &CurrentInput, std::unique_ptr< ASTUnit > AST=nullptr)
void setFileIsTransient(const FileEntry *SourceFile)
Specify that a file is transient.
IntrusiveRefCntPtr< ASTReader > getModuleManager() const
unsigned Offset
Definition: Format.cpp:1711
bool hasIRSupport() const override
Does this action support use with IR files?
SourceLocation End
std::string getSpecificModuleCachePath()
WrapperFrontendAction(std::unique_ptr< FrontendAction > WrappedAction)
Construct a WrapperFrontendAction from an existing action, taking ownership of it.
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
StateNode * Previous
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, unsigned LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
StringRef getFile() const
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:126
Defines the clang::Preprocessor interface.
Not compiling a module interface at all.
Definition: LangOptions.h:75
void createASTContext()
Create the AST context.
virtual void EndSourceFileAction()
Callback at the end of processing a single input.
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we&#39;re handling.
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M)
Check that the given module is available, producing a diagnostic if not.
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:107
unsigned ModulesEmbedAllFiles
Whether we should embed all used files into the PCM file.
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
bool PrepareToExecuteAction(CompilerInstance &CI) override
Prepare to execute the action on the given CompilerInstance.
An input file for the front end.
virtual std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile)=0
Create the AST consumer object for this action, if supported.
bool isAvailable() const
Determine whether this module is available for use within the current translation unit...
Definition: Module.h:385
Information about a header directive as found in the module map file.
Definition: Module.h:157
virtual void ExecuteAction()=0
Callback to run the program action, using the initialized compiler instance.
void EndSourceFileAction() override
Callback at the end of processing a single input.
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:97
virtual bool hasPCHSupport() const
Does this action support use with PCH?
FileSystemOptions & getFileSystemOpts()
Kind
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
bool Execute()
Set the source manager&#39;s main input file, and run the action.
StringRef getName() const
Definition: FileManager.h:83
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input. ...
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we&#39;re handling.
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
virtual void MacroDefinitionRead(serialization::PreprocessedEntityID, MacroDefinitionRecord *MD)
A macro definition was read from the AST file.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
Information about a directory name as found in the module map file.
Definition: Module.h:166
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:910
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
SmallVector< Header, 2 > Headers[5]
The headers that are part of this module.
Definition: Module.h:174
void ParseAST(Preprocessor &pp, ASTConsumer *C, ASTContext &Ctx, bool PrintStats=false, TranslationUnitKind TUKind=TU_Complete, CodeCompleteConsumer *CompletionConsumer=nullptr, bool SkipFunctionBodies=false)
Parse the entire file specified, notifying the ASTConsumer as the file is parsed. ...
Definition: ParseAST.cpp:99
static std::error_code collectModuleHeaderIncludes(const LangOptions &LangOpts, FileManager &FileMgr, DiagnosticsEngine &Diag, ModuleMap &ModMap, clang::Module *Module, SmallVectorImpl< char > &Includes)
Collect the set of header includes needed to construct the given module and update the TopHeaders fil...
void initializeBuiltins(IdentifierTable &Table, const LangOptions &LangOpts)
Mark the identifiers for all the builtins with their appropriate builtin ID # and mark any non-portab...
Definition: Builtins.cpp:90
std::unordered_map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:268
Execute the action after the main action.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:777
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
virtual void TypeRead(serialization::TypeIdx Idx, QualType T)
A type was deserialized from the AST file.
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
Definition: ASTBitCodes.h:168
std::string OverrideRecordLayoutsFile
File name of the file that will provide record layouts (in the format produced by -fdump-record-layou...
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...
bool isNot(tok::TokenKind K) const
Definition: Token.h:98
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
Definition: ASTBitCodes.h:153
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
void setPreprocessor(std::shared_ptr< Preprocessor > Value)
Replace the current preprocessor.
FileManager & getFileManager() const
Return the current file manager to the caller.
llvm::Timer & getFrontendTimer() const
const FrontendInputFile & getCurrentInput() const
Language getLanguage() const
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
ModuleFile & getPrimaryModule()
Returns the primary module associated with the manager, that is, the first module loaded...
void PrintStats() const
Print statistics to stderr.
FileID getMainFileID() const
Returns the FileID of the main source file.
StringRef getCurrentFile() const
bool loadModuleFile(StringRef FileName)
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1090
void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind)
Add a line note to the line table for the FileID and offset specified by Loc.
SourceManager & getSourceManager() const
Return the current source manager.
void addTopHeader(const FileEntry *File)
Add a top-level header associated with this module.
Definition: Module.h:502
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1081
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
TargetInfo & getTarget() const
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:134
bool hasASTFileSupport() const override
Does this action support use with AST files?
void visitTopLevelModuleMaps(serialization::ModuleFile &MF, llvm::function_ref< void(const FileEntry *)> Visitor)
Visit all the top-level module maps loaded when building the given module file.
Definition: ASTReader.cpp:9326
void setCompilerInstance(CompilerInstance *Value)
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:238
std::vector< std::string > AddPluginActions
The list of plugin actions to run in addition to the normal action.
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:45
unsigned DisableFree
Disable memory freeing on exit.
The type-property cache.
Definition: Type.cpp:3551
Preprocessor & getPreprocessor() const
Return the current preprocessor.
bool hasCodeCompletionConsumer() const
DiagnosticConsumer & getDiagnosticClient() const
An external AST source that overrides the layout of a specified set of record types.
virtual bool BeginSourceFileAction(CompilerInstance &CI)
Callback at the start of processing a single input.
void setMainFileDir(const DirectoryEntry *Dir)
Set the directory in which the main file should be considered to have been found, if it is not a real...
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:362
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
A SourceLocation and its associated SourceManager.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
bool isCurrentFileAST() const
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
static std::unique_ptr< llvm::MemoryBuffer > getInputBufferForModule(CompilerInstance &CI, Module *M)
Compute the input buffer that should be used to build the specified module.
static ErrorCode writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)
Write a global index into the given.
void setAllFilesAreTransient(bool Transient)
Specify that all files that are read during this compilation are transient.
void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine)
Instruct the preprocessor to skip part of the main source file.
This represents a decl that may have a name.
Definition: Decl.h:248
bool DumpDeserializedPCHDecls
Dump declarations that are deserialized from PCH, for testing.
virtual void BeginSourceFile(const LangOptions &LangOpts, const Preprocessor *PP=nullptr)
Callback to inform the diagnostic client that processing of a source file is beginning.
Definition: Diagnostic.h:1513
static SmallVectorImpl< char > & operator+=(SmallVectorImpl< char > &Includes, StringRef RHS)
TargetOptions & getTargetOpts()
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:722
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: FileManager.h:224
This class handles loading and caching of source files into memory.
static void addHeaderInclude(StringRef HeaderName, SmallVectorImpl< char > &Includes, const LangOptions &LangOpts, bool IsExternC)
A type index; the type ID with the qualifier bits removed.
Definition: ASTBitCodes.h:88
SourceLocation getLocation() const
Definition: DeclBase.h:429
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:124
virtual bool isModelParsingAction() const
Is this action invoked on a model file?
std::vector< std::string > ModuleMapFiles
The list of module map files to load before processing the input.