clang  14.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/ADT/ScopeExit.h"
31 #include "llvm/Support/BuryPointer.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/FileSystem.h"
34 #include "llvm/Support/Path.h"
35 #include "llvm/Support/Timer.h"
36 #include "llvm/Support/raw_ostream.h"
37 #include <system_error>
38 using namespace clang;
39 
40 LLVM_INSTANTIATE_REGISTRY(FrontendPluginRegistry)
41 
42 namespace {
43 
44 class DelegatingDeserializationListener : public ASTDeserializationListener {
46  bool DeletePrevious;
47 
48 public:
49  explicit DelegatingDeserializationListener(
50  ASTDeserializationListener *Previous, bool DeletePrevious)
51  : Previous(Previous), DeletePrevious(DeletePrevious) {}
52  ~DelegatingDeserializationListener() override {
53  if (DeletePrevious)
54  delete Previous;
55  }
56 
57  void ReaderInitialized(ASTReader *Reader) override {
58  if (Previous)
59  Previous->ReaderInitialized(Reader);
60  }
61  void IdentifierRead(serialization::IdentID ID,
62  IdentifierInfo *II) override {
63  if (Previous)
64  Previous->IdentifierRead(ID, II);
65  }
66  void TypeRead(serialization::TypeIdx Idx, QualType T) override {
67  if (Previous)
68  Previous->TypeRead(Idx, T);
69  }
70  void DeclRead(serialization::DeclID ID, const Decl *D) override {
71  if (Previous)
72  Previous->DeclRead(ID, D);
73  }
74  void SelectorRead(serialization::SelectorID ID, Selector Sel) override {
75  if (Previous)
76  Previous->SelectorRead(ID, Sel);
77  }
78  void MacroDefinitionRead(serialization::PreprocessedEntityID PPID,
79  MacroDefinitionRecord *MD) override {
80  if (Previous)
81  Previous->MacroDefinitionRead(PPID, MD);
82  }
83 };
84 
85 /// Dumps deserialized declarations.
86 class DeserializedDeclsDumper : public DelegatingDeserializationListener {
87 public:
88  explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous,
89  bool DeletePrevious)
90  : DelegatingDeserializationListener(Previous, DeletePrevious) {}
91 
92  void DeclRead(serialization::DeclID ID, const Decl *D) override {
93  llvm::outs() << "PCH DECL: " << D->getDeclKindName();
94  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
95  llvm::outs() << " - ";
96  ND->printQualifiedName(llvm::outs());
97  }
98  llvm::outs() << "\n";
99 
100  DelegatingDeserializationListener::DeclRead(ID, D);
101  }
102 };
103 
104 /// Checks deserialized declarations and emits error if a name
105 /// matches one given in command-line using -error-on-deserialized-decl.
106 class DeserializedDeclsChecker : public DelegatingDeserializationListener {
107  ASTContext &Ctx;
108  std::set<std::string> NamesToCheck;
109 
110 public:
111  DeserializedDeclsChecker(ASTContext &Ctx,
112  const std::set<std::string> &NamesToCheck,
114  bool DeletePrevious)
115  : DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx),
116  NamesToCheck(NamesToCheck) {}
117 
118  void DeclRead(serialization::DeclID ID, const Decl *D) override {
119  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
120  if (NamesToCheck.find(ND->getNameAsString()) != NamesToCheck.end()) {
121  unsigned DiagID
123  "%0 was deserialized");
124  Ctx.getDiagnostics().Report(Ctx.getFullLoc(D->getLocation()), DiagID)
125  << ND;
126  }
127 
128  DelegatingDeserializationListener::DeclRead(ID, D);
129  }
130 };
131 
132 } // end anonymous namespace
133 
134 FrontendAction::FrontendAction() : Instance(nullptr) {}
135 
137 
139  std::unique_ptr<ASTUnit> AST) {
140  this->CurrentInput = CurrentInput;
141  CurrentASTUnit = std::move(AST);
142 }
143 
147  CI.getLangOpts().CurrentModule, /*AllowSearch*/false);
148 }
149 
150 std::unique_ptr<ASTConsumer>
151 FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
152  StringRef InFile) {
153  std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
154  if (!Consumer)
155  return nullptr;
156 
157  // Validate -add-plugin args.
158  bool FoundAllPlugins = true;
159  for (const std::string &Arg : CI.getFrontendOpts().AddPluginActions) {
160  bool Found = false;
161  for (const FrontendPluginRegistry::entry &Plugin :
162  FrontendPluginRegistry::entries()) {
163  if (Plugin.getName() == Arg)
164  Found = true;
165  }
166  if (!Found) {
167  CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name) << Arg;
168  FoundAllPlugins = false;
169  }
170  }
171  if (!FoundAllPlugins)
172  return nullptr;
173 
174  // If there are no registered plugins we don't need to wrap the consumer
175  if (FrontendPluginRegistry::begin() == FrontendPluginRegistry::end())
176  return Consumer;
177 
178  // If this is a code completion run, avoid invoking the plugin consumers
179  if (CI.hasCodeCompletionConsumer())
180  return Consumer;
181 
182  // Collect the list of plugins that go before the main action (in Consumers)
183  // or after it (in AfterConsumers)
184  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
185  std::vector<std::unique_ptr<ASTConsumer>> AfterConsumers;
186  for (const FrontendPluginRegistry::entry &Plugin :
187  FrontendPluginRegistry::entries()) {
188  std::unique_ptr<PluginASTAction> P = Plugin.instantiate();
189  PluginASTAction::ActionType ActionType = P->getActionType();
190  if (ActionType == PluginASTAction::Cmdline) {
191  // This is O(|plugins| * |add_plugins|), but since both numbers are
192  // way below 50 in practice, that's ok.
193  if (llvm::any_of(CI.getFrontendOpts().AddPluginActions,
194  [&](const std::string &PluginAction) {
195  return PluginAction == Plugin.getName();
196  }))
198  }
199  if ((ActionType == PluginASTAction::AddBeforeMainAction ||
200  ActionType == PluginASTAction::AddAfterMainAction) &&
201  P->ParseArgs(
202  CI,
203  CI.getFrontendOpts().PluginArgs[std::string(Plugin.getName())])) {
204  std::unique_ptr<ASTConsumer> PluginConsumer = P->CreateASTConsumer(CI, InFile);
205  if (ActionType == PluginASTAction::AddBeforeMainAction) {
206  Consumers.push_back(std::move(PluginConsumer));
207  } else {
208  AfterConsumers.push_back(std::move(PluginConsumer));
209  }
210  }
211  }
212 
213  // Add to Consumers the main consumer, then all the plugins that go after it
214  Consumers.push_back(std::move(Consumer));
215  for (auto &C : AfterConsumers) {
216  Consumers.push_back(std::move(C));
217  }
218 
219  return std::make_unique<MultiplexConsumer>(std::move(Consumers));
220 }
221 
222 /// For preprocessed files, if the first line is the linemarker and specifies
223 /// the original source file name, use that name as the input file name.
224 /// Returns the location of the first token after the line marker directive.
225 ///
226 /// \param CI The compiler instance.
227 /// \param InputFile Populated with the filename from the line marker.
228 /// \param IsModuleMap If \c true, add a line note corresponding to this line
229 /// directive. (We need to do this because the directive will not be
230 /// visited by the preprocessor.)
232  std::string &InputFile,
233  bool IsModuleMap = false) {
234  auto &SourceMgr = CI.getSourceManager();
235  auto MainFileID = SourceMgr.getMainFileID();
236 
237  auto MainFileBuf = SourceMgr.getBufferOrNone(MainFileID);
238  if (!MainFileBuf)
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.
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.PathRelativeToRootModuleDirectory, Includes, LangOpts,
347  Module->IsExternC);
348  }
349  }
350  // Note that Module->PrivateHeaders will not be a TopHeader.
351 
352  if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
353  Module->addTopHeader(UmbrellaHeader.Entry);
354  if (Module->Parent)
355  // Include the umbrella header for submodules.
356  addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory,
357  Includes, LangOpts, Module->IsExternC);
358  } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
359  // Add all of the headers we find in this subdirectory.
360  std::error_code EC;
361  SmallString<128> DirNative;
362  llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative);
363 
364  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
366  for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
367  Dir != End && !EC; Dir.increment(EC)) {
368  // Check whether this entry has an extension typically associated with
369  // headers.
370  if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
371  .Cases(".h", ".H", ".hh", ".hpp", true)
372  .Default(false))
373  continue;
374 
375  auto Header = FileMgr.getFile(Dir->path());
376  // FIXME: This shouldn't happen unless there is a file system race. Is
377  // that worth diagnosing?
378  if (!Header)
379  continue;
380 
381  // If this header is marked 'unavailable' in this module, don't include
382  // it.
383  if (ModMap.isHeaderUnavailableInModule(*Header, Module))
384  continue;
385 
386  // Compute the relative path from the directory to this file.
387  SmallVector<StringRef, 16> Components;
388  auto PathIt = llvm::sys::path::rbegin(Dir->path());
389  for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
390  Components.push_back(*PathIt);
391  SmallString<128> RelativeHeader(
392  UmbrellaDir.PathRelativeToRootModuleDirectory);
393  for (auto It = Components.rbegin(), End = Components.rend(); It != End;
394  ++It)
395  llvm::sys::path::append(RelativeHeader, *It);
396 
397  std::string RelName = RelativeHeader.c_str();
398  Headers.push_back(std::make_pair(RelName, *Header));
399  }
400 
401  if (EC)
402  return EC;
403 
404  // Sort header paths and make the header inclusion order deterministic
405  // across different OSs and filesystems.
406  llvm::sort(Headers.begin(), Headers.end(), [](
407  const std::pair<std::string, const FileEntry *> &LHS,
408  const std::pair<std::string, const FileEntry *> &RHS) {
409  return LHS.first < RHS.first;
410  });
411  for (auto &H : Headers) {
412  // Include this header as part of the umbrella directory.
413  Module->addTopHeader(H.second);
414  addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC);
415  }
416  }
417 
418  // Recurse into submodules.
420  SubEnd = Module->submodule_end();
421  Sub != SubEnd; ++Sub)
422  if (std::error_code Err = collectModuleHeaderIncludes(
423  LangOpts, FileMgr, Diag, ModMap, *Sub, Includes))
424  return Err;
425 
426  return std::error_code();
427 }
428 
429 static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem,
430  bool IsPreprocessed,
431  std::string &PresumedModuleMapFile,
432  unsigned &Offset) {
433  auto &SrcMgr = CI.getSourceManager();
435 
436  // Map the current input to a file.
437  FileID ModuleMapID = SrcMgr.getMainFileID();
438  const FileEntry *ModuleMap = SrcMgr.getFileEntryForID(ModuleMapID);
439 
440  // If the module map is preprocessed, handle the initial line marker;
441  // line directives are not part of the module map syntax in general.
442  Offset = 0;
443  if (IsPreprocessed) {
444  SourceLocation EndOfLineMarker =
445  ReadOriginalFileName(CI, PresumedModuleMapFile, /*IsModuleMap*/ true);
446  if (EndOfLineMarker.isValid())
447  Offset = CI.getSourceManager().getDecomposedLoc(EndOfLineMarker).second;
448  }
449 
450  // Load the module map file.
451  if (HS.loadModuleMapFile(ModuleMap, IsSystem, ModuleMapID, &Offset,
452  PresumedModuleMapFile))
453  return true;
454 
455  if (SrcMgr.getBufferOrFake(ModuleMapID).getBufferSize() == Offset)
456  Offset = 0;
457 
458  return false;
459 }
460 
462  StringRef ModuleMapFilename) {
463  if (CI.getLangOpts().CurrentModule.empty()) {
464  CI.getDiagnostics().Report(diag::err_missing_module_name);
465 
466  // FIXME: Eventually, we could consider asking whether there was just
467  // a single module described in the module map, and use that as a
468  // default. Then it would be fairly trivial to just "compile" a module
469  // map with a single module (the common case).
470  return nullptr;
471  }
472 
473  // Dig out the module definition.
476  /*AllowSearch=*/true);
477  if (!M) {
478  CI.getDiagnostics().Report(diag::err_missing_module)
479  << CI.getLangOpts().CurrentModule << ModuleMapFilename;
480 
481  return nullptr;
482  }
483 
484  // Check whether we can build this module at all.
486  CI.getDiagnostics(), M))
487  return nullptr;
488 
489  // Inform the preprocessor that includes from within the input buffer should
490  // be resolved relative to the build directory of the module map file.
492 
493  // If the module was inferred from a different module map (via an expanded
494  // umbrella module definition), track that fact.
495  // FIXME: It would be preferable to fill this in as part of processing
496  // the module map, rather than adding it after the fact.
497  StringRef OriginalModuleMapName = CI.getFrontendOpts().OriginalModuleMap;
498  if (!OriginalModuleMapName.empty()) {
499  auto OriginalModuleMap =
500  CI.getFileManager().getFile(OriginalModuleMapName,
501  /*openFile*/ true);
502  if (!OriginalModuleMap) {
503  CI.getDiagnostics().Report(diag::err_module_map_not_found)
504  << OriginalModuleMapName;
505  return nullptr;
506  }
507  if (*OriginalModuleMap != CI.getSourceManager().getFileEntryForID(
509  M->IsInferred = true;
511  .setInferredModuleAllowedBy(M, *OriginalModuleMap);
512  }
513  }
514 
515  // If we're being run from the command-line, the module build stack will not
516  // have been filled in yet, so complete it now in order to allow us to detect
517  // module cycles.
518  SourceManager &SourceMgr = CI.getSourceManager();
519  if (SourceMgr.getModuleBuildStack().empty())
521  FullSourceLoc(SourceLocation(), SourceMgr));
522  return M;
523 }
524 
525 /// Compute the input buffer that should be used to build the specified module.
526 static std::unique_ptr<llvm::MemoryBuffer>
528  FileManager &FileMgr = CI.getFileManager();
529 
530  // Collect the set of #includes we need to build the module.
531  SmallString<256> HeaderContents;
532  std::error_code Err = std::error_code();
533  if (Module::Header UmbrellaHeader = M->getUmbrellaHeader())
534  addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory,
535  HeaderContents, CI.getLangOpts(), M->IsExternC);
537  CI.getLangOpts(), FileMgr, CI.getDiagnostics(),
539  HeaderContents);
540 
541  if (Err) {
542  CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
543  << M->getFullModuleName() << Err.message();
544  return nullptr;
545  }
546 
547  return llvm::MemoryBuffer::getMemBufferCopy(
548  HeaderContents, Module::getModuleInputBufferName());
549 }
550 
552  const FrontendInputFile &RealInput) {
553  FrontendInputFile Input(RealInput);
554  assert(!Instance && "Already processing a source file!");
555  assert(!Input.isEmpty() && "Unexpected empty filename!");
556  setCurrentInput(Input);
557  setCompilerInstance(&CI);
558 
559  bool HasBegunSourceFile = false;
560  bool ReplayASTFile = Input.getKind().getFormat() == InputKind::Precompiled &&
562 
563  // If we fail, reset state since the client will not end up calling the
564  // matching EndSourceFile(). All paths that return true should release this.
565  auto FailureCleanup = llvm::make_scope_exit([&]() {
566  if (HasBegunSourceFile)
568  CI.clearOutputFiles(/*EraseFiles=*/true);
569  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
571  setCompilerInstance(nullptr);
572  });
573 
574  if (!BeginInvocation(CI))
575  return false;
576 
577  // If we're replaying the build of an AST file, import it and set up
578  // the initial state from its build.
579  if (ReplayASTFile) {
581 
582  // The AST unit populates its own diagnostics engine rather than ours.
584  new DiagnosticsEngine(Diags->getDiagnosticIDs(),
585  &Diags->getDiagnosticOptions()));
586  ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
587 
588  // FIXME: What if the input is a memory buffer?
589  StringRef InputFile = Input.getFile();
590 
591  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
592  std::string(InputFile), CI.getPCHContainerReader(),
594  CI.getCodeGenOpts().DebugTypeExtRefs);
595  if (!AST)
596  return false;
597 
598  // Options relating to how we treat the input (but not what we do with it)
599  // are inherited from the AST unit.
600  CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts();
601  CI.getPreprocessorOpts() = AST->getPreprocessorOpts();
602  CI.getLangOpts() = AST->getLangOpts();
603 
604  // Set the shared objects, these are reset when we finish processing the
605  // file, otherwise the CompilerInstance will happily destroy them.
606  CI.setFileManager(&AST->getFileManager());
608  CI.getSourceManager().initializeForReplay(AST->getSourceManager());
609 
610  // Preload all the module files loaded transitively by the AST unit. Also
611  // load all module map files that were parsed as part of building the AST
612  // unit.
613  if (auto ASTReader = AST->getASTReader()) {
614  auto &MM = ASTReader->getModuleManager();
615  auto &PrimaryModule = MM.getPrimaryModule();
616 
617  for (serialization::ModuleFile &MF : MM)
618  if (&MF != &PrimaryModule)
619  CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName);
620 
622  PrimaryModule, [&](const FileEntry *FE) {
623  CI.getFrontendOpts().ModuleMapFiles.push_back(
624  std::string(FE->getName()));
625  });
626  }
627 
628  // Set up the input file for replay purposes.
629  auto Kind = AST->getInputKind();
630  if (Kind.getFormat() == InputKind::ModuleMap) {
631  Module *ASTModule =
632  AST->getPreprocessor().getHeaderSearchInfo().lookupModule(
633  AST->getLangOpts().CurrentModule, /*AllowSearch*/ false);
634  assert(ASTModule && "module file does not define its own module");
635  Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind);
636  } else {
637  auto &OldSM = AST->getSourceManager();
638  FileID ID = OldSM.getMainFileID();
639  if (auto *File = OldSM.getFileEntryForID(ID))
640  Input = FrontendInputFile(File->getName(), Kind);
641  else
642  Input = FrontendInputFile(OldSM.getBufferOrFake(ID), Kind);
643  }
644  setCurrentInput(Input, std::move(AST));
645  }
646 
647  // AST files follow a very different path, since they share objects via the
648  // AST unit.
649  if (Input.getKind().getFormat() == InputKind::Precompiled) {
650  assert(!usesPreprocessorOnly() && "this case was handled above");
651  assert(hasASTFileSupport() &&
652  "This action does not have AST file support!");
653 
655 
656  // FIXME: What if the input is a memory buffer?
657  StringRef InputFile = Input.getFile();
658 
659  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
660  std::string(InputFile), CI.getPCHContainerReader(),
662  CI.getCodeGenOpts().DebugTypeExtRefs);
663 
664  if (!AST)
665  return false;
666 
667  // Inform the diagnostic client we are processing a source file.
668  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
669  HasBegunSourceFile = true;
670 
671  // Set the shared objects, these are reset when we finish processing the
672  // file, otherwise the CompilerInstance will happily destroy them.
673  CI.setFileManager(&AST->getFileManager());
674  CI.setSourceManager(&AST->getSourceManager());
675  CI.setPreprocessor(AST->getPreprocessorPtr());
676  Preprocessor &PP = CI.getPreprocessor();
678  PP.getLangOpts());
679  CI.setASTContext(&AST->getASTContext());
680 
681  setCurrentInput(Input, std::move(AST));
682 
683  // Initialize the action.
684  if (!BeginSourceFileAction(CI))
685  return false;
686 
687  // Create the AST consumer.
688  CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
689  if (!CI.hasASTConsumer())
690  return false;
691 
692  FailureCleanup.release();
693  return true;
694  }
695 
696  // Set up the file and source managers, if needed.
697  if (!CI.hasFileManager()) {
698  if (!CI.createFileManager()) {
699  return false;
700  }
701  }
702  if (!CI.hasSourceManager())
704 
705  // Set up embedding for any specified files. Do this before we load any
706  // source files, including the primary module map for the compilation.
707  for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
708  if (auto FE = CI.getFileManager().getFile(F, /*openFile*/true))
710  else
711  CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;
712  }
715 
716  // IR files bypass the rest of initialization.
717  if (Input.getKind().getLanguage() == Language::LLVM_IR) {
718  assert(hasIRSupport() &&
719  "This action does not have IR file support!");
720 
721  // Inform the diagnostic client we are processing a source file.
722  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
723  HasBegunSourceFile = true;
724 
725  // Initialize the action.
726  if (!BeginSourceFileAction(CI))
727  return false;
728 
729  // Initialize the main file entry.
730  if (!CI.InitializeSourceManager(CurrentInput))
731  return false;
732 
733  FailureCleanup.release();
734  return true;
735  }
736 
737  // If the implicit PCH include is actually a directory, rather than
738  // a single file, search for a suitable PCH file in that directory.
739  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
740  FileManager &FileMgr = CI.getFileManager();
742  StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
743  std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
744  if (auto PCHDir = FileMgr.getDirectory(PCHInclude)) {
745  std::error_code EC;
746  SmallString<128> DirNative;
747  llvm::sys::path::native((*PCHDir)->getName(), DirNative);
748  bool Found = false;
749  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
750  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
751  DirEnd;
752  Dir != DirEnd && !EC; Dir.increment(EC)) {
753  // Check whether this is an acceptable AST file.
755  Dir->path(), FileMgr, CI.getPCHContainerReader(),
757  SpecificModuleCachePath)) {
758  PPOpts.ImplicitPCHInclude = std::string(Dir->path());
759  Found = true;
760  break;
761  }
762  }
763 
764  if (!Found) {
765  CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
766  return false;
767  }
768  }
769  }
770 
771  // Set up the preprocessor if needed. When parsing model files the
772  // preprocessor of the original source is reused.
773  if (!isModelParsingAction())
775 
776  // Inform the diagnostic client we are processing a source file.
778  &CI.getPreprocessor());
779  HasBegunSourceFile = true;
780 
781  // Initialize the main file entry.
782  if (!CI.InitializeSourceManager(Input))
783  return false;
784 
785  // For module map files, we first parse the module map and synthesize a
786  // "<module-includes>" buffer before more conventional processing.
787  if (Input.getKind().getFormat() == InputKind::ModuleMap) {
788  CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleMap);
789 
790  std::string PresumedModuleMapFile;
791  unsigned OffsetToContents;
792  if (loadModuleMapForModuleBuild(CI, Input.isSystem(),
793  Input.isPreprocessed(),
794  PresumedModuleMapFile, OffsetToContents))
795  return false;
796 
797  auto *CurrentModule = prepareToBuildModule(CI, Input.getFile());
798  if (!CurrentModule)
799  return false;
800 
801  CurrentModule->PresumedModuleMapFile = PresumedModuleMapFile;
802 
803  if (OffsetToContents)
804  // If the module contents are in the same file, skip to them.
805  CI.getPreprocessor().setSkipMainFilePreamble(OffsetToContents, true);
806  else {
807  // Otherwise, convert the module description to a suitable input buffer.
808  auto Buffer = getInputBufferForModule(CI, CurrentModule);
809  if (!Buffer)
810  return false;
811 
812  // Reinitialize the main file entry to refer to the new input.
813  auto Kind = CurrentModule->IsSystem ? SrcMgr::C_System : SrcMgr::C_User;
814  auto &SourceMgr = CI.getSourceManager();
815  auto BufferID = SourceMgr.createFileID(std::move(Buffer), Kind);
816  assert(BufferID.isValid() && "couldn't create module buffer ID");
817  SourceMgr.setMainFileID(BufferID);
818  }
819  }
820 
821  // Initialize the action.
822  if (!BeginSourceFileAction(CI))
823  return false;
824 
825  // If we were asked to load any module map files, do so now.
826  for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) {
827  if (auto File = CI.getFileManager().getFile(Filename))
829  *File, /*IsSystem*/false);
830  else
831  CI.getDiagnostics().Report(diag::err_module_map_not_found) << Filename;
832  }
833 
834  // Add a module declaration scope so that modules from -fmodule-map-file
835  // arguments may shadow modules found implicitly in search paths.
836  CI.getPreprocessor()
838  .getModuleMap()
840 
841  // Create the AST context and consumer unless this is a preprocessor only
842  // action.
843  if (!usesPreprocessorOnly()) {
844  // Parsing a model file should reuse the existing ASTContext.
845  if (!isModelParsingAction())
846  CI.createASTContext();
847 
848  // For preprocessed files, check if the first line specifies the original
849  // source file name with a linemarker.
850  std::string PresumedInputFile = std::string(getCurrentFileOrBufferName());
851  if (Input.isPreprocessed())
852  ReadOriginalFileName(CI, PresumedInputFile);
853 
854  std::unique_ptr<ASTConsumer> Consumer =
855  CreateWrappedASTConsumer(CI, PresumedInputFile);
856  if (!Consumer)
857  return false;
858 
859  // FIXME: should not overwrite ASTMutationListener when parsing model files?
860  if (!isModelParsingAction())
861  CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
862 
863  if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
864  // Convert headers to PCH and chain them.
865  IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
866  source = createChainedIncludesSource(CI, FinalReader);
867  if (!source)
868  return false;
869  CI.setASTReader(static_cast<ASTReader *>(FinalReader.get()));
870  CI.getASTContext().setExternalSource(source);
871  } else if (CI.getLangOpts().Modules ||
872  !CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
873  // Use PCM or PCH.
874  assert(hasPCHSupport() && "This action does not have PCH support!");
875  ASTDeserializationListener *DeserialListener =
876  Consumer->GetASTDeserializationListener();
877  bool DeleteDeserialListener = false;
879  DeserialListener = new DeserializedDeclsDumper(DeserialListener,
880  DeleteDeserialListener);
881  DeleteDeserialListener = true;
882  }
884  DeserialListener = new DeserializedDeclsChecker(
885  CI.getASTContext(),
887  DeserialListener, DeleteDeserialListener);
888  DeleteDeserialListener = true;
889  }
890  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
895  DeserialListener, DeleteDeserialListener);
896  if (!CI.getASTContext().getExternalSource())
897  return false;
898  }
899  // If modules are enabled, create the AST reader before creating
900  // any builtins, so that all declarations know that they might be
901  // extended by an external source.
902  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
904  CI.createASTReader();
905  CI.getASTReader()->setDeserializationListener(DeserialListener,
906  DeleteDeserialListener);
907  }
908  }
909 
910  CI.setASTConsumer(std::move(Consumer));
911  if (!CI.hasASTConsumer())
912  return false;
913  }
914 
915  // Initialize built-in info as long as we aren't using an external AST
916  // source.
917  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
919  Preprocessor &PP = CI.getPreprocessor();
921  PP.getLangOpts());
922  } else {
923  // FIXME: If this is a problem, recover from it by creating a multiplex
924  // source.
925  assert((!CI.getLangOpts().Modules || CI.getASTReader()) &&
926  "modules enabled but created an external source that "
927  "doesn't support modules");
928  }
929 
930  // If we were asked to load any module files, do so now.
931  for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
932  if (!CI.loadModuleFile(ModuleFile))
933  return false;
934 
935  // If there is a layout overrides file, attach an external AST source that
936  // provides the layouts from that file.
937  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
940  Override(new LayoutOverrideSource(
942  CI.getASTContext().setExternalSource(Override);
943  }
944 
945  FailureCleanup.release();
946  return true;
947 }
948 
949 llvm::Error FrontendAction::Execute() {
951 
952  if (CI.hasFrontendTimer()) {
953  llvm::TimeRegion Timer(CI.getFrontendTimer());
954  ExecuteAction();
955  }
956  else ExecuteAction();
957 
958  // If we are supposed to rebuild the global module index, do so now unless
959  // there were any module-build failures.
960  if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
961  CI.hasPreprocessor()) {
962  StringRef Cache =
964  if (!Cache.empty()) {
965  if (llvm::Error Err = GlobalModuleIndex::writeIndex(
967  // FIXME this drops the error on the floor, but
968  // Index/pch-from-libclang.c seems to rely on dropping at least some of
969  // the error conditions!
970  consumeError(std::move(Err));
971  }
972  }
973  }
974 
975  return llvm::Error::success();
976 }
977 
980 
981  // Inform the diagnostic client we are done with this source file.
983 
984  // Inform the preprocessor we are done.
985  if (CI.hasPreprocessor())
987 
988  // Finalize the action.
990 
991  // Sema references the ast consumer, so reset sema first.
992  //
993  // FIXME: There is more per-file stuff we could just drop here?
994  bool DisableFree = CI.getFrontendOpts().DisableFree;
995  if (DisableFree) {
996  CI.resetAndLeakSema();
998  llvm::BuryPointer(CI.takeASTConsumer().get());
999  } else {
1000  CI.setSema(nullptr);
1001  CI.setASTContext(nullptr);
1002  CI.setASTConsumer(nullptr);
1003  }
1004 
1005  if (CI.getFrontendOpts().ShowStats) {
1006  llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFile() << "':\n";
1007  CI.getPreprocessor().PrintStats();
1011  llvm::errs() << "\n";
1012  }
1013 
1014  // Cleanup the output streams, and erase the output files if instructed by the
1015  // FrontendAction.
1016  CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
1017 
1018  if (isCurrentFileAST()) {
1019  if (DisableFree) {
1023  llvm::BuryPointer(std::move(CurrentASTUnit));
1024  } else {
1025  CI.setPreprocessor(nullptr);
1026  CI.setSourceManager(nullptr);
1027  CI.setFileManager(nullptr);
1028  }
1029  }
1030 
1031  setCompilerInstance(nullptr);
1033  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
1034 }
1035 
1038 }
1039 
1040 //===----------------------------------------------------------------------===//
1041 // Utility Actions
1042 //===----------------------------------------------------------------------===//
1043 
1046  if (!CI.hasPreprocessor())
1047  return;
1048 
1049  // FIXME: Move the truncation aspect of this into Sema, we delayed this till
1050  // here so the source manager would be initialized.
1051  if (hasCodeCompletionSupport() &&
1054 
1055  // Use a code completion consumer?
1056  CodeCompleteConsumer *CompletionConsumer = nullptr;
1057  if (CI.hasCodeCompletionConsumer())
1058  CompletionConsumer = &CI.getCodeCompletionConsumer();
1059 
1060  if (!CI.hasSema())
1061  CI.createSema(getTranslationUnitKind(), CompletionConsumer);
1062 
1065 }
1066 
1067 void PluginASTAction::anchor() { }
1068 
1069 std::unique_ptr<ASTConsumer>
1071  StringRef InFile) {
1072  llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
1073 }
1074 
1076  return WrappedAction->PrepareToExecuteAction(CI);
1077 }
1078 std::unique_ptr<ASTConsumer>
1080  StringRef InFile) {
1081  return WrappedAction->CreateASTConsumer(CI, InFile);
1082 }
1084  return WrappedAction->BeginInvocation(CI);
1085 }
1087  WrappedAction->setCurrentInput(getCurrentInput());
1088  WrappedAction->setCompilerInstance(&CI);
1089  auto Ret = WrappedAction->BeginSourceFileAction(CI);
1090  // BeginSourceFileAction may change CurrentInput, e.g. during module builds.
1091  setCurrentInput(WrappedAction->getCurrentInput());
1092  return Ret;
1093 }
1095  WrappedAction->ExecuteAction();
1096 }
1099  WrappedAction->EndSourceFileAction();
1100 }
1102  return WrappedAction->shouldEraseOutputFiles();
1103 }
1104 
1106  return WrappedAction->usesPreprocessorOnly();
1107 }
1109  return WrappedAction->getTranslationUnitKind();
1110 }
1112  return WrappedAction->hasPCHSupport();
1113 }
1115  return WrappedAction->hasASTFileSupport();
1116 }
1118  return WrappedAction->hasIRSupport();
1119 }
1121  return WrappedAction->hasCodeCompletionSupport();
1122 }
1123 
1125  std::unique_ptr<FrontendAction> WrappedAction)
1126  : WrappedAction(std::move(WrappedAction)) {}
1127 
clang::CompilerInstance::setASTConsumer
void setASTConsumer(std::unique_ptr< ASTConsumer > Value)
setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value.
Definition: CompilerInstance.cpp:183
clang::WrapperFrontendAction::ExecuteAction
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Definition: FrontendAction.cpp:1094
clang::ModuleMap::finishModuleDeclarationScope
void finishModuleDeclarationScope()
Creates a new declaration scope for module names, allowing previously defined modules to shadow defin...
Definition: ModuleMap.h:576
clang::CompilerInstance::hasSema
bool hasSema() const
Definition: CompilerInstance.h:500
clang::FrontendOptions::ModuleMapFiles
std::vector< std::string > ModuleMapFiles
The list of module map files to load before processing the input.
Definition: FrontendOptions.h:423
Builtins.h
clang::LangOptions::CurrentModule
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:343
clang::Preprocessor::setSkipMainFilePreamble
void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine)
Instruct the preprocessor to skip part of the main source file.
Definition: Preprocessor.h:1713
clang::FrontendOptions::AddPluginActions
std::vector< std::string > AddPluginActions
The list of plugin actions to run in addition to the normal action.
Definition: FrontendOptions.h:414
FrontendPluginRegistry.h
clang::serialization::TypeIdx
A type index; the type ID with the qualifier bits removed.
Definition: ASTBitCodes.h:88
clang::Preprocessor::PrintStats
void PrintStats()
Definition: Preprocessor.cpp:268
clang::GlobalModuleIndex::writeIndex
static llvm::Error writeIndex(FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, llvm::StringRef Path)
Write a global index into the given.
Definition: GlobalModuleIndex.cpp:852
clang::CompilerInstance::hasASTConsumer
bool hasASTConsumer() const
Definition: CompilerInstance.h:482
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:370
loadModuleMapForModuleBuild
static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem, bool IsPreprocessed, std::string &PresumedModuleMapFile, unsigned &Offset)
Definition: FrontendAction.cpp:429
clang::DeclaratorContext::File
@ File
clang::Module::getUmbrellaDir
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:246
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::PreprocessorOptions
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Definition: PreprocessorOptions.h:64
Ret
static bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
Definition: Interp.cpp:34
clang::FrontendInputFile::getKind
InputKind getKind() const
Definition: FrontendOptions.h:208
clang::HeaderSearch::lookupModule
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
Definition: HeaderSearch.cpp:232
Diag
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.
Definition: LiteralSupport.cpp:78
clang::PluginASTAction::AddAfterMainAction
@ AddAfterMainAction
Execute the action after the main action.
Definition: FrontendAction.h:276
clang::FrontendOptions::ShowStats
unsigned ShowStats
Show frontend performance metrics and statistics.
Definition: FrontendOptions.h:241
clang::Lexer::getSpelling
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:400
clang::FrontendAction::WrapperFrontendAction
friend class WrapperFrontendAction
Definition: FrontendAction.h:41
llvm::SmallVector
Definition: LLVM.h:38
clang::FrontendAction::isModelParsingAction
virtual bool isModelParsingAction() const
Is this action invoked on a model file?
Definition: FrontendAction.h:179
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::Module::getFullModuleName
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:221
clang::WrapperFrontendAction::hasCodeCompletionSupport
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
Definition: FrontendAction.cpp:1120
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:249
clang::CompilerInstance::setSema
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
Definition: CompilerInstance.cpp:179
clang::serialization::IdentID
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:134
clang::PreprocessorFrontendAction::CreateASTConsumer
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...
Definition: FrontendAction.cpp:1070
addHeaderInclude
static void addHeaderInclude(StringRef HeaderName, SmallVectorImpl< char > &Includes, const LangOptions &LangOpts, bool IsExternC)
Definition: FrontendAction.cpp:291
clang::FrontendOptions::PluginArgs
std::map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
Definition: FrontendOptions.h:411
clang::FrontendOptions::SkipFunctionBodies
unsigned SkipFunctionBodies
Skip over function bodies to speed up parsing in cases you do not need them (e.g.
Definition: FrontendOptions.h:269
clang::FrontendAction::hasIRSupport
virtual bool hasIRSupport() const
Does this action support use with IR files?
Definition: FrontendAction.h:197
clang::ASTContext::getFullLoc
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:777
clang::WrapperFrontendAction::getTranslationUnitKind
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we're handling.
Definition: FrontendAction.cpp:1108
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::FrontendAction::EndSourceFile
virtual void EndSourceFile()
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
Definition: FrontendAction.cpp:978
clang::Module::submodule_begin
submodule_iterator submodule_begin()
Definition: Module.h:623
clang::CompilerInstance::InitializeSourceManager
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file.
Definition: CompilerInstance.cpp:884
clang::CompilerInstance::getLangOpts
LangOptions & getLangOpts()
Definition: CompilerInstance.h:298
clang::WrapperFrontendAction::hasPCHSupport
bool hasPCHSupport() const override
Does this action support use with PCH?
Definition: FrontendAction.cpp:1111
Filename
StringRef Filename
Definition: Format.cpp:2333
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
clang::FrontendAction::getCurrentModule
Module * getCurrentModule() const
Definition: FrontendAction.cpp:144
clang::CompilerInstance::hasFrontendTimer
bool hasFrontendTimer() const
Definition: CompilerInstance.h:573
clang::FrontendAction::hasCodeCompletionSupport
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
Definition: FrontendAction.h:200
clang::FrontendInputFile
An input file for the front end.
Definition: FrontendOptions.h:185
clang::Token::isAtStartOfLine
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:268
collectModuleHeaderIncludes
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...
Definition: FrontendAction.cpp:316
clang::LangOptions::CMK_ModuleMap
@ CMK_ModuleMap
Compiling a module from a module map.
Definition: LangOptions.h:88
clang::FrontendAction::BeginInvocation
virtual bool BeginInvocation(CompilerInstance &CI)
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
Definition: FrontendAction.h:79
clang::StringLiteralParser::hadError
bool hadError
Definition: LiteralSupport.h:239
clang::SourceManager::PrintStats
void PrintStats() const
Print statistics to stderr.
Definition: SourceManager.cpp:2127
clang::PreprocessorOptions::DumpDeserializedPCHDecls
bool DumpDeserializedPCHDecls
Dump declarations that are deserialized from PCH, for testing.
Definition: PreprocessorOptions.h:114
clang::TypePropertyCache
The type-property cache.
Definition: Type.cpp:3776
clang::CompilerInstance::getFileSystemOpts
FileSystemOptions & getFileSystemOpts()
Definition: CompilerInstance.h:274
clang::SourceManager::AddLineNote
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.
Definition: SourceManager.cpp:272
ASTDeserializationListener.h
clang::SourceManager::pushModuleBuildStack
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
Definition: SourceManager.h:831
FrontendAction.h
clang::DiagnosticConsumer::EndSourceFile
virtual void EndSourceFile()
Callback to inform the diagnostic client that processing of a source file has ended.
Definition: Diagnostic.h:1739
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::CompilerInstance::getCodeGenOpts
CodeGenOptions & getCodeGenOpts()
Definition: CompilerInstance.h:253
LiteralSupport.h
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::frontend::PluginAction
@ PluginAction
Run a plugin action,.
Definition: FrontendOptions.h:109
clang::FrontendInputFile::getFile
StringRef getFile() const
Definition: FrontendOptions.h:216
clang::CompilerInstance::getPCHContainerReader
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
Definition: CompilerInstance.h:541
clang::CompilerInstance::createCodeCompletionConsumer
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
Definition: CompilerInstance.cpp:653
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:944
clang::Module::isAvailable
bool isAvailable() const
Determine whether this module is available for use within the current translation unit.
Definition: Module.h:443
clang::FrontendAction::hasASTFileSupport
virtual bool hasASTFileSupport() const
Does this action support use with AST files?
Definition: FrontendAction.h:194
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:626
clang::ModuleMap::setInferredModuleAllowedBy
void setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap)
Definition: ModuleMap.cpp:1269
clang::ParsedSourceLocation::FileName
std::string FileName
Definition: CommandLineSourceLoc.h:25
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:937
Preprocessor.h
clang::HeaderSearch
Encapsulates the information needed to find the file referenced by a #include or #include_next,...
Definition: HeaderSearch.h:169
clang::CompilerInstance::resetAndLeakSourceManager
void resetAndLeakSourceManager()
Definition: CompilerInstance.h:426
clang::Lexer
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.
Definition: Lexer.h:76
Offset
unsigned Offset
Definition: Format.cpp:2335
clang::FrontendOptions::OverrideRecordLayoutsFile
std::string OverrideRecordLayoutsFile
File name of the file that will provide record layouts (in the format produced by -fdump-record-layou...
Definition: FrontendOptions.h:441
clang::SourceManager::setAllFilesAreTransient
void setAllFilesAreTransient(bool Transient)
Specify that all files that are read during this compilation are transient.
Definition: SourceManager.h:999
clang::FrontendOptions::ModulesEmbedAllFiles
unsigned ModulesEmbedAllFiles
Whether we should embed all used files into the PCM file.
Definition: FrontendOptions.h:296
clang::CompilerInstance::getFileManager
FileManager & getFileManager() const
Return the current file manager to the caller.
Definition: CompilerInstance.h:401
clang::PluginASTAction::AddBeforeMainAction
@ AddBeforeMainAction
Execute the action before the main action.
Definition: FrontendAction.h:275
clang::ASTContext::getExternalSource
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1152
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::WrapperFrontendAction::hasIRSupport
bool hasIRSupport() const override
Does this action support use with IR files?
Definition: FrontendAction.cpp:1117
clang::FileManager::getVirtualFileSystem
llvm::vfs::FileSystem & getVirtualFileSystem() const
Definition: FileManager.h:243
clang::FrontendAction::~FrontendAction
virtual ~FrontendAction()
Definition: FrontendAction.cpp:136
clang::FrontendAction::getCurrentFileOrBufferName
StringRef getCurrentFileOrBufferName() const
Definition: FrontendAction.h:144
clang::Preprocessor::EndSourceFile
void EndSourceFile()
Inform the preprocessor callbacks that processing is complete.
Definition: Preprocessor.cpp:683
clang::LangOptions::CMK_None
@ CMK_None
Not compiling a module interface at all.
Definition: LangOptions.h:85
clang::CompilerInstance::resetAndLeakFileManager
void resetAndLeakFileManager()
Definition: CompilerInstance.h:406
clang::ASTReader::getModuleManager
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1692
clang::CompilerInstance::createASTReader
void createASTReader()
Definition: CompilerInstance.cpp:1557
clang::ASTUnit::LoadFromASTFile
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, CaptureDiagsKind CaptureDiagnostics=CaptureDiagsKind::None, bool AllowASTWithCompilerErrors=false, bool UserFilesAreVolatile=false)
Create a ASTUnit from an AST file.
Definition: ASTUnit.cpp:757
clang::DiagnosticsEngine::hasErrorOccurred
bool hasErrorOccurred() const
Definition: Diagnostic.h:833
clang::FrontendAction::BeginSourceFile
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
Definition: FrontendAction.cpp:551
clang::Token::getKind
tok::TokenKind getKind() const
Definition: Token.h:92
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:211
clang::HeaderSearch::loadModuleMapFile
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.
Definition: HeaderSearch.cpp:1517
clang::PreprocessorOptions::ChainedIncludes
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
Definition: PreprocessorOptions.h:99
clang::SourceManager::getMainFileID
FileID getMainFileID() const
Returns the FileID of the main source file.
Definition: SourceManager.h:840
clang::CompilerInstance::getSema
Sema & getSema() const
Definition: CompilerInstance.h:502
clang::DiagnosticsEngine::Error
@ Error
Definition: Diagnostic.h:199
Utils.h
clang::LayoutOverrideSource
An external AST source that overrides the layout of a specified set of record types.
Definition: LayoutOverrideSource.h:24
clang::ASTContext::setExternalSource
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:1037
clang::FrontendAction::hasPCHSupport
virtual bool hasPCHSupport() const
Does this action support use with PCH?
Definition: FrontendAction.h:191
clang::InputKind::getLanguage
Language getLanguage() const
Definition: FrontendOptions.h:163
clang::InputKind::Precompiled
@ Precompiled
Definition: FrontendOptions.h:156
clang::MacroDefinitionRecord
Record the location of a macro definition.
Definition: PreprocessingRecord.h:148
clang::FrontendAction::CreateASTConsumer
virtual std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile)=0
Create the AST consumer object for this action, if supported.
clang::PreprocessorOptions::AllowPCHWithCompilerErrors
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
Definition: PreprocessorOptions.h:107
clang::FrontendAction::getCompilerInstance
CompilerInstance & getCompilerInstance() const
Definition: FrontendAction.h:119
llvm::SmallString< 16 >
clang::PreprocessorOptions::DisablePCHOrModuleValidation
DisableValidationForModuleKind DisablePCHOrModuleValidation
Whether to disable most of the normal validation performed on precompiled headers and module files.
Definition: PreprocessorOptions.h:103
clang::CompilerInstance::resetAndLeakPreprocessor
void resetAndLeakPreprocessor()
Definition: CompilerInstance.h:448
ASTContext.h
clang::PluginASTAction::Cmdline
@ Cmdline
Action is determined by the cc1 command-line.
Definition: FrontendAction.h:273
clang::FrontendAction::shouldEraseOutputFiles
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
Definition: FrontendAction.cpp:1036
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:441
clang::Module::MissingHeaders
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:231
clang::FrontendAction::getTranslationUnitKind
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we're handling.
Definition: FrontendAction.h:188
clang::FrontendOptions::ModulesEmbedFiles
std::vector< std::string > ModulesEmbedFiles
The list of files to embed into the compiled module file.
Definition: FrontendOptions.h:430
clang::CompilerInstance::getASTContext
ASTContext & getASTContext() const
Definition: CompilerInstance.h:461
clang::SrcMgr::C_User
@ C_User
Definition: SourceManager.h:79
clang::CompilerInstance::hasFileManager
bool hasFileManager() const
Definition: CompilerInstance.h:398
clang::FrontendAction::setCurrentInput
void setCurrentInput(const FrontendInputFile &CurrentInput, std::unique_ptr< ASTUnit > AST=nullptr)
Definition: FrontendAction.cpp:138
clang::ASTReader::visitTopLevelModuleMaps
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:9121
prepareToBuildModule
static Module * prepareToBuildModule(CompilerInstance &CI, StringRef ModuleMapFilename)
Definition: FrontendAction.cpp:461
DeclGroup.h
clang::Token::isNot
bool isNot(tok::TokenKind K) const
Definition: Token.h:98
clang::CompilerInstance
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Definition: CompilerInstance.h:74
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
clang::SourceManager::getDecomposedLoc
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Definition: SourceManager.h:1236
clang::ModuleMap
Definition: ModuleMap.h:75
clang::CompilerInstance::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts()
Definition: CompilerInstance.h:305
clang::InputKind::getFormat
Format getFormat() const
Definition: FrontendOptions.h:164
clang::FrontendInputFile::isSystem
bool isSystem() const
Definition: FrontendOptions.h:209
clang::WrapperFrontendAction::BeginInvocation
bool BeginInvocation(CompilerInstance &CI) override
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
Definition: FrontendAction.cpp:1083
clang::Module::Parent
Module * Parent
The parent of this module.
Definition: Module.h:124
clang::serialization::PreprocessedEntityID
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
Definition: ASTBitCodes.h:168
clang::Module::PresumedModuleMapFile
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
Definition: Module.h:133
clang::CompilerInstance::setPreprocessor
void setPreprocessor(std::shared_ptr< Preprocessor > Value)
Replace the current preprocessor.
Definition: CompilerInstance.cpp:168
clang::CompilerInstance::setASTReader
void setASTReader(IntrusiveRefCntPtr< ASTReader > Reader)
Definition: CompilerInstance.cpp:201
clang::FrontendAction::getCurrentInput
const FrontendInputFile & getCurrentInput() const
Definition: FrontendAction.h:135
clang::InputKind::ModuleMap
@ ModuleMap
Definition: FrontendOptions.h:155
clang::FrontendAction::EndSourceFileAction
virtual void EndSourceFileAction()
Callback at the end of processing a single input.
Definition: FrontendAction.h:100
clang::Module::submodule_iterator
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:620
clang::CompilerInstance::getTargetOpts
TargetOptions & getTargetOpts()
Definition: CompilerInstance.h:319
clang::Module::HK_Normal
@ HK_Normal
Definition: Module.h:182
ParseAST.h
clang::FrontendAction::FrontendAction
FrontendAction()
Definition: FrontendAction.cpp:134
clang::CompilerInstance::takeASTConsumer
std::unique_ptr< ASTConsumer > takeASTConsumer()
takeASTConsumer - Remove the current AST consumer and give ownership to the caller.
Definition: CompilerInstance.h:491
clang::CompilerInstance::loadModuleFile
bool loadModuleFile(StringRef FileName)
Definition: CompilerInstance.cpp:1608
clang::Module::HK_Private
@ HK_Private
Definition: Module.h:184
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::FrontendInputFile::isPreprocessed
bool isPreprocessed() const
Definition: FrontendOptions.h:214
clang::Module::Directory
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:129
clang::Module::Headers
SmallVector< Header, 2 > Headers[5]
The headers that are part of this module.
Definition: Module.h:211
clang::DiagnosticConsumer::BeginSourceFile
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:1731
clang::CompilerInstance::getDiagnosticClient
DiagnosticConsumer & getDiagnosticClient() const
Definition: CompilerInstance.h:341
clang::Preprocessor::getBuiltinInfo
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:947
clang::ASTDeserializationListener
Definition: ASTDeserializationListener.h:30
clang::CompilerInstance::hasPreprocessor
bool hasPreprocessor() const
Definition: CompilerInstance.h:438
clang::WrapperFrontendAction::BeginSourceFileAction
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
Definition: FrontendAction.cpp:1086
LangStandard.h
clang::WrapperFrontendAction::usesPreprocessorOnly
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
Definition: FrontendAction.cpp:1105
clang::HeaderSearch::getModuleCachePath
StringRef getModuleCachePath() const
Retrieve the path to the module cache.
Definition: HeaderSearch.h:348
clang::CompilerInstance::hasCodeCompletionConsumer
bool hasCodeCompletionConsumer() const
Definition: CompilerInstance.h:557
clang::Language::LLVM_IR
@ LLVM_IR
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::FrontendAction::getCurrentFile
StringRef getCurrentFile() const
Definition: FrontendAction.h:139
clang::ASTUnit::LoadPreprocessorOnly
@ LoadPreprocessorOnly
Load options and the preprocessor state.
Definition: ASTUnit.h:672
getInputBufferForModule
static std::unique_ptr< llvm::MemoryBuffer > getInputBufferForModule(CompilerInstance &CI, Module *M)
Compute the input buffer that should be used to build the specified module.
Definition: FrontendAction.cpp:527
clang::CompilerInstance::getFrontendTimer
llvm::Timer & getFrontendTimer() const
Definition: CompilerInstance.h:575
HeaderSearch.h
clang::StringLiteralParser::GetString
StringRef GetString() const
Definition: LiteralSupport.h:242
clang::FrontendAction::Execute
llvm::Error Execute()
Set the source manager's main input file, and run the action.
Definition: FrontendAction.cpp:949
ASTUnit.h
clang::CodeCompleteConsumer
Abstract interface for a consumer of code-completion information.
Definition: CodeCompleteConsumer.h:1000
clang::PreprocessorOptions::DeserializedPCHDeclsToErrorOn
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...
Definition: PreprocessorOptions.h:118
GlobalModuleIndex.h
clang::ModuleMap::resolveHeaderDirectives
void resolveHeaderDirectives(const FileEntry *File) const
Resolve all lazy header directives for the specified file.
Definition: ModuleMap.cpp:1188
clang::FrontendPluginRegistry
llvm::Registry< PluginASTAction > FrontendPluginRegistry
The frontend plugin registry.
Definition: FrontendPluginRegistry.h:22
ASTConsumer.h
clang::serialization::ModuleManager::getPrimaryModule
ModuleFile & getPrimaryModule()
Returns the primary module associated with the manager, that is, the first module loaded.
Definition: ModuleManager.h:173
clang::CompilerInstance::resetAndLeakASTContext
void resetAndLeakASTContext()
Definition: CompilerInstance.h:466
clang::CompilerInstance::hasSourceManager
bool hasSourceManager() const
Definition: CompilerInstance.h:418
clang::WrapperFrontendAction::shouldEraseOutputFiles
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
Definition: FrontendAction.cpp:1101
clang::FrontendAction::ExecuteAction
virtual void ExecuteAction()=0
Callback to run the program action, using the initialized compiler instance.
clang::ModuleMap::isHeaderUnavailableInModule
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:696
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:67
clang::Token::getLocation
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:126
LayoutOverrideSource.h
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:58
clang::FrontendInputFile::isEmpty
bool isEmpty() const
Definition: FrontendOptions.h:211
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:342
std
Definition: Format.h:3899
clang::TranslationUnitKind
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:703
clang::FrontendOptions::ModuleFiles
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input.
Definition: FrontendOptions.h:427
clang::FrontendOptions::OriginalModuleMap
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred,...
Definition: FrontendOptions.h:390
clang::SourceManager::initializeForReplay
void initializeForReplay(const SourceManager &Old)
Initialize this source manager suitably to replay the compilation described by Old.
Definition: SourceManager.cpp:361
clang::CompilerInstance::getTarget
TargetInfo & getTarget() const
Definition: CompilerInstance.h:368
clang::DiagnosticsEngine::getCustomDiagID
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:863
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang::createChainedIncludesSource
IntrusiveRefCntPtr< ExternalSemaSource > createChainedIncludesSource(CompilerInstance &CI, IntrusiveRefCntPtr< ExternalSemaSource > &Reader)
The ChainedIncludesSource class converts headers to chained PCHs in memory, mainly for testing.
Definition: ChainedIncludesSource.cpp:113
clang
Definition: CalledOnceCheck.h:17
clang::FileManager
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
clang::SourceManager::createFileID
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
Definition: SourceManager.cpp:532
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:720
clang::Module::getModuleInputBufferName
static StringRef getModuleInputBufferName()
Definition: Module.h:641
clang::CompilerInstance::resetAndLeakSema
void resetAndLeakSema()
Definition: CompilerInstance.cpp:2253
clang::IdentifierTable::PrintStats
void PrintStats() const
Print some statistics to stderr that indicate how well the hashing is doing.
Definition: IdentifierTable.cpp:371
FrontendDiagnostic.h
clang::FrontendAction::isCurrentFileAST
bool isCurrentFileAST() const
Definition: FrontendAction.h:130
operator+=
static SmallVectorImpl< char > & operator+=(SmallVectorImpl< char > &Includes, StringRef RHS)
Definition: FrontendAction.cpp:286
ASTReader.h
clang::CompilerInstance::getCodeCompletionConsumer
CodeCompleteConsumer & getCodeCompletionConsumer() const
Definition: CompilerInstance.h:559
clang::FileEntry::getName
StringRef getName() const
Definition: FileEntry.h:364
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:40
clang::Module::getUmbrellaHeader
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:551
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:112
clang::SourceManager::getFileEntryForID
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
Definition: SourceManager.h:1030
clang::CompilerInstance::createASTContext
void createASTContext()
Create the AST context.
Definition: CompilerInstance.cpp:550
clang::WrapperFrontendAction::WrappedAction
std::unique_ptr< FrontendAction > WrappedAction
Definition: FrontendAction.h:306
clang::Module::IsExternC
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...
Definition: Module.h:276
clang::Module::submodule_end
submodule_iterator submodule_end()
Definition: Module.h:625
clang::WrapperFrontendAction::PrepareToExecuteAction
bool PrepareToExecuteAction(CompilerInstance &CI) override
Prepare to execute the action on the given CompilerInstance.
Definition: FrontendAction.cpp:1075
clang::FrontendAction::BeginSourceFileAction
virtual bool BeginSourceFileAction(CompilerInstance &CI)
Callback at the start of processing a single input.
Definition: FrontendAction.h:85
clang::FileManager::getDirectory
llvm::ErrorOr< const DirectoryEntry * > getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
Definition: FileManager.cpp:188
clang::CompilerInstance::setFileManager
void setFileManager(FileManager *Value)
Replace the current file manager and virtual file system.
Definition: CompilerInstance.cpp:160
clang::ASTUnit::LoadEverything
@ LoadEverything
Load everything, including Sema.
Definition: ASTUnit.h:678
clang::SourceManager::getModuleBuildStack
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
Definition: SourceManager.h:820
clang::FileManager::getFile
llvm::ErrorOr< const FileEntry * > getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
Definition: FileManager.cpp:196
clang::ASTFrontendAction::ExecuteAction
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
Definition: FrontendAction.cpp:1044
CompilerInstance.h
clang::WrapperFrontendAction::EndSourceFile
void EndSourceFile() override
Perform any per-file post processing, deallocate per-file objects, and run statistics and output file...
Definition: FrontendAction.cpp:1097
clang::CompilerInstance::getFrontendOpts
FrontendOptions & getFrontendOpts()
Definition: CompilerInstance.h:281
clang::WrapperFrontendAction::hasASTFileSupport
bool hasASTFileSupport() const override
Does this action support use with AST files?
Definition: FrontendAction.cpp:1114
clang::CompilerInstance::getASTReader
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: CompilerInstance.cpp:198
clang::CompilerInstance::setASTContext
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
Definition: CompilerInstance.cpp:172
clang::FrontendOptions::DisableFree
unsigned DisableFree
Disable memory freeing on exit.
Definition: FrontendOptions.h:231
clang::Module::addTopHeader
void addTopHeader(const FileEntry *File)
Add a top-level header associated with this module.
Definition: Module.cpp:254
clang::comments::tok::eof
@ eof
Definition: CommentLexer.h:33
clang::Preprocessor::checkModuleIsAvailable
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.
Definition: PPDirectives.cpp:1748
clang::CompilerInstance::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
Definition: CompilerInstance.h:333
clang::CompilerInstance::getSourceManager
SourceManager & getSourceManager() const
Return the current source manager.
Definition: CompilerInstance.h:421
llvm::SmallVectorImpl< char >
clang::FrontendAction::setCompilerInstance
void setCompilerInstance(CompilerInstance *Value)
Definition: FrontendAction.h:124
clang::SrcMgr::C_System
@ C_System
Definition: SourceManager.h:80
clang::WrapperFrontendAction::CreateASTConsumer
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Definition: FrontendAction.cpp:1079
clang::CompilerInstance::createFileManager
FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)
Create the file manager and replace any existing one with it.
Definition: CompilerInstance.cpp:370
clang::CompilerInstance::getSpecificModuleCachePath
std::string getSpecificModuleCachePath(StringRef ModuleHash)
Definition: CompilerInstance.cpp:540
clang::CompilerInstance::createSema
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Definition: CompilerInstance.cpp:692
clang::FrontendAction::usesPreprocessorOnly
virtual bool usesPreprocessorOnly() const =0
Does this action only use the preprocessor?
Previous
StateNode * Previous
Definition: UnwrappedLineFormatter.cpp:988
PreprocessorOptions.h
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:130
clang::CompilerInstance::setSourceManager
void setSourceManager(SourceManager *Value)
setSourceManager - Replace the current source manager.
Definition: CompilerInstance.cpp:164
clang::CompilerInstance::createPreprocessor
void createPreprocessor(TranslationUnitKind TUKind)
Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...
Definition: CompilerInstance.cpp:445
clang::ParseAST
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
clang::Preprocessor::getHeaderSearchInfo
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:942
clang::serialization::DeclID
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
clang::StringLiteralParser
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
Definition: LiteralSupport.h:210
clang::ASTReader::isAcceptableASTFile
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:5403
ReadOriginalFileName
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...
Definition: FrontendAction.cpp:231
clang::serialization::SelectorID
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
Definition: ASTBitCodes.h:153
clang::SrcMgr::C_User_ModuleMap
@ C_User_ModuleMap
Definition: SourceManager.h:82
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:430
clang::WrapperFrontendAction::EndSourceFileAction
void EndSourceFileAction() override
Callback at the end of processing a single input.
Definition: FrontendAction.cpp:1098
clang::CompilerInstance::clearOutputFiles
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
Definition: CompilerInstance.cpp:705
clang::CompilerInstance::shouldBuildGlobalModuleIndex
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
Definition: CompilerInstance.cpp:76
clang::CompilerInstance::createSourceManager
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
Definition: CompilerInstance.cpp:383
clang::Builtin::Context::initializeBuiltins
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:93
clang::serialization::ModuleFile
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:110
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:712
clang::interp::Sub
bool Sub(InterpState &S, CodePtr OpPC)
Definition: Interp.h:142
clang::FrontendOptions::CodeCompletionAt
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
Definition: FrontendOptions.h:402
clang::HeaderSearch::PrintStats
void PrintStats()
Definition: HeaderSearch.cpp:89
clang::CompilerInstance::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts()
Definition: CompilerInstance.h:288
clang::CompilerInstance::createPCHExternalASTSource
void createPCHExternalASTSource(StringRef Path, DisableValidationForModuleKind DisableValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)
Create an external AST source to read a PCH file and attach it to the AST context.
Definition: CompilerInstance.cpp:561
clang::Preprocessor::setMainFileDir
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...
Definition: Preprocessor.h:1703
clang::Module::IsInferred
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
Definition: Module.h:279
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:47
clang::PreprocessorOptions::ImplicitPCHInclude
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
Definition: PreprocessorOptions.h:96
clang::ASTContext::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Definition: ASTContext.cpp:1501
clang::ASTContext::setASTMutationListener
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1161
clang::PluginASTAction::ActionType
ActionType
Definition: FrontendAction.h:272
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1508
clang::Decl::getDeclKindName
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
clang::CompilerInstance::hasASTContext
bool hasASTContext() const
Definition: CompilerInstance.h:459
clang::SourceManager::setFileIsTransient
void setFileIsTransient(const FileEntry *SourceFile)
Specify that a file is transient.
Definition: SourceManager.cpp:723
MultiplexConsumer.h