clang  12.0.0git
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/Basic/Builtins.h"
15 #include "clang/Frontend/ASTUnit.h"
21 #include "clang/Frontend/Utils.h"
22 #include "clang/Lex/HeaderSearch.h"
24 #include "clang/Lex/Preprocessor.h"
26 #include "clang/Parse/ParseAST.h"
30 #include "llvm/Support/BuryPointer.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/FileSystem.h"
33 #include "llvm/Support/Path.h"
34 #include "llvm/Support/Timer.h"
35 #include "llvm/Support/raw_ostream.h"
36 #include <system_error>
37 using namespace clang;
38 
39 LLVM_INSTANTIATE_REGISTRY(FrontendPluginRegistry)
40 
41 namespace {
42 
43 class DelegatingDeserializationListener : public ASTDeserializationListener {
45  bool DeletePrevious;
46 
47 public:
48  explicit DelegatingDeserializationListener(
49  ASTDeserializationListener *Previous, bool DeletePrevious)
50  : Previous(Previous), DeletePrevious(DeletePrevious) {}
51  ~DelegatingDeserializationListener() override {
52  if (DeletePrevious)
53  delete Previous;
54  }
55 
56  void ReaderInitialized(ASTReader *Reader) override {
57  if (Previous)
58  Previous->ReaderInitialized(Reader);
59  }
60  void IdentifierRead(serialization::IdentID ID,
61  IdentifierInfo *II) override {
62  if (Previous)
63  Previous->IdentifierRead(ID, II);
64  }
65  void TypeRead(serialization::TypeIdx Idx, QualType T) override {
66  if (Previous)
67  Previous->TypeRead(Idx, T);
68  }
69  void DeclRead(serialization::DeclID ID, const Decl *D) override {
70  if (Previous)
71  Previous->DeclRead(ID, D);
72  }
73  void SelectorRead(serialization::SelectorID ID, Selector Sel) override {
74  if (Previous)
75  Previous->SelectorRead(ID, Sel);
76  }
77  void MacroDefinitionRead(serialization::PreprocessedEntityID PPID,
78  MacroDefinitionRecord *MD) override {
79  if (Previous)
80  Previous->MacroDefinitionRead(PPID, MD);
81  }
82 };
83 
84 /// Dumps deserialized declarations.
85 class DeserializedDeclsDumper : public DelegatingDeserializationListener {
86 public:
87  explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous,
88  bool DeletePrevious)
89  : DelegatingDeserializationListener(Previous, DeletePrevious) {}
90 
91  void DeclRead(serialization::DeclID ID, const Decl *D) override {
92  llvm::outs() << "PCH DECL: " << D->getDeclKindName();
93  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
94  llvm::outs() << " - ";
95  ND->printQualifiedName(llvm::outs());
96  }
97  llvm::outs() << "\n";
98 
99  DelegatingDeserializationListener::DeclRead(ID, D);
100  }
101 };
102 
103 /// Checks deserialized declarations and emits error if a name
104 /// matches one given in command-line using -error-on-deserialized-decl.
105 class DeserializedDeclsChecker : public DelegatingDeserializationListener {
106  ASTContext &Ctx;
107  std::set<std::string> NamesToCheck;
108 
109 public:
110  DeserializedDeclsChecker(ASTContext &Ctx,
111  const std::set<std::string> &NamesToCheck,
112  ASTDeserializationListener *Previous,
113  bool DeletePrevious)
114  : DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx),
115  NamesToCheck(NamesToCheck) {}
116 
117  void DeclRead(serialization::DeclID ID, const Decl *D) override {
118  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
119  if (NamesToCheck.find(ND->getNameAsString()) != NamesToCheck.end()) {
120  unsigned DiagID
122  "%0 was deserialized");
123  Ctx.getDiagnostics().Report(Ctx.getFullLoc(D->getLocation()), DiagID)
124  << ND->getNameAsString();
125  }
126 
127  DelegatingDeserializationListener::DeclRead(ID, D);
128  }
129 };
130 
131 } // end anonymous namespace
132 
133 FrontendAction::FrontendAction() : Instance(nullptr) {}
134 
136 
138  std::unique_ptr<ASTUnit> AST) {
139  this->CurrentInput = CurrentInput;
140  CurrentASTUnit = std::move(AST);
141 }
142 
146  CI.getLangOpts().CurrentModule, /*AllowSearch*/false);
147 }
148 
149 std::unique_ptr<ASTConsumer>
150 FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
151  StringRef InFile) {
152  std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
153  if (!Consumer)
154  return nullptr;
155 
156  // Validate -add-plugin args.
157  bool FoundAllPlugins = true;
158  for (const std::string &Arg : CI.getFrontendOpts().AddPluginActions) {
159  bool Found = false;
160  for (const FrontendPluginRegistry::entry &Plugin :
161  FrontendPluginRegistry::entries()) {
162  if (Plugin.getName() == Arg)
163  Found = true;
164  }
165  if (!Found) {
166  CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name) << Arg;
167  FoundAllPlugins = false;
168  }
169  }
170  if (!FoundAllPlugins)
171  return nullptr;
172 
173  // If there are no registered plugins we don't need to wrap the consumer
174  if (FrontendPluginRegistry::begin() == FrontendPluginRegistry::end())
175  return Consumer;
176 
177  // If this is a code completion run, avoid invoking the plugin consumers
178  if (CI.hasCodeCompletionConsumer())
179  return Consumer;
180 
181  // Collect the list of plugins that go before the main action (in Consumers)
182  // or after it (in AfterConsumers)
183  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
184  std::vector<std::unique_ptr<ASTConsumer>> AfterConsumers;
185  for (const FrontendPluginRegistry::entry &Plugin :
186  FrontendPluginRegistry::entries()) {
187  std::unique_ptr<PluginASTAction> P = Plugin.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  if (llvm::any_of(CI.getFrontendOpts().AddPluginActions,
193  [&](const std::string &PluginAction) {
194  return PluginAction == Plugin.getName();
195  }))
197  }
198  if ((ActionType == PluginASTAction::AddBeforeMainAction ||
199  ActionType == PluginASTAction::AddAfterMainAction) &&
200  P->ParseArgs(
201  CI,
202  CI.getFrontendOpts().PluginArgs[std::string(Plugin.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 std::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();
365  for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
366  Dir != End && !EC; Dir.increment(EC)) {
367  // Check whether this entry has an extension typically associated with
368  // headers.
369  if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
370  .Cases(".h", ".H", ".hh", ".hpp", true)
371  .Default(false))
372  continue;
373 
374  auto Header = FileMgr.getFile(Dir->path());
375  // FIXME: This shouldn't happen unless there is a file system race. Is
376  // that worth diagnosing?
377  if (!Header)
378  continue;
379 
380  // If this header is marked 'unavailable' in this module, don't include
381  // it.
382  if (ModMap.isHeaderUnavailableInModule(*Header, Module))
383  continue;
384 
385  // Compute the relative path from the directory to this file.
386  SmallVector<StringRef, 16> Components;
387  auto PathIt = llvm::sys::path::rbegin(Dir->path());
388  for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
389  Components.push_back(*PathIt);
390  SmallString<128> RelativeHeader(UmbrellaDir.NameAsWritten);
391  for (auto It = Components.rbegin(), End = Components.rend(); It != End;
392  ++It)
393  llvm::sys::path::append(RelativeHeader, *It);
394 
395  std::string RelName = RelativeHeader.c_str();
396  Headers.push_back(std::make_pair(RelName, *Header));
397  }
398 
399  if (EC)
400  return EC;
401 
402  // Sort header paths and make the header inclusion order deterministic
403  // across different OSs and filesystems.
404  llvm::sort(Headers.begin(), Headers.end(), [](
405  const std::pair<std::string, const FileEntry *> &LHS,
406  const std::pair<std::string, const FileEntry *> &RHS) {
407  return LHS.first < RHS.first;
408  });
409  for (auto &H : Headers) {
410  // Include this header as part of the umbrella directory.
411  Module->addTopHeader(H.second);
412  addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC);
413  }
414  }
415 
416  // Recurse into submodules.
418  SubEnd = Module->submodule_end();
419  Sub != SubEnd; ++Sub)
420  if (std::error_code Err = collectModuleHeaderIncludes(
421  LangOpts, FileMgr, Diag, ModMap, *Sub, Includes))
422  return Err;
423 
424  return std::error_code();
425 }
426 
427 static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem,
428  bool IsPreprocessed,
429  std::string &PresumedModuleMapFile,
430  unsigned &Offset) {
431  auto &SrcMgr = CI.getSourceManager();
433 
434  // Map the current input to a file.
435  FileID ModuleMapID = SrcMgr.getMainFileID();
436  const FileEntry *ModuleMap = SrcMgr.getFileEntryForID(ModuleMapID);
437 
438  // If the module map is preprocessed, handle the initial line marker;
439  // line directives are not part of the module map syntax in general.
440  Offset = 0;
441  if (IsPreprocessed) {
442  SourceLocation EndOfLineMarker =
443  ReadOriginalFileName(CI, PresumedModuleMapFile, /*IsModuleMap*/ true);
444  if (EndOfLineMarker.isValid())
445  Offset = CI.getSourceManager().getDecomposedLoc(EndOfLineMarker).second;
446  }
447 
448  // Load the module map file.
449  if (HS.loadModuleMapFile(ModuleMap, IsSystem, ModuleMapID, &Offset,
450  PresumedModuleMapFile))
451  return true;
452 
453  if (SrcMgr.getBuffer(ModuleMapID)->getBufferSize() == Offset)
454  Offset = 0;
455 
456  return false;
457 }
458 
460  StringRef ModuleMapFilename) {
461  if (CI.getLangOpts().CurrentModule.empty()) {
462  CI.getDiagnostics().Report(diag::err_missing_module_name);
463 
464  // FIXME: Eventually, we could consider asking whether there was just
465  // a single module described in the module map, and use that as a
466  // default. Then it would be fairly trivial to just "compile" a module
467  // map with a single module (the common case).
468  return nullptr;
469  }
470 
471  // Dig out the module definition.
474  /*AllowSearch=*/false);
475  if (!M) {
476  CI.getDiagnostics().Report(diag::err_missing_module)
477  << CI.getLangOpts().CurrentModule << ModuleMapFilename;
478 
479  return nullptr;
480  }
481 
482  // Check whether we can build this module at all.
484  CI.getDiagnostics(), M))
485  return nullptr;
486 
487  // Inform the preprocessor that includes from within the input buffer should
488  // be resolved relative to the build directory of the module map file.
490 
491  // If the module was inferred from a different module map (via an expanded
492  // umbrella module definition), track that fact.
493  // FIXME: It would be preferable to fill this in as part of processing
494  // the module map, rather than adding it after the fact.
495  StringRef OriginalModuleMapName = CI.getFrontendOpts().OriginalModuleMap;
496  if (!OriginalModuleMapName.empty()) {
497  auto OriginalModuleMap =
498  CI.getFileManager().getFile(OriginalModuleMapName,
499  /*openFile*/ true);
500  if (!OriginalModuleMap) {
501  CI.getDiagnostics().Report(diag::err_module_map_not_found)
502  << OriginalModuleMapName;
503  return nullptr;
504  }
505  if (*OriginalModuleMap != CI.getSourceManager().getFileEntryForID(
507  M->IsInferred = true;
509  .setInferredModuleAllowedBy(M, *OriginalModuleMap);
510  }
511  }
512 
513  // If we're being run from the command-line, the module build stack will not
514  // have been filled in yet, so complete it now in order to allow us to detect
515  // module cycles.
516  SourceManager &SourceMgr = CI.getSourceManager();
517  if (SourceMgr.getModuleBuildStack().empty())
519  FullSourceLoc(SourceLocation(), SourceMgr));
520  return M;
521 }
522 
523 /// Compute the input buffer that should be used to build the specified module.
524 static std::unique_ptr<llvm::MemoryBuffer>
526  FileManager &FileMgr = CI.getFileManager();
527 
528  // Collect the set of #includes we need to build the module.
529  SmallString<256> HeaderContents;
530  std::error_code Err = std::error_code();
531  if (Module::Header UmbrellaHeader = M->getUmbrellaHeader())
532  addHeaderInclude(UmbrellaHeader.NameAsWritten, HeaderContents,
533  CI.getLangOpts(), M->IsExternC);
535  CI.getLangOpts(), FileMgr, CI.getDiagnostics(),
537  HeaderContents);
538 
539  if (Err) {
540  CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
541  << M->getFullModuleName() << Err.message();
542  return nullptr;
543  }
544 
545  return llvm::MemoryBuffer::getMemBufferCopy(
546  HeaderContents, Module::getModuleInputBufferName());
547 }
548 
550  const FrontendInputFile &RealInput) {
551  FrontendInputFile Input(RealInput);
552  assert(!Instance && "Already processing a source file!");
553  assert(!Input.isEmpty() && "Unexpected empty filename!");
554  setCurrentInput(Input);
555  setCompilerInstance(&CI);
556 
557  bool HasBegunSourceFile = false;
558  bool ReplayASTFile = Input.getKind().getFormat() == InputKind::Precompiled &&
560  if (!BeginInvocation(CI))
561  goto failure;
562 
563  // If we're replaying the build of an AST file, import it and set up
564  // the initial state from its build.
565  if (ReplayASTFile) {
567 
568  // The AST unit populates its own diagnostics engine rather than ours.
570  new DiagnosticsEngine(Diags->getDiagnosticIDs(),
571  &Diags->getDiagnosticOptions()));
572  ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
573 
574  // FIXME: What if the input is a memory buffer?
575  StringRef InputFile = Input.getFile();
576 
577  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
578  std::string(InputFile), CI.getPCHContainerReader(),
580  CI.getCodeGenOpts().DebugTypeExtRefs);
581  if (!AST)
582  goto failure;
583 
584  // Options relating to how we treat the input (but not what we do with it)
585  // are inherited from the AST unit.
586  CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts();
587  CI.getPreprocessorOpts() = AST->getPreprocessorOpts();
588  CI.getLangOpts() = AST->getLangOpts();
589 
590  // Set the shared objects, these are reset when we finish processing the
591  // file, otherwise the CompilerInstance will happily destroy them.
592  CI.setFileManager(&AST->getFileManager());
594  CI.getSourceManager().initializeForReplay(AST->getSourceManager());
595 
596  // Preload all the module files loaded transitively by the AST unit. Also
597  // load all module map files that were parsed as part of building the AST
598  // unit.
599  if (auto ASTReader = AST->getASTReader()) {
600  auto &MM = ASTReader->getModuleManager();
601  auto &PrimaryModule = MM.getPrimaryModule();
602 
603  for (serialization::ModuleFile &MF : MM)
604  if (&MF != &PrimaryModule)
605  CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName);
606 
608  PrimaryModule, [&](const FileEntry *FE) {
609  CI.getFrontendOpts().ModuleMapFiles.push_back(
610  std::string(FE->getName()));
611  });
612  }
613 
614  // Set up the input file for replay purposes.
615  auto Kind = AST->getInputKind();
616  if (Kind.getFormat() == InputKind::ModuleMap) {
617  Module *ASTModule =
618  AST->getPreprocessor().getHeaderSearchInfo().lookupModule(
619  AST->getLangOpts().CurrentModule, /*AllowSearch*/ false);
620  assert(ASTModule && "module file does not define its own module");
621  Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind);
622  } else {
623  auto &OldSM = AST->getSourceManager();
624  FileID ID = OldSM.getMainFileID();
625  if (auto *File = OldSM.getFileEntryForID(ID))
626  Input = FrontendInputFile(File->getName(), Kind);
627  else
628  Input = FrontendInputFile(OldSM.getBuffer(ID), Kind);
629  }
630  setCurrentInput(Input, std::move(AST));
631  }
632 
633  // AST files follow a very different path, since they share objects via the
634  // AST unit.
635  if (Input.getKind().getFormat() == InputKind::Precompiled) {
636  assert(!usesPreprocessorOnly() && "this case was handled above");
637  assert(hasASTFileSupport() &&
638  "This action does not have AST file support!");
639 
641 
642  // FIXME: What if the input is a memory buffer?
643  StringRef InputFile = Input.getFile();
644 
645  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
646  std::string(InputFile), CI.getPCHContainerReader(),
648  CI.getCodeGenOpts().DebugTypeExtRefs);
649 
650  if (!AST)
651  goto failure;
652 
653  // Inform the diagnostic client we are processing a source file.
654  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
655  HasBegunSourceFile = true;
656 
657  // Set the shared objects, these are reset when we finish processing the
658  // file, otherwise the CompilerInstance will happily destroy them.
659  CI.setFileManager(&AST->getFileManager());
660  CI.setSourceManager(&AST->getSourceManager());
661  CI.setPreprocessor(AST->getPreprocessorPtr());
662  Preprocessor &PP = CI.getPreprocessor();
664  PP.getLangOpts());
665  CI.setASTContext(&AST->getASTContext());
666 
667  setCurrentInput(Input, std::move(AST));
668 
669  // Initialize the action.
670  if (!BeginSourceFileAction(CI))
671  goto failure;
672 
673  // Create the AST consumer.
674  CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
675  if (!CI.hasASTConsumer())
676  goto failure;
677 
678  return true;
679  }
680 
681  // Set up the file and source managers, if needed.
682  if (!CI.hasFileManager()) {
683  if (!CI.createFileManager()) {
684  goto failure;
685  }
686  }
687  if (!CI.hasSourceManager())
689 
690  // Set up embedding for any specified files. Do this before we load any
691  // source files, including the primary module map for the compilation.
692  for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
693  if (auto FE = CI.getFileManager().getFile(F, /*openFile*/true))
695  else
696  CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;
697  }
700 
701  // IR files bypass the rest of initialization.
702  if (Input.getKind().getLanguage() == Language::LLVM_IR) {
703  assert(hasIRSupport() &&
704  "This action does not have IR file support!");
705 
706  // Inform the diagnostic client we are processing a source file.
707  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
708  HasBegunSourceFile = true;
709 
710  // Initialize the action.
711  if (!BeginSourceFileAction(CI))
712  goto failure;
713 
714  // Initialize the main file entry.
715  if (!CI.InitializeSourceManager(CurrentInput))
716  goto failure;
717 
718  return true;
719  }
720 
721  // If the implicit PCH include is actually a directory, rather than
722  // a single file, search for a suitable PCH file in that directory.
723  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
724  FileManager &FileMgr = CI.getFileManager();
726  StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
727  std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
728  if (auto PCHDir = FileMgr.getDirectory(PCHInclude)) {
729  std::error_code EC;
730  SmallString<128> DirNative;
731  llvm::sys::path::native((*PCHDir)->getName(), DirNative);
732  bool Found = false;
733  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
734  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
735  DirEnd;
736  Dir != DirEnd && !EC; Dir.increment(EC)) {
737  // Check whether this is an acceptable AST file.
739  Dir->path(), FileMgr, CI.getPCHContainerReader(),
741  SpecificModuleCachePath)) {
742  PPOpts.ImplicitPCHInclude = std::string(Dir->path());
743  Found = true;
744  break;
745  }
746  }
747 
748  if (!Found) {
749  CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
750  goto failure;
751  }
752  }
753  }
754 
755  // Set up the preprocessor if needed. When parsing model files the
756  // preprocessor of the original source is reused.
757  if (!isModelParsingAction())
759 
760  // Inform the diagnostic client we are processing a source file.
762  &CI.getPreprocessor());
763  HasBegunSourceFile = true;
764 
765  // Initialize the main file entry.
766  if (!CI.InitializeSourceManager(Input))
767  goto failure;
768 
769  // For module map files, we first parse the module map and synthesize a
770  // "<module-includes>" buffer before more conventional processing.
771  if (Input.getKind().getFormat() == InputKind::ModuleMap) {
772  CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleMap);
773 
774  std::string PresumedModuleMapFile;
775  unsigned OffsetToContents;
776  if (loadModuleMapForModuleBuild(CI, Input.isSystem(),
777  Input.isPreprocessed(),
778  PresumedModuleMapFile, OffsetToContents))
779  goto failure;
780 
781  auto *CurrentModule = prepareToBuildModule(CI, Input.getFile());
782  if (!CurrentModule)
783  goto failure;
784 
785  CurrentModule->PresumedModuleMapFile = PresumedModuleMapFile;
786 
787  if (OffsetToContents)
788  // If the module contents are in the same file, skip to them.
789  CI.getPreprocessor().setSkipMainFilePreamble(OffsetToContents, true);
790  else {
791  // Otherwise, convert the module description to a suitable input buffer.
792  auto Buffer = getInputBufferForModule(CI, CurrentModule);
793  if (!Buffer)
794  goto failure;
795 
796  // Reinitialize the main file entry to refer to the new input.
797  auto Kind = CurrentModule->IsSystem ? SrcMgr::C_System : SrcMgr::C_User;
798  auto &SourceMgr = CI.getSourceManager();
799  auto BufferID = SourceMgr.createFileID(std::move(Buffer), Kind);
800  assert(BufferID.isValid() && "couldn't create module buffer ID");
801  SourceMgr.setMainFileID(BufferID);
802  }
803  }
804 
805  // Initialize the action.
806  if (!BeginSourceFileAction(CI))
807  goto failure;
808 
809  // If we were asked to load any module map files, do so now.
810  for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) {
811  if (auto File = CI.getFileManager().getFile(Filename))
813  *File, /*IsSystem*/false);
814  else
815  CI.getDiagnostics().Report(diag::err_module_map_not_found) << Filename;
816  }
817 
818  // Add a module declaration scope so that modules from -fmodule-map-file
819  // arguments may shadow modules found implicitly in search paths.
820  CI.getPreprocessor()
822  .getModuleMap()
824 
825  // Create the AST context and consumer unless this is a preprocessor only
826  // action.
827  if (!usesPreprocessorOnly()) {
828  // Parsing a model file should reuse the existing ASTContext.
829  if (!isModelParsingAction())
830  CI.createASTContext();
831 
832  // For preprocessed files, check if the first line specifies the original
833  // source file name with a linemarker.
834  std::string PresumedInputFile = std::string(getCurrentFileOrBufferName());
835  if (Input.isPreprocessed())
836  ReadOriginalFileName(CI, PresumedInputFile);
837 
838  std::unique_ptr<ASTConsumer> Consumer =
839  CreateWrappedASTConsumer(CI, PresumedInputFile);
840  if (!Consumer)
841  goto failure;
842 
843  // FIXME: should not overwrite ASTMutationListener when parsing model files?
844  if (!isModelParsingAction())
845  CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
846 
847  if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
848  // Convert headers to PCH and chain them.
849  IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
850  source = createChainedIncludesSource(CI, FinalReader);
851  if (!source)
852  goto failure;
853  CI.setASTReader(static_cast<ASTReader *>(FinalReader.get()));
854  CI.getASTContext().setExternalSource(source);
855  } else if (CI.getLangOpts().Modules ||
856  !CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
857  // Use PCM or PCH.
858  assert(hasPCHSupport() && "This action does not have PCH support!");
859  ASTDeserializationListener *DeserialListener =
860  Consumer->GetASTDeserializationListener();
861  bool DeleteDeserialListener = false;
863  DeserialListener = new DeserializedDeclsDumper(DeserialListener,
864  DeleteDeserialListener);
865  DeleteDeserialListener = true;
866  }
868  DeserialListener = new DeserializedDeclsChecker(
869  CI.getASTContext(),
871  DeserialListener, DeleteDeserialListener);
872  DeleteDeserialListener = true;
873  }
874  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
878  CI.getPreprocessorOpts().AllowPCHWithCompilerErrors, DeserialListener,
879  DeleteDeserialListener);
880  if (!CI.getASTContext().getExternalSource())
881  goto failure;
882  }
883  // If modules are enabled, create the AST reader before creating
884  // any builtins, so that all declarations know that they might be
885  // extended by an external source.
886  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
888  CI.createASTReader();
889  CI.getASTReader()->setDeserializationListener(DeserialListener,
890  DeleteDeserialListener);
891  }
892  }
893 
894  CI.setASTConsumer(std::move(Consumer));
895  if (!CI.hasASTConsumer())
896  goto failure;
897  }
898 
899  // Initialize built-in info as long as we aren't using an external AST
900  // source.
901  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
903  Preprocessor &PP = CI.getPreprocessor();
905  PP.getLangOpts());
906  } else {
907  // FIXME: If this is a problem, recover from it by creating a multiplex
908  // source.
909  assert((!CI.getLangOpts().Modules || CI.getASTReader()) &&
910  "modules enabled but created an external source that "
911  "doesn't support modules");
912  }
913 
914  // If we were asked to load any module files, do so now.
915  for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
916  if (!CI.loadModuleFile(ModuleFile))
917  goto failure;
918 
919  // If there is a layout overrides file, attach an external AST source that
920  // provides the layouts from that file.
921  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
924  Override(new LayoutOverrideSource(
926  CI.getASTContext().setExternalSource(Override);
927  }
928 
929  return true;
930 
931  // If we failed, reset state since the client will not end up calling the
932  // matching EndSourceFile().
933 failure:
934  if (HasBegunSourceFile)
936  CI.clearOutputFiles(/*EraseFiles=*/true);
937  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
939  setCompilerInstance(nullptr);
940  return false;
941 }
942 
945 
946  if (CI.hasFrontendTimer()) {
947  llvm::TimeRegion Timer(CI.getFrontendTimer());
948  ExecuteAction();
949  }
950  else ExecuteAction();
951 
952  // If we are supposed to rebuild the global module index, do so now unless
953  // there were any module-build failures.
954  if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
955  CI.hasPreprocessor()) {
956  StringRef Cache =
958  if (!Cache.empty()) {
961  // FIXME this drops the error on the floor, but
962  // Index/pch-from-libclang.c seems to rely on dropping at least some of
963  // the error conditions!
964  consumeError(std::move(Err));
965  }
966  }
967  }
968 
969  return llvm::Error::success();
970 }
971 
974 
975  // Inform the diagnostic client we are done with this source file.
977 
978  // Inform the preprocessor we are done.
979  if (CI.hasPreprocessor())
981 
982  // Finalize the action.
984 
985  // Sema references the ast consumer, so reset sema first.
986  //
987  // FIXME: There is more per-file stuff we could just drop here?
988  bool DisableFree = CI.getFrontendOpts().DisableFree;
989  if (DisableFree) {
990  CI.resetAndLeakSema();
992  llvm::BuryPointer(CI.takeASTConsumer().get());
993  } else {
994  CI.setSema(nullptr);
995  CI.setASTContext(nullptr);
996  CI.setASTConsumer(nullptr);
997  }
998 
999  if (CI.getFrontendOpts().ShowStats) {
1000  llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFile() << "':\n";
1001  CI.getPreprocessor().PrintStats();
1005  llvm::errs() << "\n";
1006  }
1007 
1008  // Cleanup the output streams, and erase the output files if instructed by the
1009  // FrontendAction.
1010  CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
1011 
1012  if (isCurrentFileAST()) {
1013  if (DisableFree) {
1017  llvm::BuryPointer(std::move(CurrentASTUnit));
1018  } else {
1019  CI.setPreprocessor(nullptr);
1020  CI.setSourceManager(nullptr);
1021  CI.setFileManager(nullptr);
1022  }
1023  }
1024 
1025  setCompilerInstance(nullptr);
1027  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
1028 }
1029 
1032 }
1033 
1034 //===----------------------------------------------------------------------===//
1035 // Utility Actions
1036 //===----------------------------------------------------------------------===//
1037 
1040  if (!CI.hasPreprocessor())
1041  return;
1042 
1043  // FIXME: Move the truncation aspect of this into Sema, we delayed this till
1044  // here so the source manager would be initialized.
1045  if (hasCodeCompletionSupport() &&
1048 
1049  // Use a code completion consumer?
1050  CodeCompleteConsumer *CompletionConsumer = nullptr;
1051  if (CI.hasCodeCompletionConsumer())
1052  CompletionConsumer = &CI.getCodeCompletionConsumer();
1053 
1054  if (!CI.hasSema())
1055  CI.createSema(getTranslationUnitKind(), CompletionConsumer);
1056 
1059 }
1060 
1061 void PluginASTAction::anchor() { }
1062 
1063 std::unique_ptr<ASTConsumer>
1065  StringRef InFile) {
1066  llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
1067 }
1068 
1070  return WrappedAction->PrepareToExecuteAction(CI);
1071 }
1072 std::unique_ptr<ASTConsumer>
1074  StringRef InFile) {
1075  return WrappedAction->CreateASTConsumer(CI, InFile);
1076 }
1078  return WrappedAction->BeginInvocation(CI);
1079 }
1081  WrappedAction->setCurrentInput(getCurrentInput());
1082  WrappedAction->setCompilerInstance(&CI);
1083  auto Ret = WrappedAction->BeginSourceFileAction(CI);
1084  // BeginSourceFileAction may change CurrentInput, e.g. during module builds.
1085  setCurrentInput(WrappedAction->getCurrentInput());
1086  return Ret;
1087 }
1089  WrappedAction->ExecuteAction();
1090 }
1092  WrappedAction->EndSourceFileAction();
1093 }
1095  return WrappedAction->shouldEraseOutputFiles();
1096 }
1097 
1099  return WrappedAction->usesPreprocessorOnly();
1100 }
1102  return WrappedAction->getTranslationUnitKind();
1103 }
1105  return WrappedAction->hasPCHSupport();
1106 }
1108  return WrappedAction->hasASTFileSupport();
1109 }
1111  return WrappedAction->hasIRSupport();
1112 }
1114  return WrappedAction->hasCodeCompletionSupport();
1115 }
1116 
1118  std::unique_ptr<FrontendAction> WrappedAction)
1119  : WrappedAction(std::move(WrappedAction)) {}
1120 
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
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:5422
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:398
void setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap)
Definition: ModuleMap.cpp:1262
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:757
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:217
A (possibly-)qualified type.
Definition: Type.h:655
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
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:603
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:172
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:606
TypePropertyCache< Private > Cache
Definition: Type.cpp:3747
virtual bool hasIRSupport() const
Does this action support use with IR files?
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...
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:262
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:89
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:1330
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
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:1558
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:665
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:925
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
IntrusiveRefCntPtr< ASTReader > getASTReader() const
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
Definition: Module.h:124
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:624
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:174
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.
static llvm::Error writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)
Write a global index into the given.
void resolveHeaderDirectives(const FileEntry *File) const
Resolve all lazy header directives for the specified file.
Definition: ModuleMap.cpp:1181
Definition: Format.h:2679
Module * getCurrentModule() const
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
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:536
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:695
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:577
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:54
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:915
Compiling a module from a module map.
Definition: LangOptions.h:84
std::vector< std::string > ModulesEmbedFiles
The list of files to embed into the compiled module file.
Describes a module or submodule.
Definition: Module.h:87
Execute the action before the main action.
CompilerInstance & getCompilerInstance() const
bool hasPCHSupport() const override
Does this action support use with PCH?
llvm::ErrorOr< const DirectoryEntry * > getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
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:225
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:920
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:756
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1674
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:153
Module * Parent
The parent of this module.
Definition: Module.h:115
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
Definition: Module.h:265
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:608
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:328
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:274
StringRef Filename
Definition: Format.cpp:2018
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.
unsigned Offset
Definition: Format.cpp:2020
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
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:81
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: ModuleFile.h:106
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:432
Information about a header directive as found in the module map file.
Definition: Module.h:180
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:120
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.
StringRef getName() const
Definition: FileManager.h:103
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.
static bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
Definition: Interp.cpp:34
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Information about a directory name as found in the module map file.
Definition: Module.h:189
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:922
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:79
SmallVector< Header, 2 > Headers[5]
The headers that are part of this module.
Definition: Module.h:197
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:89
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:786
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
llvm::Error Execute()
Set the source manager&#39;s main input file, and run the action.
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:340
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:1026
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.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1017
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
Run a plugin action,.
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
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:9175
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:250
void setASTReader(IntrusiveRefCntPtr< ASTReader > Reader)
std::vector< std::string > AddPluginActions
The list of plugin actions to run in addition to the normal action.
unsigned DisableFree
Disable memory freeing on exit.
The type-property cache.
Definition: Type.cpp:3701
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...
void addTopHeader(const FileEntry *File)
Add a top-level header associated with this module.
Definition: Module.cpp:257
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:541
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
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
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.
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:223
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:1550
static SmallVectorImpl< char > & operator+=(SmallVectorImpl< char > &Includes, StringRef RHS)
TargetOptions & getTargetOpts()
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:676
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: FileManager.h:356
This class handles loading and caching of source files into memory.
static void addHeaderInclude(StringRef HeaderName, SmallVectorImpl< char > &Includes, const LangOptions &LangOpts, bool IsExternC)
Defines enum values for all the target-independent builtin functions.
bool Sub(InterpState &S, CodePtr OpPC)
Definition: Interp.h:140
A type index; the type ID with the qualifier bits removed.
Definition: ASTBitCodes.h:88
SourceLocation getLocation() const
Definition: DeclBase.h:430
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:128
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.