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, SourceLocation(), /*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::CmdlineAfterMainAction ||
192  // This is O(|plugins| * |add_plugins|), but since both numbers are
193  // way below 50 in practice, that's ok.
194  if (llvm::any_of(CI.getFrontendOpts().AddPluginActions,
195  [&](const std::string &PluginAction) {
196  return PluginAction == Plugin.getName();
197  })) {
200  else
202  }
203  }
204  if ((ActionType == PluginASTAction::AddBeforeMainAction ||
205  ActionType == PluginASTAction::AddAfterMainAction) &&
206  P->ParseArgs(
207  CI,
208  CI.getFrontendOpts().PluginArgs[std::string(Plugin.getName())])) {
209  std::unique_ptr<ASTConsumer> PluginConsumer = P->CreateASTConsumer(CI, InFile);
210  if (ActionType == PluginASTAction::AddBeforeMainAction) {
211  Consumers.push_back(std::move(PluginConsumer));
212  } else {
213  AfterConsumers.push_back(std::move(PluginConsumer));
214  }
215  }
216  }
217 
218  // Add to Consumers the main consumer, then all the plugins that go after it
219  Consumers.push_back(std::move(Consumer));
220  if (!AfterConsumers.empty()) {
221  // If we have plugins after the main consumer, which may be the codegen
222  // action, they likely will need the ASTContext, so don't clear it in the
223  // codegen action.
224  CI.getCodeGenOpts().ClearASTBeforeBackend = false;
225  for (auto &C : AfterConsumers)
226  Consumers.push_back(std::move(C));
227  }
228 
229  return std::make_unique<MultiplexConsumer>(std::move(Consumers));
230 }
231 
232 /// For preprocessed files, if the first line is the linemarker and specifies
233 /// the original source file name, use that name as the input file name.
234 /// Returns the location of the first token after the line marker directive.
235 ///
236 /// \param CI The compiler instance.
237 /// \param InputFile Populated with the filename from the line marker.
238 /// \param IsModuleMap If \c true, add a line note corresponding to this line
239 /// directive. (We need to do this because the directive will not be
240 /// visited by the preprocessor.)
242  std::string &InputFile,
243  bool IsModuleMap = false) {
244  auto &SourceMgr = CI.getSourceManager();
245  auto MainFileID = SourceMgr.getMainFileID();
246 
247  auto MainFileBuf = SourceMgr.getBufferOrNone(MainFileID);
248  if (!MainFileBuf)
249  return SourceLocation();
250 
251  std::unique_ptr<Lexer> RawLexer(
252  new Lexer(MainFileID, *MainFileBuf, SourceMgr, CI.getLangOpts()));
253 
254  // If the first line has the syntax of
255  //
256  // # NUM "FILENAME"
257  //
258  // we use FILENAME as the input file name.
259  Token T;
260  if (RawLexer->LexFromRawLexer(T) || T.getKind() != tok::hash)
261  return SourceLocation();
262  if (RawLexer->LexFromRawLexer(T) || T.isAtStartOfLine() ||
263  T.getKind() != tok::numeric_constant)
264  return SourceLocation();
265 
266  unsigned LineNo;
267  SourceLocation LineNoLoc = T.getLocation();
268  if (IsModuleMap) {
269  llvm::SmallString<16> Buffer;
270  if (Lexer::getSpelling(LineNoLoc, Buffer, SourceMgr, CI.getLangOpts())
271  .getAsInteger(10, LineNo))
272  return SourceLocation();
273  }
274 
275  RawLexer->LexFromRawLexer(T);
276  if (T.isAtStartOfLine() || T.getKind() != tok::string_literal)
277  return SourceLocation();
278 
279  StringLiteralParser Literal(T, CI.getPreprocessor());
280  if (Literal.hadError)
281  return SourceLocation();
282  RawLexer->LexFromRawLexer(T);
283  if (T.isNot(tok::eof) && !T.isAtStartOfLine())
284  return SourceLocation();
285  InputFile = Literal.GetString().str();
286 
287  if (IsModuleMap)
289  LineNoLoc, LineNo, SourceMgr.getLineTableFilenameID(InputFile), false,
290  false, SrcMgr::C_User_ModuleMap);
291 
292  return T.getLocation();
293 }
294 
295 static SmallVectorImpl<char> &
296 operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) {
297  Includes.append(RHS.begin(), RHS.end());
298  return Includes;
299 }
300 
301 static void addHeaderInclude(StringRef HeaderName,
302  SmallVectorImpl<char> &Includes,
303  const LangOptions &LangOpts,
304  bool IsExternC) {
305  if (IsExternC && LangOpts.CPlusPlus)
306  Includes += "extern \"C\" {\n";
307  if (LangOpts.ObjC)
308  Includes += "#import \"";
309  else
310  Includes += "#include \"";
311 
312  Includes += HeaderName;
313 
314  Includes += "\"\n";
315  if (IsExternC && LangOpts.CPlusPlus)
316  Includes += "}\n";
317 }
318 
319 /// Collect the set of header includes needed to construct the given
320 /// module and update the TopHeaders file set of the module.
321 ///
322 /// \param Module The module we're collecting includes from.
323 ///
324 /// \param Includes Will be augmented with the set of \#includes or \#imports
325 /// needed to load all of the named headers.
326 static std::error_code collectModuleHeaderIncludes(
327  const LangOptions &LangOpts, FileManager &FileMgr, DiagnosticsEngine &Diag,
328  ModuleMap &ModMap, clang::Module *Module, SmallVectorImpl<char> &Includes) {
329  // Don't collect any headers for unavailable modules.
330  if (!Module->isAvailable())
331  return std::error_code();
332 
333  // Resolve all lazy header directives to header files.
335 
336  // If any headers are missing, we can't build this module. In most cases,
337  // diagnostics for this should have already been produced; we only get here
338  // if explicit stat information was provided.
339  // FIXME: If the name resolves to a file with different stat information,
340  // produce a better diagnostic.
341  if (!Module->MissingHeaders.empty()) {
342  auto &MissingHeader = Module->MissingHeaders.front();
343  Diag.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
344  << MissingHeader.IsUmbrella << MissingHeader.FileName;
345  return std::error_code();
346  }
347 
348  // Add includes for each of these headers.
349  for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
350  for (Module::Header &H : Module->Headers[HK]) {
351  Module->addTopHeader(H.Entry);
352  // Use the path as specified in the module map file. We'll look for this
353  // file relative to the module build directory (the directory containing
354  // the module map file) so this will find the same file that we found
355  // while parsing the module map.
356  addHeaderInclude(H.PathRelativeToRootModuleDirectory, Includes, LangOpts,
357  Module->IsExternC);
358  }
359  }
360  // Note that Module->PrivateHeaders will not be a TopHeader.
361 
362  if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
363  Module->addTopHeader(UmbrellaHeader.Entry);
364  if (Module->Parent)
365  // Include the umbrella header for submodules.
366  addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory,
367  Includes, LangOpts, Module->IsExternC);
368  } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
369  // Add all of the headers we find in this subdirectory.
370  std::error_code EC;
371  SmallString<128> DirNative;
372  llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative);
373 
374  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
376  for (llvm::vfs::recursive_directory_iterator Dir(FS, DirNative, EC), End;
377  Dir != End && !EC; Dir.increment(EC)) {
378  // Check whether this entry has an extension typically associated with
379  // headers.
380  if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
381  .Cases(".h", ".H", ".hh", ".hpp", true)
382  .Default(false))
383  continue;
384 
385  auto Header = FileMgr.getFile(Dir->path());
386  // FIXME: This shouldn't happen unless there is a file system race. Is
387  // that worth diagnosing?
388  if (!Header)
389  continue;
390 
391  // If this header is marked 'unavailable' in this module, don't include
392  // it.
393  if (ModMap.isHeaderUnavailableInModule(*Header, Module))
394  continue;
395 
396  // Compute the relative path from the directory to this file.
397  SmallVector<StringRef, 16> Components;
398  auto PathIt = llvm::sys::path::rbegin(Dir->path());
399  for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
400  Components.push_back(*PathIt);
401  SmallString<128> RelativeHeader(
402  UmbrellaDir.PathRelativeToRootModuleDirectory);
403  for (auto It = Components.rbegin(), End = Components.rend(); It != End;
404  ++It)
405  llvm::sys::path::append(RelativeHeader, *It);
406 
407  std::string RelName = RelativeHeader.c_str();
408  Headers.push_back(std::make_pair(RelName, *Header));
409  }
410 
411  if (EC)
412  return EC;
413 
414  // Sort header paths and make the header inclusion order deterministic
415  // across different OSs and filesystems.
416  llvm::sort(Headers.begin(), Headers.end(), [](
417  const std::pair<std::string, const FileEntry *> &LHS,
418  const std::pair<std::string, const FileEntry *> &RHS) {
419  return LHS.first < RHS.first;
420  });
421  for (auto &H : Headers) {
422  // Include this header as part of the umbrella directory.
423  Module->addTopHeader(H.second);
424  addHeaderInclude(H.first, Includes, LangOpts, Module->IsExternC);
425  }
426  }
427 
428  // Recurse into submodules.
430  SubEnd = Module->submodule_end();
431  Sub != SubEnd; ++Sub)
432  if (std::error_code Err = collectModuleHeaderIncludes(
433  LangOpts, FileMgr, Diag, ModMap, *Sub, Includes))
434  return Err;
435 
436  return std::error_code();
437 }
438 
439 static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem,
440  bool IsPreprocessed,
441  std::string &PresumedModuleMapFile,
442  unsigned &Offset) {
443  auto &SrcMgr = CI.getSourceManager();
445 
446  // Map the current input to a file.
447  FileID ModuleMapID = SrcMgr.getMainFileID();
448  const FileEntry *ModuleMap = SrcMgr.getFileEntryForID(ModuleMapID);
449 
450  // If the module map is preprocessed, handle the initial line marker;
451  // line directives are not part of the module map syntax in general.
452  Offset = 0;
453  if (IsPreprocessed) {
454  SourceLocation EndOfLineMarker =
455  ReadOriginalFileName(CI, PresumedModuleMapFile, /*IsModuleMap*/ true);
456  if (EndOfLineMarker.isValid())
457  Offset = CI.getSourceManager().getDecomposedLoc(EndOfLineMarker).second;
458  }
459 
460  // Load the module map file.
461  if (HS.loadModuleMapFile(ModuleMap, IsSystem, ModuleMapID, &Offset,
462  PresumedModuleMapFile))
463  return true;
464 
465  if (SrcMgr.getBufferOrFake(ModuleMapID).getBufferSize() == Offset)
466  Offset = 0;
467 
468  return false;
469 }
470 
472  StringRef ModuleMapFilename) {
473  if (CI.getLangOpts().CurrentModule.empty()) {
474  CI.getDiagnostics().Report(diag::err_missing_module_name);
475 
476  // FIXME: Eventually, we could consider asking whether there was just
477  // a single module described in the module map, and use that as a
478  // default. Then it would be fairly trivial to just "compile" a module
479  // map with a single module (the common case).
480  return nullptr;
481  }
482 
483  // Dig out the module definition.
486  /*AllowSearch=*/true);
487  if (!M) {
488  CI.getDiagnostics().Report(diag::err_missing_module)
489  << CI.getLangOpts().CurrentModule << ModuleMapFilename;
490 
491  return nullptr;
492  }
493 
494  // Check whether we can build this module at all.
496  CI.getDiagnostics(), M))
497  return nullptr;
498 
499  // Inform the preprocessor that includes from within the input buffer should
500  // be resolved relative to the build directory of the module map file.
502 
503  // If the module was inferred from a different module map (via an expanded
504  // umbrella module definition), track that fact.
505  // FIXME: It would be preferable to fill this in as part of processing
506  // the module map, rather than adding it after the fact.
507  StringRef OriginalModuleMapName = CI.getFrontendOpts().OriginalModuleMap;
508  if (!OriginalModuleMapName.empty()) {
509  auto OriginalModuleMap =
510  CI.getFileManager().getFile(OriginalModuleMapName,
511  /*openFile*/ true);
512  if (!OriginalModuleMap) {
513  CI.getDiagnostics().Report(diag::err_module_map_not_found)
514  << OriginalModuleMapName;
515  return nullptr;
516  }
517  if (*OriginalModuleMap != CI.getSourceManager().getFileEntryForID(
519  M->IsInferred = true;
521  .setInferredModuleAllowedBy(M, *OriginalModuleMap);
522  }
523  }
524 
525  // If we're being run from the command-line, the module build stack will not
526  // have been filled in yet, so complete it now in order to allow us to detect
527  // module cycles.
528  SourceManager &SourceMgr = CI.getSourceManager();
529  if (SourceMgr.getModuleBuildStack().empty())
531  FullSourceLoc(SourceLocation(), SourceMgr));
532  return M;
533 }
534 
535 /// Compute the input buffer that should be used to build the specified module.
536 static std::unique_ptr<llvm::MemoryBuffer>
538  FileManager &FileMgr = CI.getFileManager();
539 
540  // Collect the set of #includes we need to build the module.
541  SmallString<256> HeaderContents;
542  std::error_code Err = std::error_code();
543  if (Module::Header UmbrellaHeader = M->getUmbrellaHeader())
544  addHeaderInclude(UmbrellaHeader.PathRelativeToRootModuleDirectory,
545  HeaderContents, CI.getLangOpts(), M->IsExternC);
547  CI.getLangOpts(), FileMgr, CI.getDiagnostics(),
549  HeaderContents);
550 
551  if (Err) {
552  CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
553  << M->getFullModuleName() << Err.message();
554  return nullptr;
555  }
556 
557  return llvm::MemoryBuffer::getMemBufferCopy(
558  HeaderContents, Module::getModuleInputBufferName());
559 }
560 
562  const FrontendInputFile &RealInput) {
563  FrontendInputFile Input(RealInput);
564  assert(!Instance && "Already processing a source file!");
565  assert(!Input.isEmpty() && "Unexpected empty filename!");
566  setCurrentInput(Input);
567  setCompilerInstance(&CI);
568 
569  bool HasBegunSourceFile = false;
570  bool ReplayASTFile = Input.getKind().getFormat() == InputKind::Precompiled &&
572 
573  // If we fail, reset state since the client will not end up calling the
574  // matching EndSourceFile(). All paths that return true should release this.
575  auto FailureCleanup = llvm::make_scope_exit([&]() {
576  if (HasBegunSourceFile)
578  CI.clearOutputFiles(/*EraseFiles=*/true);
579  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
581  setCompilerInstance(nullptr);
582  });
583 
584  if (!BeginInvocation(CI))
585  return false;
586 
587  // If we're replaying the build of an AST file, import it and set up
588  // the initial state from its build.
589  if (ReplayASTFile) {
591 
592  // The AST unit populates its own diagnostics engine rather than ours.
594  new DiagnosticsEngine(Diags->getDiagnosticIDs(),
595  &Diags->getDiagnosticOptions()));
596  ASTDiags->setClient(Diags->getClient(), /*OwnsClient*/false);
597 
598  // FIXME: What if the input is a memory buffer?
599  StringRef InputFile = Input.getFile();
600 
601  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
602  std::string(InputFile), CI.getPCHContainerReader(),
604  CI.getCodeGenOpts().DebugTypeExtRefs);
605  if (!AST)
606  return false;
607 
608  // Options relating to how we treat the input (but not what we do with it)
609  // are inherited from the AST unit.
610  CI.getHeaderSearchOpts() = AST->getHeaderSearchOpts();
611  CI.getPreprocessorOpts() = AST->getPreprocessorOpts();
612  CI.getLangOpts() = AST->getLangOpts();
613 
614  // Set the shared objects, these are reset when we finish processing the
615  // file, otherwise the CompilerInstance will happily destroy them.
616  CI.setFileManager(&AST->getFileManager());
618  CI.getSourceManager().initializeForReplay(AST->getSourceManager());
619 
620  // Preload all the module files loaded transitively by the AST unit. Also
621  // load all module map files that were parsed as part of building the AST
622  // unit.
623  if (auto ASTReader = AST->getASTReader()) {
624  auto &MM = ASTReader->getModuleManager();
625  auto &PrimaryModule = MM.getPrimaryModule();
626 
627  for (serialization::ModuleFile &MF : MM)
628  if (&MF != &PrimaryModule)
629  CI.getFrontendOpts().ModuleFiles.push_back(MF.FileName);
630 
632  PrimaryModule, [&](const FileEntry *FE) {
633  CI.getFrontendOpts().ModuleMapFiles.push_back(
634  std::string(FE->getName()));
635  });
636  }
637 
638  // Set up the input file for replay purposes.
639  auto Kind = AST->getInputKind();
640  if (Kind.getFormat() == InputKind::ModuleMap) {
641  Module *ASTModule =
642  AST->getPreprocessor().getHeaderSearchInfo().lookupModule(
643  AST->getLangOpts().CurrentModule, SourceLocation(),
644  /*AllowSearch*/ false);
645  assert(ASTModule && "module file does not define its own module");
646  Input = FrontendInputFile(ASTModule->PresumedModuleMapFile, Kind);
647  } else {
648  auto &OldSM = AST->getSourceManager();
649  FileID ID = OldSM.getMainFileID();
650  if (auto *File = OldSM.getFileEntryForID(ID))
651  Input = FrontendInputFile(File->getName(), Kind);
652  else
653  Input = FrontendInputFile(OldSM.getBufferOrFake(ID), Kind);
654  }
655  setCurrentInput(Input, std::move(AST));
656  }
657 
658  // AST files follow a very different path, since they share objects via the
659  // AST unit.
660  if (Input.getKind().getFormat() == InputKind::Precompiled) {
661  assert(!usesPreprocessorOnly() && "this case was handled above");
662  assert(hasASTFileSupport() &&
663  "This action does not have AST file support!");
664 
666 
667  // FIXME: What if the input is a memory buffer?
668  StringRef InputFile = Input.getFile();
669 
670  std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
671  std::string(InputFile), CI.getPCHContainerReader(),
673  CI.getCodeGenOpts().DebugTypeExtRefs);
674 
675  if (!AST)
676  return false;
677 
678  // Inform the diagnostic client we are processing a source file.
679  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
680  HasBegunSourceFile = true;
681 
682  // Set the shared objects, these are reset when we finish processing the
683  // file, otherwise the CompilerInstance will happily destroy them.
684  CI.setFileManager(&AST->getFileManager());
685  CI.setSourceManager(&AST->getSourceManager());
686  CI.setPreprocessor(AST->getPreprocessorPtr());
687  Preprocessor &PP = CI.getPreprocessor();
689  PP.getLangOpts());
690  CI.setASTContext(&AST->getASTContext());
691 
692  setCurrentInput(Input, std::move(AST));
693 
694  // Initialize the action.
695  if (!BeginSourceFileAction(CI))
696  return false;
697 
698  // Create the AST consumer.
699  CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
700  if (!CI.hasASTConsumer())
701  return false;
702 
703  FailureCleanup.release();
704  return true;
705  }
706 
707  // Set up the file and source managers, if needed.
708  if (!CI.hasFileManager()) {
709  if (!CI.createFileManager()) {
710  return false;
711  }
712  }
713  if (!CI.hasSourceManager())
715 
716  // Set up embedding for any specified files. Do this before we load any
717  // source files, including the primary module map for the compilation.
718  for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
719  if (auto FE = CI.getFileManager().getFile(F, /*openFile*/true))
721  else
722  CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;
723  }
726 
727  // IR files bypass the rest of initialization.
728  if (Input.getKind().getLanguage() == Language::LLVM_IR) {
729  assert(hasIRSupport() &&
730  "This action does not have IR file support!");
731 
732  // Inform the diagnostic client we are processing a source file.
733  CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
734  HasBegunSourceFile = true;
735 
736  // Initialize the action.
737  if (!BeginSourceFileAction(CI))
738  return false;
739 
740  // Initialize the main file entry.
741  if (!CI.InitializeSourceManager(CurrentInput))
742  return false;
743 
744  FailureCleanup.release();
745  return true;
746  }
747 
748  // If the implicit PCH include is actually a directory, rather than
749  // a single file, search for a suitable PCH file in that directory.
750  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
751  FileManager &FileMgr = CI.getFileManager();
753  StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
754  std::string SpecificModuleCachePath = CI.getSpecificModuleCachePath();
755  if (auto PCHDir = FileMgr.getDirectory(PCHInclude)) {
756  std::error_code EC;
757  SmallString<128> DirNative;
758  llvm::sys::path::native((*PCHDir)->getName(), DirNative);
759  bool Found = false;
760  llvm::vfs::FileSystem &FS = FileMgr.getVirtualFileSystem();
761  for (llvm::vfs::directory_iterator Dir = FS.dir_begin(DirNative, EC),
762  DirEnd;
763  Dir != DirEnd && !EC; Dir.increment(EC)) {
764  // Check whether this is an acceptable AST file.
766  Dir->path(), FileMgr, CI.getPCHContainerReader(),
768  SpecificModuleCachePath)) {
769  PPOpts.ImplicitPCHInclude = std::string(Dir->path());
770  Found = true;
771  break;
772  }
773  }
774 
775  if (!Found) {
776  CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
777  return false;
778  }
779  }
780  }
781 
782  // Set up the preprocessor if needed. When parsing model files the
783  // preprocessor of the original source is reused.
784  if (!isModelParsingAction())
786 
787  // Inform the diagnostic client we are processing a source file.
789  &CI.getPreprocessor());
790  HasBegunSourceFile = true;
791 
792  // Initialize the main file entry.
793  if (!CI.InitializeSourceManager(Input))
794  return false;
795 
796  // For module map files, we first parse the module map and synthesize a
797  // "<module-includes>" buffer before more conventional processing.
798  if (Input.getKind().getFormat() == InputKind::ModuleMap) {
799  CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleMap);
800 
801  std::string PresumedModuleMapFile;
802  unsigned OffsetToContents;
803  if (loadModuleMapForModuleBuild(CI, Input.isSystem(),
804  Input.isPreprocessed(),
805  PresumedModuleMapFile, OffsetToContents))
806  return false;
807 
808  auto *CurrentModule = prepareToBuildModule(CI, Input.getFile());
809  if (!CurrentModule)
810  return false;
811 
812  CurrentModule->PresumedModuleMapFile = PresumedModuleMapFile;
813 
814  if (OffsetToContents)
815  // If the module contents are in the same file, skip to them.
816  CI.getPreprocessor().setSkipMainFilePreamble(OffsetToContents, true);
817  else {
818  // Otherwise, convert the module description to a suitable input buffer.
819  auto Buffer = getInputBufferForModule(CI, CurrentModule);
820  if (!Buffer)
821  return false;
822 
823  // Reinitialize the main file entry to refer to the new input.
824  auto Kind = CurrentModule->IsSystem ? SrcMgr::C_System : SrcMgr::C_User;
825  auto &SourceMgr = CI.getSourceManager();
826  auto BufferID = SourceMgr.createFileID(std::move(Buffer), Kind);
827  assert(BufferID.isValid() && "couldn't create module buffer ID");
828  SourceMgr.setMainFileID(BufferID);
829  }
830  }
831 
832  // Initialize the action.
833  if (!BeginSourceFileAction(CI))
834  return false;
835 
836  // If we were asked to load any module map files, do so now.
837  for (const auto &Filename : CI.getFrontendOpts().ModuleMapFiles) {
838  if (auto File = CI.getFileManager().getFile(Filename))
840  *File, /*IsSystem*/false);
841  else
842  CI.getDiagnostics().Report(diag::err_module_map_not_found) << Filename;
843  }
844 
845  // Add a module declaration scope so that modules from -fmodule-map-file
846  // arguments may shadow modules found implicitly in search paths.
847  CI.getPreprocessor()
849  .getModuleMap()
851 
852  // Create the AST context and consumer unless this is a preprocessor only
853  // action.
854  if (!usesPreprocessorOnly()) {
855  // Parsing a model file should reuse the existing ASTContext.
856  if (!isModelParsingAction())
857  CI.createASTContext();
858 
859  // For preprocessed files, check if the first line specifies the original
860  // source file name with a linemarker.
861  std::string PresumedInputFile = std::string(getCurrentFileOrBufferName());
862  if (Input.isPreprocessed())
863  ReadOriginalFileName(CI, PresumedInputFile);
864 
865  std::unique_ptr<ASTConsumer> Consumer =
866  CreateWrappedASTConsumer(CI, PresumedInputFile);
867  if (!Consumer)
868  return false;
869 
870  // FIXME: should not overwrite ASTMutationListener when parsing model files?
871  if (!isModelParsingAction())
872  CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
873 
874  if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
875  // Convert headers to PCH and chain them.
876  IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
877  source = createChainedIncludesSource(CI, FinalReader);
878  if (!source)
879  return false;
880  CI.setASTReader(static_cast<ASTReader *>(FinalReader.get()));
881  CI.getASTContext().setExternalSource(source);
882  } else if (CI.getLangOpts().Modules ||
883  !CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
884  // Use PCM or PCH.
885  assert(hasPCHSupport() && "This action does not have PCH support!");
886  ASTDeserializationListener *DeserialListener =
887  Consumer->GetASTDeserializationListener();
888  bool DeleteDeserialListener = false;
890  DeserialListener = new DeserializedDeclsDumper(DeserialListener,
891  DeleteDeserialListener);
892  DeleteDeserialListener = true;
893  }
895  DeserialListener = new DeserializedDeclsChecker(
896  CI.getASTContext(),
898  DeserialListener, DeleteDeserialListener);
899  DeleteDeserialListener = true;
900  }
901  if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
906  DeserialListener, DeleteDeserialListener);
907  if (!CI.getASTContext().getExternalSource())
908  return false;
909  }
910  // If modules are enabled, create the AST reader before creating
911  // any builtins, so that all declarations know that they might be
912  // extended by an external source.
913  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
915  CI.createASTReader();
916  CI.getASTReader()->setDeserializationListener(DeserialListener,
917  DeleteDeserialListener);
918  }
919  }
920 
921  CI.setASTConsumer(std::move(Consumer));
922  if (!CI.hasASTConsumer())
923  return false;
924  }
925 
926  // Initialize built-in info as long as we aren't using an external AST
927  // source.
928  if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
930  Preprocessor &PP = CI.getPreprocessor();
932  PP.getLangOpts());
933  } else {
934  // FIXME: If this is a problem, recover from it by creating a multiplex
935  // source.
936  assert((!CI.getLangOpts().Modules || CI.getASTReader()) &&
937  "modules enabled but created an external source that "
938  "doesn't support modules");
939  }
940 
941  // If we were asked to load any module files, do so now.
942  for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
943  if (!CI.loadModuleFile(ModuleFile))
944  return false;
945 
946  // If there is a layout overrides file, attach an external AST source that
947  // provides the layouts from that file.
948  if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
951  Override(new LayoutOverrideSource(
953  CI.getASTContext().setExternalSource(Override);
954  }
955 
956  FailureCleanup.release();
957  return true;
958 }
959 
960 llvm::Error FrontendAction::Execute() {
962 
963  if (CI.hasFrontendTimer()) {
964  llvm::TimeRegion Timer(CI.getFrontendTimer());
965  ExecuteAction();
966  }
967  else ExecuteAction();
968 
969  // If we are supposed to rebuild the global module index, do so now unless
970  // there were any module-build failures.
971  if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
972  CI.hasPreprocessor()) {
973  StringRef Cache =
975  if (!Cache.empty()) {
976  if (llvm::Error Err = GlobalModuleIndex::writeIndex(
978  // FIXME this drops the error on the floor, but
979  // Index/pch-from-libclang.c seems to rely on dropping at least some of
980  // the error conditions!
981  consumeError(std::move(Err));
982  }
983  }
984  }
985 
986  return llvm::Error::success();
987 }
988 
991 
992  // Inform the diagnostic client we are done with this source file.
994 
995  // Inform the preprocessor we are done.
996  if (CI.hasPreprocessor())
998 
999  // Finalize the action.
1001 
1002  // Sema references the ast consumer, so reset sema first.
1003  //
1004  // FIXME: There is more per-file stuff we could just drop here?
1005  bool DisableFree = CI.getFrontendOpts().DisableFree;
1006  if (DisableFree) {
1007  CI.resetAndLeakSema();
1009  llvm::BuryPointer(CI.takeASTConsumer().get());
1010  } else {
1011  CI.setSema(nullptr);
1012  CI.setASTContext(nullptr);
1013  CI.setASTConsumer(nullptr);
1014  }
1015 
1016  if (CI.getFrontendOpts().ShowStats) {
1017  llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFile() << "':\n";
1018  CI.getPreprocessor().PrintStats();
1022  llvm::errs() << "\n";
1023  }
1024 
1025  // Cleanup the output streams, and erase the output files if instructed by the
1026  // FrontendAction.
1027  CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
1028 
1029  if (isCurrentFileAST()) {
1030  if (DisableFree) {
1034  llvm::BuryPointer(std::move(CurrentASTUnit));
1035  } else {
1036  CI.setPreprocessor(nullptr);
1037  CI.setSourceManager(nullptr);
1038  CI.setFileManager(nullptr);
1039  }
1040  }
1041 
1042  setCompilerInstance(nullptr);
1044  CI.getLangOpts().setCompilingModule(LangOptions::CMK_None);
1045 }
1046 
1049 }
1050 
1051 //===----------------------------------------------------------------------===//
1052 // Utility Actions
1053 //===----------------------------------------------------------------------===//
1054 
1057  if (!CI.hasPreprocessor())
1058  return;
1059 
1060  // FIXME: Move the truncation aspect of this into Sema, we delayed this till
1061  // here so the source manager would be initialized.
1062  if (hasCodeCompletionSupport() &&
1065 
1066  // Use a code completion consumer?
1067  CodeCompleteConsumer *CompletionConsumer = nullptr;
1068  if (CI.hasCodeCompletionConsumer())
1069  CompletionConsumer = &CI.getCodeCompletionConsumer();
1070 
1071  if (!CI.hasSema())
1072  CI.createSema(getTranslationUnitKind(), CompletionConsumer);
1073 
1076 }
1077 
1078 void PluginASTAction::anchor() { }
1079 
1080 std::unique_ptr<ASTConsumer>
1082  StringRef InFile) {
1083  llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
1084 }
1085 
1087  return WrappedAction->PrepareToExecuteAction(CI);
1088 }
1089 std::unique_ptr<ASTConsumer>
1091  StringRef InFile) {
1092  return WrappedAction->CreateASTConsumer(CI, InFile);
1093 }
1095  return WrappedAction->BeginInvocation(CI);
1096 }
1098  WrappedAction->setCurrentInput(getCurrentInput());
1099  WrappedAction->setCompilerInstance(&CI);
1100  auto Ret = WrappedAction->BeginSourceFileAction(CI);
1101  // BeginSourceFileAction may change CurrentInput, e.g. during module builds.
1102  setCurrentInput(WrappedAction->getCurrentInput());
1103  return Ret;
1104 }
1106  WrappedAction->ExecuteAction();
1107 }
1110  WrappedAction->EndSourceFileAction();
1111 }
1113  return WrappedAction->shouldEraseOutputFiles();
1114 }
1115 
1117  return WrappedAction->usesPreprocessorOnly();
1118 }
1120  return WrappedAction->getTranslationUnitKind();
1121 }
1123  return WrappedAction->hasPCHSupport();
1124 }
1126  return WrappedAction->hasASTFileSupport();
1127 }
1129  return WrappedAction->hasIRSupport();
1130 }
1132  return WrappedAction->hasCodeCompletionSupport();
1133 }
1134 
1136  std::unique_ptr<FrontendAction> WrappedAction)
1137  : WrappedAction(std::move(WrappedAction)) {}
1138 
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:184
clang::WrapperFrontendAction::ExecuteAction
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Definition: FrontendAction.cpp:1105
clang::ModuleMap::finishModuleDeclarationScope
void finishModuleDeclarationScope()
Creates a new declaration scope for module names, allowing previously defined modules to shadow defin...
Definition: ModuleMap.h:579
clang::CompilerInstance::hasSema
bool hasSema() const
Definition: CompilerInstance.h:501
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:344
clang::Preprocessor::setSkipMainFilePreamble
void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine)
Instruct the preprocessor to skip part of the main source file.
Definition: Preprocessor.h:1736
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:483
clang::FullSourceLoc
A SourceLocation and its associated SourceManager.
Definition: SourceLocation.h:368
loadModuleMapForModuleBuild
static bool loadModuleMapForModuleBuild(CompilerInstance &CI, bool IsSystem, bool IsPreprocessed, std::string &PresumedModuleMapFile, unsigned &Offset)
Definition: FrontendAction.cpp:439
clang::DeclaratorContext::File
@ File
clang::Module::getUmbrellaDir
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:244
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
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:279
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:404
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:86
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:219
clang::WrapperFrontendAction::hasCodeCompletionSupport
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
Definition: FrontendAction.cpp:1131
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::CompilerInstance::setSema
void setSema(Sema *S)
Replace the current Sema; the compiler instance takes ownership of S.
Definition: CompilerInstance.cpp:180
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:1081
addHeaderInclude
static void addHeaderInclude(StringRef HeaderName, SmallVectorImpl< char > &Includes, const LangOptions &LangOpts, bool IsExternC)
Definition: FrontendAction.cpp:301
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:782
clang::WrapperFrontendAction::getTranslationUnitKind
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we're handling.
Definition: FrontendAction.cpp:1119
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:674
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:989
clang::Module::submodule_begin
submodule_iterator submodule_begin()
Definition: Module.h:627
clang::CompilerInstance::InitializeSourceManager
bool InitializeSourceManager(const FrontendInputFile &Input)
InitializeSourceManager - Initialize the source manager to set InputFile as the main file.
Definition: CompilerInstance.cpp:940
clang::CompilerInstance::getLangOpts
LangOptions & getLangOpts()
Definition: CompilerInstance.h:299
clang::WrapperFrontendAction::hasPCHSupport
bool hasPCHSupport() const override
Does this action support use with PCH?
Definition: FrontendAction.cpp:1122
Filename
StringRef Filename
Definition: Format.cpp:2429
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:574
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:326
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:2124
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:3800
clang::CompilerInstance::getFileSystemOpts
FileSystemOptions & getFileSystemOpts()
Definition: CompilerInstance.h:275
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:1754
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::CompilerInstance::getCodeGenOpts
CodeGenOptions & getCodeGenOpts()
Definition: CompilerInstance.h:254
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:542
clang::CompilerInstance::createCodeCompletionConsumer
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
Definition: CompilerInstance.cpp:709
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:967
clang::Module::isAvailable
bool isAvailable() const
Determine whether this module is available for use within the current translation unit.
Definition: Module.h:447
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:1270
clang::ParsedSourceLocation::FileName
std::string FileName
Definition: CommandLineSourceLoc.h:25
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:960
Preprocessor.h
clang::HeaderSearch
Encapsulates the information needed to find the file referenced by a #include or #include_next,...
Definition: HeaderSearch.h:168
clang::CompilerInstance::resetAndLeakSourceManager
void resetAndLeakSourceManager()
Definition: CompilerInstance.h:427
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:2431
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:402
clang::PluginASTAction::AddBeforeMainAction
@ AddBeforeMainAction
Execute the action before the main action.
Definition: FrontendAction.h:278
clang::ASTContext::getExternalSource
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1155
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:1128
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:682
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:407
clang::ASTReader::getModuleManager
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1690
clang::CompilerInstance::createASTReader
void createASTReader()
Definition: CompilerInstance.cpp:1632
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:836
clang::FrontendAction::BeginSourceFile
bool BeginSourceFile(CompilerInstance &CI, const FrontendInputFile &Input)
Prepare the action for processing the input file Input.
Definition: FrontendAction.cpp:561
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:208
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:1610
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:503
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:1044
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::HeaderSearch::lookupModule
Module * lookupModule(StringRef ModuleName, SourceLocation ImportLoc=SourceLocation(), bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
Definition: HeaderSearch.cpp:271
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:449
ASTContext.h
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:1047
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:442
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:235
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:462
clang::SrcMgr::C_User
@ C_User
Definition: SourceManager.h:79
clang::CompilerInstance::hasFileManager
bool hasFileManager() const
Definition: CompilerInstance.h:399
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:9134
prepareToBuildModule
static Module * prepareToBuildModule(CompilerInstance &CI, StringRef ModuleMapFilename)
Definition: FrontendAction.cpp:471
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:72
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:306
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:1094
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:169
clang::CompilerInstance::setASTReader
void setASTReader(IntrusiveRefCntPtr< ASTReader > Reader)
Definition: CompilerInstance.cpp:202
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:624
clang::CompilerInstance::getTargetOpts
TargetOptions & getTargetOpts()
Definition: CompilerInstance.h:320
clang::Module::HK_Normal
@ HK_Normal
Definition: Module.h:186
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:492
clang::CompilerInstance::loadModuleFile
bool loadModuleFile(StringRef FileName)
Definition: CompilerInstance.cpp:1683
clang::Module::HK_Private
@ HK_Private
Definition: Module.h:188
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:215
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:1746
clang::CompilerInstance::getDiagnosticClient
DiagnosticConsumer & getDiagnosticClient() const
Definition: CompilerInstance.h:342
clang::Preprocessor::getBuiltinInfo
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:970
clang::ASTDeserializationListener
Definition: ASTDeserializationListener.h:30
clang::CompilerInstance::hasPreprocessor
bool hasPreprocessor() const
Definition: CompilerInstance.h:439
clang::WrapperFrontendAction::BeginSourceFileAction
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
Definition: FrontendAction.cpp:1097
LangStandard.h
clang::WrapperFrontendAction::usesPreprocessorOnly
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
Definition: FrontendAction.cpp:1116
clang::HeaderSearch::getModuleCachePath
StringRef getModuleCachePath() const
Retrieve the path to the module cache.
Definition: HeaderSearch.h:345
clang::CompilerInstance::hasCodeCompletionConsumer
bool hasCodeCompletionConsumer() const
Definition: CompilerInstance.h:558
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:83
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:537
clang::CompilerInstance::getFrontendTimer
llvm::Timer & getFrontendTimer() const
Definition: CompilerInstance.h:576
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:960
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:1190
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:168
clang::CompilerInstance::resetAndLeakASTContext
void resetAndLeakASTContext()
Definition: CompilerInstance.h:467
clang::CompilerInstance::hasSourceManager
bool hasSourceManager() const
Definition: CompilerInstance.h:419
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:1112
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:84
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:340
std
Definition: Format.h:4275
clang::TranslationUnitKind
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:704
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:369
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:866
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:748
clang::Module::getModuleInputBufferName
static StringRef getModuleInputBufferName()
Definition: Module.h:645
clang::CompilerInstance::resetAndLeakSema
void resetAndLeakSema()
Definition: CompilerInstance.cpp:2277
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:296
ASTReader.h
clang::CompilerInstance::getCodeCompletionConsumer
CodeCompleteConsumer & getCodeCompletionConsumer() const
Definition: CompilerInstance.h:560
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:38
clang::Module::getUmbrellaHeader
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:555
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
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:551
clang::WrapperFrontendAction::WrappedAction
std::unique_ptr< FrontendAction > WrappedAction
Definition: FrontendAction.h:307
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:280
clang::Module::submodule_end
submodule_iterator submodule_end()
Definition: Module.h:629
clang::WrapperFrontendAction::PrepareToExecuteAction
bool PrepareToExecuteAction(CompilerInstance &CI) override
Prepare to execute the action on the given CompilerInstance.
Definition: FrontendAction.cpp:1086
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:161
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:1055
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:1108
clang::CompilerInstance::getFrontendOpts
FrontendOptions & getFrontendOpts()
Definition: CompilerInstance.h:282
clang::WrapperFrontendAction::hasASTFileSupport
bool hasASTFileSupport() const override
Does this action support use with AST files?
Definition: FrontendAction.cpp:1125
clang::CompilerInstance::getASTReader
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: CompilerInstance.cpp:199
clang::CompilerInstance::setASTContext
void setASTContext(ASTContext *Value)
setASTContext - Replace the current AST context.
Definition: CompilerInstance.cpp:173
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:252
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:1755
clang::CompilerInstance::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
Definition: CompilerInstance.h:334
clang::CompilerInstance::getSourceManager
SourceManager & getSourceManager() const
Return the current source manager.
Definition: CompilerInstance.h:422
llvm::SmallVectorImpl< char >
clang::PluginASTAction::CmdlineAfterMainAction
@ CmdlineAfterMainAction
Execute the action after the main action if on the command line.
Definition: FrontendAction.h:275
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:1090
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:371
clang::CompilerInstance::getSpecificModuleCachePath
std::string getSpecificModuleCachePath(StringRef ModuleHash)
Definition: CompilerInstance.cpp:541
clang::CompilerInstance::createSema
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Definition: CompilerInstance.cpp:748
clang::FrontendAction::usesPreprocessorOnly
virtual bool usesPreprocessorOnly() const =0
Does this action only use the preprocessor?
Previous
StateNode * Previous
Definition: UnwrappedLineFormatter.cpp:1054
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:165
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:446
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:965
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:5414
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:241
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:424
clang::WrapperFrontendAction::EndSourceFileAction
void EndSourceFileAction() override
Callback at the end of processing a single input.
Definition: FrontendAction.cpp:1109
clang::CompilerInstance::clearOutputFiles
void clearOutputFiles(bool EraseFiles)
clearOutputFiles - Clear the output file list.
Definition: CompilerInstance.cpp:761
clang::CompilerInstance::shouldBuildGlobalModuleIndex
bool shouldBuildGlobalModuleIndex() const
Indicates whether we should (re)build the global module index.
Definition: CompilerInstance.cpp:77
clang::CompilerInstance::createSourceManager
void createSourceManager(FileManager &FileMgr)
Create the source manager and replace any existing one with it.
Definition: CompilerInstance.cpp:384
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:111
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:723
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:90
clang::CompilerInstance::getHeaderSearchOpts
HeaderSearchOptions & getHeaderSearchOpts()
Definition: CompilerInstance.h:289
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:610
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:1726
clang::Module::IsInferred
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
Definition: Module.h:283
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:1499
clang::ASTContext::setASTMutationListener
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1164
clang::PluginASTAction::CmdlineBeforeMainAction
@ CmdlineBeforeMainAction
Execute the action before the main action if on the command line.
Definition: FrontendAction.h:273
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:1523
clang::Decl::getDeclKindName
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
clang::CompilerInstance::hasASTContext
bool hasASTContext() const
Definition: CompilerInstance.h:460
clang::SourceManager::setFileIsTransient
void setFileIsTransient(const FileEntry *SourceFile)
Specify that a file is transient.
Definition: SourceManager.cpp:723
MultiplexConsumer.h