clang  8.0.0svn
FrontendActions.cpp
Go to the documentation of this file.
1 //===--- FrontendActions.cpp ----------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 #include "clang/AST/ASTConsumer.h"
17 #include "clang/Frontend/Utils.h"
18 #include "clang/Lex/HeaderSearch.h"
19 #include "clang/Lex/Preprocessor.h"
24 #include "llvm/Support/FileSystem.h"
25 #include "llvm/Support/MemoryBuffer.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Support/YAMLTraits.h"
29 #include <memory>
30 #include <system_error>
31 
32 using namespace clang;
33 
34 namespace {
35 CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
37  : nullptr;
38 }
39 
40 void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
41  if (Action.hasCodeCompletionSupport() &&
44 
45  if (!CI.hasSema())
47  GetCodeCompletionConsumer(CI));
48 }
49 } // namespace
50 
51 //===----------------------------------------------------------------------===//
52 // Custom Actions
53 //===----------------------------------------------------------------------===//
54 
55 std::unique_ptr<ASTConsumer>
56 InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
57  return llvm::make_unique<ASTConsumer>();
58 }
59 
60 void InitOnlyAction::ExecuteAction() {
61 }
62 
63 //===----------------------------------------------------------------------===//
64 // AST Consumer Actions
65 //===----------------------------------------------------------------------===//
66 
67 std::unique_ptr<ASTConsumer>
69  if (std::unique_ptr<raw_ostream> OS =
70  CI.createDefaultOutputFile(false, InFile))
71  return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
72  return nullptr;
73 }
74 
75 std::unique_ptr<ASTConsumer>
77  return CreateASTDumper(nullptr /*Dump to stdout.*/,
82 }
83 
84 std::unique_ptr<ASTConsumer>
86  return CreateASTDeclNodeLister();
87 }
88 
89 std::unique_ptr<ASTConsumer>
91  return CreateASTViewer();
92 }
93 
94 std::unique_ptr<ASTConsumer>
96  std::string Sysroot;
97  if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
98  return nullptr;
99 
100  std::string OutputFile;
101  std::unique_ptr<raw_pwrite_stream> OS =
102  CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
103  if (!OS)
104  return nullptr;
105 
107  Sysroot.clear();
108 
109  const auto &FrontendOpts = CI.getFrontendOpts();
110  auto Buffer = std::make_shared<PCHBuffer>();
111  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
112  Consumers.push_back(llvm::make_unique<PCHGenerator>(
113  CI.getPreprocessor(), OutputFile, Sysroot,
114  Buffer, FrontendOpts.ModuleFileExtensions,
116  FrontendOpts.IncludeTimestamps));
117  Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
118  CI, InFile, OutputFile, std::move(OS), Buffer));
119 
120  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
121 }
122 
124  std::string &Sysroot) {
125  Sysroot = CI.getHeaderSearchOpts().Sysroot;
126  if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
127  CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
128  return false;
129  }
130 
131  return true;
132 }
133 
134 std::unique_ptr<llvm::raw_pwrite_stream>
136  std::string &OutputFile) {
137  // We use createOutputFile here because this is exposed via libclang, and we
138  // must disable the RemoveFileOnSignal behavior.
139  // We use a temporary to avoid race conditions.
140  std::unique_ptr<raw_pwrite_stream> OS =
141  CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
142  /*RemoveFileOnSignal=*/false, InFile,
143  /*Extension=*/"", /*useTemporary=*/true);
144  if (!OS)
145  return nullptr;
146 
147  OutputFile = CI.getFrontendOpts().OutputFile;
148  return OS;
149 }
150 
152  if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
153  return false;
155 }
156 
158  CI.getLangOpts().CompilingPCH = true;
159  return true;
160 }
161 
162 std::unique_ptr<ASTConsumer>
164  StringRef InFile) {
165  std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
166  if (!OS)
167  return nullptr;
168 
169  std::string OutputFile = CI.getFrontendOpts().OutputFile;
170  std::string Sysroot;
171 
172  auto Buffer = std::make_shared<PCHBuffer>();
173  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
174 
175  Consumers.push_back(llvm::make_unique<PCHGenerator>(
176  CI.getPreprocessor(), OutputFile, Sysroot,
178  /*AllowASTWithErrors=*/false,
179  /*IncludeTimestamps=*/
181  Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
182  CI, InFile, OutputFile, std::move(OS), Buffer));
183  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
184 }
185 
186 bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
187  CompilerInstance &CI) {
188  if (!CI.getLangOpts().Modules) {
189  CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
190  return false;
191  }
192 
194 }
195 
196 std::unique_ptr<raw_pwrite_stream>
197 GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
198  StringRef InFile) {
199  // If no output file was provided, figure out where this module would go
200  // in the module cache.
201  if (CI.getFrontendOpts().OutputFile.empty()) {
202  StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
203  if (ModuleMapFile.empty())
204  ModuleMapFile = InFile;
205 
209  ModuleMapFile);
210  }
211 
212  // We use createOutputFile here because this is exposed via libclang, and we
213  // must disable the RemoveFileOnSignal behavior.
214  // We use a temporary to avoid race conditions.
215  return CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
216  /*RemoveFileOnSignal=*/false, InFile,
217  /*Extension=*/"", /*useTemporary=*/true,
218  /*CreateMissingDirectories=*/true);
219 }
220 
221 bool GenerateModuleInterfaceAction::BeginSourceFileAction(
222  CompilerInstance &CI) {
223  if (!CI.getLangOpts().ModulesTS) {
224  CI.getDiagnostics().Report(diag::err_module_interface_requires_modules_ts);
225  return false;
226  }
227 
228  CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
229 
231 }
232 
233 std::unique_ptr<raw_pwrite_stream>
234 GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
235  StringRef InFile) {
236  return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
237 }
238 
239 bool GenerateHeaderModuleAction::PrepareToExecuteAction(
240  CompilerInstance &CI) {
241  if (!CI.getLangOpts().Modules && !CI.getLangOpts().ModulesTS) {
242  CI.getDiagnostics().Report(diag::err_header_module_requires_modules);
243  return false;
244  }
245 
246  auto &Inputs = CI.getFrontendOpts().Inputs;
247  if (Inputs.empty())
249 
250  auto Kind = Inputs[0].getKind();
251 
252  // Convert the header file inputs into a single module input buffer.
253  SmallString<256> HeaderContents;
254  ModuleHeaders.reserve(Inputs.size());
255  for (const FrontendInputFile &FIF : Inputs) {
256  // FIXME: We should support re-compiling from an AST file.
257  if (FIF.getKind().getFormat() != InputKind::Source || !FIF.isFile()) {
258  CI.getDiagnostics().Report(diag::err_module_header_file_not_found)
259  << (FIF.isFile() ? FIF.getFile()
260  : FIF.getBuffer()->getBufferIdentifier());
261  return true;
262  }
263 
264  HeaderContents += "#include \"";
265  HeaderContents += FIF.getFile();
266  HeaderContents += "\"\n";
267  ModuleHeaders.push_back(FIF.getFile());
268  }
269  Buffer = llvm::MemoryBuffer::getMemBufferCopy(
270  HeaderContents, Module::getModuleInputBufferName());
271 
272  // Set that buffer up as our "real" input.
273  Inputs.clear();
274  Inputs.push_back(FrontendInputFile(Buffer.get(), Kind, /*IsSystem*/false));
275 
277 }
278 
279 bool GenerateHeaderModuleAction::BeginSourceFileAction(
280  CompilerInstance &CI) {
281  CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderModule);
282 
283  // Synthesize a Module object for the given headers.
284  auto &HS = CI.getPreprocessor().getHeaderSearchInfo();
286  for (StringRef Name : ModuleHeaders) {
287  const DirectoryLookup *CurDir = nullptr;
288  const FileEntry *FE = HS.LookupFile(
289  Name, SourceLocation(), /*Angled*/ false, nullptr, CurDir,
290  None, nullptr, nullptr, nullptr, nullptr, nullptr);
291  if (!FE) {
292  CI.getDiagnostics().Report(diag::err_module_header_file_not_found)
293  << Name;
294  continue;
295  }
296  Headers.push_back({Name, FE});
297  }
298  HS.getModuleMap().createHeaderModule(CI.getLangOpts().CurrentModule, Headers);
299 
301 }
302 
303 std::unique_ptr<raw_pwrite_stream>
304 GenerateHeaderModuleAction::CreateOutputFile(CompilerInstance &CI,
305  StringRef InFile) {
306  return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
307 }
308 
310 }
311 
312 std::unique_ptr<ASTConsumer>
314  return llvm::make_unique<ASTConsumer>();
315 }
316 
317 std::unique_ptr<ASTConsumer>
319  StringRef InFile) {
320  return llvm::make_unique<ASTConsumer>();
321 }
322 
323 std::unique_ptr<ASTConsumer>
325  return llvm::make_unique<ASTConsumer>();
326 }
327 
331  const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
332  std::unique_ptr<ASTReader> Reader(new ASTReader(
335  Sysroot.empty() ? "" : Sysroot.c_str(),
336  /*DisableValidation*/ false,
337  /*AllowPCHWithCompilerErrors*/ false,
338  /*AllowConfigurationMismatch*/ true,
339  /*ValidateSystemInputs*/ true));
340 
341  Reader->ReadAST(getCurrentFile(),
342  Preamble ? serialization::MK_Preamble
344  SourceLocation(),
346 }
347 
348 namespace {
349 struct TemplightEntry {
350  std::string Name;
351  std::string Kind;
352  std::string Event;
353  std::string DefinitionLocation;
354  std::string PointOfInstantiation;
355 };
356 } // namespace
357 
358 namespace llvm {
359 namespace yaml {
360 template <> struct MappingTraits<TemplightEntry> {
361  static void mapping(IO &io, TemplightEntry &fields) {
362  io.mapRequired("name", fields.Name);
363  io.mapRequired("kind", fields.Kind);
364  io.mapRequired("event", fields.Event);
365  io.mapRequired("orig", fields.DefinitionLocation);
366  io.mapRequired("poi", fields.PointOfInstantiation);
367  }
368 };
369 } // namespace yaml
370 } // namespace llvm
371 
372 namespace {
373 class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
374  using CodeSynthesisContext = Sema::CodeSynthesisContext;
375 
376 public:
377  void initialize(const Sema &) override {}
378 
379  void finalize(const Sema &) override {}
380 
381  void atTemplateBegin(const Sema &TheSema,
382  const CodeSynthesisContext &Inst) override {
383  displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
384  }
385 
386  void atTemplateEnd(const Sema &TheSema,
387  const CodeSynthesisContext &Inst) override {
388  displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
389  }
390 
391 private:
392  static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
393  switch (Kind) {
394  case CodeSynthesisContext::TemplateInstantiation:
395  return "TemplateInstantiation";
396  case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
397  return "DefaultTemplateArgumentInstantiation";
398  case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
399  return "DefaultFunctionArgumentInstantiation";
400  case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
401  return "ExplicitTemplateArgumentSubstitution";
402  case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
403  return "DeducedTemplateArgumentSubstitution";
404  case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
405  return "PriorTemplateArgumentSubstitution";
406  case CodeSynthesisContext::DefaultTemplateArgumentChecking:
407  return "DefaultTemplateArgumentChecking";
408  case CodeSynthesisContext::ExceptionSpecEvaluation:
409  return "ExceptionSpecEvaluation";
410  case CodeSynthesisContext::ExceptionSpecInstantiation:
411  return "ExceptionSpecInstantiation";
412  case CodeSynthesisContext::DeclaringSpecialMember:
413  return "DeclaringSpecialMember";
414  case CodeSynthesisContext::DefiningSynthesizedFunction:
415  return "DefiningSynthesizedFunction";
416  case CodeSynthesisContext::Memoization:
417  return "Memoization";
418  }
419  return "";
420  }
421 
422  template <bool BeginInstantiation>
423  static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
424  const CodeSynthesisContext &Inst) {
425  std::string YAML;
426  {
427  llvm::raw_string_ostream OS(YAML);
428  llvm::yaml::Output YO(OS);
429  TemplightEntry Entry =
430  getTemplightEntry<BeginInstantiation>(TheSema, Inst);
431  llvm::yaml::EmptyContext Context;
432  llvm::yaml::yamlize(YO, Entry, true, Context);
433  }
434  Out << "---" << YAML << "\n";
435  }
436 
437  template <bool BeginInstantiation>
438  static TemplightEntry getTemplightEntry(const Sema &TheSema,
439  const CodeSynthesisContext &Inst) {
440  TemplightEntry Entry;
441  Entry.Kind = toString(Inst.Kind);
442  Entry.Event = BeginInstantiation ? "Begin" : "End";
443  if (auto *NamedTemplate = dyn_cast_or_null<NamedDecl>(Inst.Entity)) {
444  llvm::raw_string_ostream OS(Entry.Name);
445  NamedTemplate->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
446  const PresumedLoc DefLoc =
447  TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
448  if(!DefLoc.isInvalid())
449  Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
450  std::to_string(DefLoc.getLine()) + ":" +
451  std::to_string(DefLoc.getColumn());
452  }
453  const PresumedLoc PoiLoc =
454  TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
455  if (!PoiLoc.isInvalid()) {
456  Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
457  std::to_string(PoiLoc.getLine()) + ":" +
458  std::to_string(PoiLoc.getColumn());
459  }
460  return Entry;
461  }
462 };
463 } // namespace
464 
465 std::unique_ptr<ASTConsumer>
467  return llvm::make_unique<ASTConsumer>();
468 }
469 
472 
473  // This part is normally done by ASTFrontEndAction, but needs to happen
474  // before Templight observers can be created
475  // FIXME: Move the truncation aspect of this into Sema, we delayed this till
476  // here so the source manager would be initialized.
477  EnsureSemaIsCreated(CI, *this);
478 
479  CI.getSema().TemplateInstCallbacks.push_back(
480  llvm::make_unique<DefaultTemplateInstCallback>());
482 }
483 
484 namespace {
485  /// AST reader listener that dumps module information for a module
486  /// file.
487  class DumpModuleInfoListener : public ASTReaderListener {
488  llvm::raw_ostream &Out;
489 
490  public:
491  DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
492 
493 #define DUMP_BOOLEAN(Value, Text) \
494  Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
495 
496  bool ReadFullVersionInformation(StringRef FullVersion) override {
497  Out.indent(2)
498  << "Generated by "
499  << (FullVersion == getClangFullRepositoryVersion()? "this"
500  : "a different")
501  << " Clang: " << FullVersion << "\n";
503  }
504 
505  void ReadModuleName(StringRef ModuleName) override {
506  Out.indent(2) << "Module name: " << ModuleName << "\n";
507  }
508  void ReadModuleMapFile(StringRef ModuleMapPath) override {
509  Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
510  }
511 
512  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
513  bool AllowCompatibleDifferences) override {
514  Out.indent(2) << "Language options:\n";
515 #define LANGOPT(Name, Bits, Default, Description) \
516  DUMP_BOOLEAN(LangOpts.Name, Description);
517 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
518  Out.indent(4) << Description << ": " \
519  << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
520 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
521  Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
522 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
523 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
524 #include "clang/Basic/LangOptions.def"
525 
526  if (!LangOpts.ModuleFeatures.empty()) {
527  Out.indent(4) << "Module features:\n";
528  for (StringRef Feature : LangOpts.ModuleFeatures)
529  Out.indent(6) << Feature << "\n";
530  }
531 
532  return false;
533  }
534 
535  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
536  bool AllowCompatibleDifferences) override {
537  Out.indent(2) << "Target options:\n";
538  Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
539  Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
540  Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
541 
542  if (!TargetOpts.FeaturesAsWritten.empty()) {
543  Out.indent(4) << "Target features:\n";
544  for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
545  I != N; ++I) {
546  Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
547  }
548  }
549 
550  return false;
551  }
552 
553  bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
554  bool Complain) override {
555  Out.indent(2) << "Diagnostic options:\n";
556 #define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
557 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
558  Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
559 #define VALUE_DIAGOPT(Name, Bits, Default) \
560  Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
561 #include "clang/Basic/DiagnosticOptions.def"
562 
563  Out.indent(4) << "Diagnostic flags:\n";
564  for (const std::string &Warning : DiagOpts->Warnings)
565  Out.indent(6) << "-W" << Warning << "\n";
566  for (const std::string &Remark : DiagOpts->Remarks)
567  Out.indent(6) << "-R" << Remark << "\n";
568 
569  return false;
570  }
571 
572  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
573  StringRef SpecificModuleCachePath,
574  bool Complain) override {
575  Out.indent(2) << "Header search options:\n";
576  Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
577  Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
578  Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
580  "Use builtin include directories [-nobuiltininc]");
582  "Use standard system include directories [-nostdinc]");
584  "Use standard C++ include directories [-nostdinc++]");
585  DUMP_BOOLEAN(HSOpts.UseLibcxx,
586  "Use libc++ (rather than libstdc++) [-stdlib=]");
587  return false;
588  }
589 
590  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
591  bool Complain,
592  std::string &SuggestedPredefines) override {
593  Out.indent(2) << "Preprocessor options:\n";
595  "Uses compiler/target-specific predefines [-undef]");
597  "Uses detailed preprocessing record (for indexing)");
598 
599  if (!PPOpts.Macros.empty()) {
600  Out.indent(4) << "Predefined macros:\n";
601  }
602 
603  for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
604  I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
605  I != IEnd; ++I) {
606  Out.indent(6);
607  if (I->second)
608  Out << "-U";
609  else
610  Out << "-D";
611  Out << I->first << "\n";
612  }
613  return false;
614  }
615 
616  /// Indicates that a particular module file extension has been read.
617  void readModuleFileExtension(
618  const ModuleFileExtensionMetadata &Metadata) override {
619  Out.indent(2) << "Module file extension '"
620  << Metadata.BlockName << "' " << Metadata.MajorVersion
621  << "." << Metadata.MinorVersion;
622  if (!Metadata.UserInfo.empty()) {
623  Out << ": ";
624  Out.write_escaped(Metadata.UserInfo);
625  }
626 
627  Out << "\n";
628  }
629 
630  /// Tells the \c ASTReaderListener that we want to receive the
631  /// input files of the AST file via \c visitInputFile.
632  bool needsInputFileVisitation() override { return true; }
633 
634  /// Tells the \c ASTReaderListener that we want to receive the
635  /// input files of the AST file via \c visitInputFile.
636  bool needsSystemInputFileVisitation() override { return true; }
637 
638  /// Indicates that the AST file contains particular input file.
639  ///
640  /// \returns true to continue receiving the next input file, false to stop.
641  bool visitInputFile(StringRef Filename, bool isSystem,
642  bool isOverridden, bool isExplicitModule) override {
643 
644  Out.indent(2) << "Input file: " << Filename;
645 
646  if (isSystem || isOverridden || isExplicitModule) {
647  Out << " [";
648  if (isSystem) {
649  Out << "System";
650  if (isOverridden || isExplicitModule)
651  Out << ", ";
652  }
653  if (isOverridden) {
654  Out << "Overridden";
655  if (isExplicitModule)
656  Out << ", ";
657  }
658  if (isExplicitModule)
659  Out << "ExplicitModule";
660 
661  Out << "]";
662  }
663 
664  Out << "\n";
665 
666  return true;
667  }
668 
669  /// Returns true if this \c ASTReaderListener wants to receive the
670  /// imports of the AST file via \c visitImport, false otherwise.
671  bool needsImportVisitation() const override { return true; }
672 
673  /// If needsImportVisitation returns \c true, this is called for each
674  /// AST file imported by this AST file.
675  void visitImport(StringRef ModuleName, StringRef Filename) override {
676  Out.indent(2) << "Imports module '" << ModuleName
677  << "': " << Filename.str() << "\n";
678  }
679 #undef DUMP_BOOLEAN
680  };
681 }
682 
684  // The Object file reader also supports raw ast files and there is no point in
685  // being strict about the module file format in -module-file-info mode.
686  CI.getHeaderSearchOpts().ModuleFormat = "obj";
687  return true;
688 }
689 
691  // Set up the output file.
692  std::unique_ptr<llvm::raw_fd_ostream> OutFile;
693  StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
694  if (!OutputFileName.empty() && OutputFileName != "-") {
695  std::error_code EC;
696  OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
697  llvm::sys::fs::F_Text));
698  }
699  llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
700 
701  Out << "Information for module file '" << getCurrentFile() << "':\n";
702  auto &FileMgr = getCompilerInstance().getFileManager();
703  auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
704  StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
705  bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&
706  Magic[2] == 'C' && Magic[3] == 'H');
707  Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
708 
710  DumpModuleInfoListener Listener(Out);
711  HeaderSearchOptions &HSOpts =
712  PP.getHeaderSearchInfo().getHeaderSearchOpts();
714  getCurrentFile(), FileMgr, getCompilerInstance().getPCHContainerReader(),
715  /*FindModuleFileExtensions=*/true, Listener,
717 }
718 
719 //===----------------------------------------------------------------------===//
720 // Preprocessor Actions
721 //===----------------------------------------------------------------------===//
722 
726 
727  // Start lexing the specified input file.
728  const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
729  Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
730  RawLex.SetKeepWhitespaceMode(true);
731 
732  Token RawTok;
733  RawLex.LexFromRawLexer(RawTok);
734  while (RawTok.isNot(tok::eof)) {
735  PP.DumpToken(RawTok, true);
736  llvm::errs() << "\n";
737  RawLex.LexFromRawLexer(RawTok);
738  }
739 }
740 
743  // Start preprocessing the specified input file.
744  Token Tok;
745  PP.EnterMainSourceFile();
746  do {
747  PP.Lex(Tok);
748  PP.DumpToken(Tok, true);
749  llvm::errs() << "\n";
750  } while (Tok.isNot(tok::eof));
751 }
752 
755  std::unique_ptr<raw_pwrite_stream> OS =
757  if (!OS)
758  return;
759 
760  CacheTokens(CI.getPreprocessor(), OS.get());
761 }
762 
765 
766  // Ignore unknown pragmas.
767  PP.IgnorePragmas();
768 
769  Token Tok;
770  // Start parsing the specified input file.
771  PP.EnterMainSourceFile();
772  do {
773  PP.Lex(Tok);
774  } while (Tok.isNot(tok::eof));
775 }
776 
779  // Output file may need to be set to 'Binary', to avoid converting Unix style
780  // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
781  //
782  // Look to see what type of line endings the file uses. If there's a
783  // CRLF, then we won't open the file up in binary mode. If there is
784  // just an LF or CR, then we will open the file up in binary mode.
785  // In this fashion, the output format should match the input format, unless
786  // the input format has inconsistent line endings.
787  //
788  // This should be a relatively fast operation since most files won't have
789  // all of their source code on a single line. However, that is still a
790  // concern, so if we scan for too long, we'll just assume the file should
791  // be opened in binary mode.
792  bool BinaryMode = true;
793  bool InvalidFile = false;
794  const SourceManager& SM = CI.getSourceManager();
795  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
796  &InvalidFile);
797  if (!InvalidFile) {
798  const char *cur = Buffer->getBufferStart();
799  const char *end = Buffer->getBufferEnd();
800  const char *next = (cur != end) ? cur + 1 : end;
801 
802  // Limit ourselves to only scanning 256 characters into the source
803  // file. This is mostly a sanity check in case the file has no
804  // newlines whatsoever.
805  if (end - cur > 256) end = cur + 256;
806 
807  while (next < end) {
808  if (*cur == 0x0D) { // CR
809  if (*next == 0x0A) // CRLF
810  BinaryMode = false;
811 
812  break;
813  } else if (*cur == 0x0A) // LF
814  break;
815 
816  ++cur;
817  ++next;
818  }
819  }
820 
821  std::unique_ptr<raw_ostream> OS =
823  if (!OS) return;
824 
825  // If we're preprocessing a module map, start by dumping the contents of the
826  // module itself before switching to the input buffer.
827  auto &Input = getCurrentInput();
828  if (Input.getKind().getFormat() == InputKind::ModuleMap) {
829  if (Input.isFile()) {
830  (*OS) << "# 1 \"";
831  OS->write_escaped(Input.getFile());
832  (*OS) << "\"\n";
833  }
834  getCurrentModule()->print(*OS);
835  (*OS) << "#pragma clang module contents\n";
836  }
837 
840 }
841 
843  switch (getCurrentFileKind().getLanguage()) {
844  case InputKind::C:
845  case InputKind::CXX:
846  case InputKind::ObjC:
847  case InputKind::ObjCXX:
848  case InputKind::OpenCL:
849  case InputKind::CUDA:
850  case InputKind::HIP:
851  break;
852 
853  case InputKind::Unknown:
854  case InputKind::Asm:
855  case InputKind::LLVM_IR:
857  // We can't do anything with these.
858  return;
859  }
860 
861  // We don't expect to find any #include directives in a preprocessed input.
862  if (getCurrentFileKind().isPreprocessed())
863  return;
864 
866  auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
867  if (Buffer) {
868  unsigned Preamble =
869  Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
870  llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
871  }
872 }
873 
874 void DumpCompilerOptionsAction::ExecuteAction() {
876  std::unique_ptr<raw_ostream> OSP =
878  if (!OSP)
879  return;
880 
881  raw_ostream &OS = *OSP;
882  const Preprocessor &PP = CI.getPreprocessor();
883  const LangOptions &LangOpts = PP.getLangOpts();
884 
885  // FIXME: Rather than manually format the JSON (which is awkward due to
886  // needing to remove trailing commas), this should make use of a JSON library.
887  // FIXME: Instead of printing enums as an integral value and specifying the
888  // type as a separate field, use introspection to print the enumerator.
889 
890  OS << "{\n";
891  OS << "\n\"features\" : [\n";
892  {
894 #define FEATURE(Name, Predicate) \
895  ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
896  .toVector(Str);
897 #include "clang/Basic/Features.def"
898 #undef FEATURE
899  // Remove the newline and comma from the last entry to ensure this remains
900  // valid JSON.
901  OS << Str.substr(0, Str.size() - 2);
902  }
903  OS << "\n],\n";
904 
905  OS << "\n\"extensions\" : [\n";
906  {
908 #define EXTENSION(Name, Predicate) \
909  ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
910  .toVector(Str);
911 #include "clang/Basic/Features.def"
912 #undef EXTENSION
913  // Remove the newline and comma from the last entry to ensure this remains
914  // valid JSON.
915  OS << Str.substr(0, Str.size() - 2);
916  }
917  OS << "\n]\n";
918 
919  OS << "}";
920 }
std::string OutputFile
The output file, if any.
LangOptions & getLangOpts()
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred...
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
PreprocessorOptions & getPreprocessorOpts()
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
std::vector< std::pair< std::string, bool > > Macros
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens...
Definition: Lexer.h:77
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained)...
Definition: Sema.h:7314
Defines the clang::FileManager interface and associated types.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Abstract base class for actions which can be performed by the frontend.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
void finalize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
ASTContext & getASTContext() const
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:80
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:1851
Options for controlling the target.
Definition: TargetOptions.h:26
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:7141
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static StringRef getModuleInputBufferName()
Definition: Module.h:574
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Module * getCurrentModule() const
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
The client can handle an AST file that cannot load because it&#39;s compiled configuration doesn&#39;t match ...
Definition: ASTReader.h:1525
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:827
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
Languages that the frontend can parse and compile.
static bool ComputeASTConsumerArguments(CompilerInstance &CI, std::string &Sysroot)
Compute the AST consumer arguments that will be used to create the PCHGenerator instance returned by ...
This is a base class for callbacks that will be notified at every template instantiation.
CompilerInstance & getCompilerInstance() const
std::string UserInfo
A string containing additional user information that will be stored with the metadata.
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:833
std::string getCachedModuleFileName(Module *Module)
Retrieve the name of the cached module file that should be used to load the given module...
FrontendOptions & getFrontendOpts()
const FormatToken & Tok
static void mapping(IO &io, TemplightEntry &fields)
StringRef getCurrentFileOrBufferName() const
PreprocessorOutputOptions & getPreprocessorOutputOpts()
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
virtual bool BeginInvocation(CompilerInstance &CI)
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
void CacheTokens(Preprocessor &PP, raw_pwrite_stream *OS)
Cache tokens for use with PCH. Note that this requires a seekable stream.
bool BeginInvocation(CompilerInstance &CI) override
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
#define DUMP_BOOLEAN(Value, Text)
const LangOptions & getLangOpts() const
Definition: Sema.h:1220
HeaderSearchOptions & getHeaderSearchOpts()
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
CodeCompleteConsumer & getCodeCompletionConsumer() const
std::vector< std::string > ModuleFeatures
The names of any features to enable in module &#39;requires&#39; decls in addition to the hard-coded list in ...
Definition: LangOptions.h:225
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:148
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:219
StringRef Filename
Definition: Format.cpp:1629
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
std::unique_ptr< ASTConsumer > CreateASTDumper(std::unique_ptr< raw_ostream > OS, StringRef FilterString, bool DumpDecls, bool Deserialize, bool DumpLookups)
void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts)
DoPrintPreprocessedInput - Implement -E mode.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
static PreambleBounds ComputePreamble(StringRef Buffer, const LangOptions &LangOpts, unsigned MaxLines=0)
Compute the preamble of the given file.
Definition: Lexer.cpp:574
bool isInvalid() const
Return true if this object is invalid or uninitialized.
unsigned getLine() const
Return the presumed line number of this location.
Compiling a module from a list of header files.
Definition: LangOptions.h:77
void EnterMainSourceFile()
Enter the specified FileID as the main source file, which implicitly adds the builtin defines etc...
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
Definition: Module.cpp:405
Defines the clang::Preprocessor interface.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
Represents an unpacked "presumed" location which can be presented to the user.
An input file for the front end.
InputKind getCurrentFileKind() const
const SourceManager & SM
Definition: Format.cpp:1490
unsigned MajorVersion
The major version of the extension data.
std::unique_ptr< raw_pwrite_stream > createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file and add it to the list of tracked output files, optionally deriving the outp...
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
unsigned MinorVersion
The minor version of the extension data.
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
SourceManager & getSourceManager() const
Definition: Preprocessor.h:831
const char * getFilename() const
Return the presumed filename of this location.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Kind
llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
std::string ABI
If given, the name of the target ABI to use.
Definition: TargetOptions.h:42
File is a PCH file treated as the preamble.
Definition: Module.h:54
unsigned getColumn() const
Return the presumed column number of this location.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
Assembly: we accept this only so that we can preprocess it.
File is a PCH file treated as such.
Definition: Module.h:51
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we&#39;re handling.
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
std::vector< FrontendInputFile > Inputs
The input files and their types.
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:60
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:90
void Lex(Token &Result)
Lex the next token for this preprocessor.
virtual bool PrepareToExecuteAction(CompilerInstance &CI)
Prepare to execute the action on the given CompilerInstance.
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:135
unsigned ASTDumpLookups
Whether we include lookup table dumps in AST dumps.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line...
Definition: TargetOptions.h:51
void DumpToken(const Token &Tok, bool DumpFlags=false) const
Print the token to stderr, used for debugging.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Abstract interface for a consumer of code-completion information.
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
Dataflow Directional Tag Classes.
FileManager & getFileManager() const
Return the current file manager to the caller.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
const FrontendInputFile & getCurrentInput() const
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:355
FileID getMainFileID() const
Returns the FileID of the main source file.
StringRef getCurrentFile() const
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
virtual std::unique_ptr< ASTConsumer > CreatePCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName, const std::string &OutputFileName, std::unique_ptr< llvm::raw_pwrite_stream > OS, std::shared_ptr< PCHBuffer > Buffer) const =0
Return an ASTConsumer that can be chained with a PCHGenerator that produces a wrapper file format con...
SourceManager & getSourceManager() const
Return the current source manager.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
std::string BlockName
The name used to identify this particular extension block within the resulting module file...
std::string toString(const til::SExpr *E)
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:127
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation&#39;s options) and add it to the list of tracked outp...
std::unique_ptr< ASTConsumer > CreateASTViewer()
Metadata for a module file extension.
Preprocessor & getPreprocessor() const
Return the current preprocessor.
bool hasCodeCompletionConsumer() const
std::unique_ptr< ASTConsumer > CreateASTDeclNodeLister()
virtual bool BeginSourceFileAction(CompilerInstance &CI)
Callback at the start of processing a single input.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
SourceManager & getSourceManager() const
Definition: Sema.h:1225
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions)
Read the control block for the named AST file.
Definition: ASTReader.cpp:4718
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static std::unique_ptr< llvm::raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile, std::string &OutputFile)
Creates file to write the PCH into and returns a stream to write it into.
std::unique_ptr< ASTConsumer > CreateASTPrinter(std::unique_ptr< raw_ostream > OS, StringRef FilterString)
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
void SetKeepWhitespaceMode(bool Val)
SetKeepWhitespaceMode - This method lets clients enable or disable whitespace retention mode...
Definition: Lexer.h:213
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
Definition: SourceManager.h:83
This class handles loading and caching of source files into memory.
std::string ModuleFormat
The module/pch container format.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...