clang  9.0.0svn
FrontendActions.cpp
Go to the documentation of this file.
1 //===--- FrontendActions.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"
16 #include "clang/Frontend/Utils.h"
17 #include "clang/Lex/HeaderSearch.h"
18 #include "clang/Lex/Preprocessor.h"
23 #include "llvm/Support/FileSystem.h"
24 #include "llvm/Support/MemoryBuffer.h"
25 #include "llvm/Support/Path.h"
26 #include "llvm/Support/raw_ostream.h"
27 #include "llvm/Support/YAMLTraits.h"
28 #include <memory>
29 #include <system_error>
30 
31 using namespace clang;
32 
33 namespace {
34 CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
36  : nullptr;
37 }
38 
39 void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
40  if (Action.hasCodeCompletionSupport() &&
43 
44  if (!CI.hasSema())
46  GetCodeCompletionConsumer(CI));
47 }
48 } // namespace
49 
50 //===----------------------------------------------------------------------===//
51 // Custom Actions
52 //===----------------------------------------------------------------------===//
53 
54 std::unique_ptr<ASTConsumer>
55 InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
56  return llvm::make_unique<ASTConsumer>();
57 }
58 
59 void InitOnlyAction::ExecuteAction() {
60 }
61 
62 //===----------------------------------------------------------------------===//
63 // AST Consumer Actions
64 //===----------------------------------------------------------------------===//
65 
66 std::unique_ptr<ASTConsumer>
68  if (std::unique_ptr<raw_ostream> OS =
69  CI.createDefaultOutputFile(false, InFile))
70  return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
71  return nullptr;
72 }
73 
74 std::unique_ptr<ASTConsumer>
76  const FrontendOptions &Opts = CI.getFrontendOpts();
77  return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,
78  Opts.ASTDumpDecls, Opts.ASTDumpAll,
79  Opts.ASTDumpLookups, Opts.ASTDumpFormat);
80 }
81 
82 std::unique_ptr<ASTConsumer>
84  return CreateASTDeclNodeLister();
85 }
86 
87 std::unique_ptr<ASTConsumer>
89  return CreateASTViewer();
90 }
91 
92 std::unique_ptr<ASTConsumer>
94  std::string Sysroot;
95  if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
96  return nullptr;
97 
98  std::string OutputFile;
99  std::unique_ptr<raw_pwrite_stream> OS =
100  CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
101  if (!OS)
102  return nullptr;
103 
105  Sysroot.clear();
106 
107  const auto &FrontendOpts = CI.getFrontendOpts();
108  auto Buffer = std::make_shared<PCHBuffer>();
109  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
110  Consumers.push_back(llvm::make_unique<PCHGenerator>(
111  CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
112  FrontendOpts.ModuleFileExtensions,
114  FrontendOpts.IncludeTimestamps, +CI.getLangOpts().CacheGeneratedPCH));
115  Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
116  CI, InFile, OutputFile, std::move(OS), Buffer));
117 
118  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
119 }
120 
122  std::string &Sysroot) {
123  Sysroot = CI.getHeaderSearchOpts().Sysroot;
124  if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
125  CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
126  return false;
127  }
128 
129  return true;
130 }
131 
132 std::unique_ptr<llvm::raw_pwrite_stream>
134  std::string &OutputFile) {
135  // We use createOutputFile here because this is exposed via libclang, and we
136  // must disable the RemoveFileOnSignal behavior.
137  // We use a temporary to avoid race conditions.
138  std::unique_ptr<raw_pwrite_stream> OS =
139  CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
140  /*RemoveFileOnSignal=*/false, InFile,
141  /*Extension=*/"", /*useTemporary=*/true);
142  if (!OS)
143  return nullptr;
144 
145  OutputFile = CI.getFrontendOpts().OutputFile;
146  return OS;
147 }
148 
150  if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
151  return false;
153 }
154 
156  CI.getLangOpts().CompilingPCH = true;
157  return true;
158 }
159 
160 std::unique_ptr<ASTConsumer>
162  StringRef InFile) {
163  std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
164  if (!OS)
165  return nullptr;
166 
167  std::string OutputFile = CI.getFrontendOpts().OutputFile;
168  std::string Sysroot;
169 
170  auto Buffer = std::make_shared<PCHBuffer>();
171  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
172 
173  Consumers.push_back(llvm::make_unique<PCHGenerator>(
174  CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
176  /*AllowASTWithErrors=*/false,
177  /*IncludeTimestamps=*/
179  /*ShouldCacheASTInMemory=*/
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 && !CI.getLangOpts().CPlusPlusModules) {
224  CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
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) {
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, 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(
333  CI.getPreprocessor(), CI.getModuleCache(), &CI.getASTContext(),
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 
756  // Ignore unknown pragmas.
757  PP.IgnorePragmas();
758 
759  Token Tok;
760  // Start parsing the specified input file.
761  PP.EnterMainSourceFile();
762  do {
763  PP.Lex(Tok);
764  } while (Tok.isNot(tok::eof));
765 }
766 
769  // Output file may need to be set to 'Binary', to avoid converting Unix style
770  // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
771  //
772  // Look to see what type of line endings the file uses. If there's a
773  // CRLF, then we won't open the file up in binary mode. If there is
774  // just an LF or CR, then we will open the file up in binary mode.
775  // In this fashion, the output format should match the input format, unless
776  // the input format has inconsistent line endings.
777  //
778  // This should be a relatively fast operation since most files won't have
779  // all of their source code on a single line. However, that is still a
780  // concern, so if we scan for too long, we'll just assume the file should
781  // be opened in binary mode.
782  bool BinaryMode = true;
783  bool InvalidFile = false;
784  const SourceManager& SM = CI.getSourceManager();
785  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
786  &InvalidFile);
787  if (!InvalidFile) {
788  const char *cur = Buffer->getBufferStart();
789  const char *end = Buffer->getBufferEnd();
790  const char *next = (cur != end) ? cur + 1 : end;
791 
792  // Limit ourselves to only scanning 256 characters into the source
793  // file. This is mostly a sanity check in case the file has no
794  // newlines whatsoever.
795  if (end - cur > 256) end = cur + 256;
796 
797  while (next < end) {
798  if (*cur == 0x0D) { // CR
799  if (*next == 0x0A) // CRLF
800  BinaryMode = false;
801 
802  break;
803  } else if (*cur == 0x0A) // LF
804  break;
805 
806  ++cur;
807  ++next;
808  }
809  }
810 
811  std::unique_ptr<raw_ostream> OS =
813  if (!OS) return;
814 
815  // If we're preprocessing a module map, start by dumping the contents of the
816  // module itself before switching to the input buffer.
817  auto &Input = getCurrentInput();
818  if (Input.getKind().getFormat() == InputKind::ModuleMap) {
819  if (Input.isFile()) {
820  (*OS) << "# 1 \"";
821  OS->write_escaped(Input.getFile());
822  (*OS) << "\"\n";
823  }
824  getCurrentModule()->print(*OS);
825  (*OS) << "#pragma clang module contents\n";
826  }
827 
830 }
831 
833  switch (getCurrentFileKind().getLanguage()) {
834  case InputKind::C:
835  case InputKind::CXX:
836  case InputKind::ObjC:
837  case InputKind::ObjCXX:
838  case InputKind::OpenCL:
839  case InputKind::CUDA:
840  case InputKind::HIP:
841  break;
842 
843  case InputKind::Unknown:
844  case InputKind::Asm:
845  case InputKind::LLVM_IR:
847  // We can't do anything with these.
848  return;
849  }
850 
851  // We don't expect to find any #include directives in a preprocessed input.
852  if (getCurrentFileKind().isPreprocessed())
853  return;
854 
856  auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
857  if (Buffer) {
858  unsigned Preamble =
859  Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
860  llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
861  }
862 }
863 
864 void DumpCompilerOptionsAction::ExecuteAction() {
866  std::unique_ptr<raw_ostream> OSP =
868  if (!OSP)
869  return;
870 
871  raw_ostream &OS = *OSP;
872  const Preprocessor &PP = CI.getPreprocessor();
873  const LangOptions &LangOpts = PP.getLangOpts();
874 
875  // FIXME: Rather than manually format the JSON (which is awkward due to
876  // needing to remove trailing commas), this should make use of a JSON library.
877  // FIXME: Instead of printing enums as an integral value and specifying the
878  // type as a separate field, use introspection to print the enumerator.
879 
880  OS << "{\n";
881  OS << "\n\"features\" : [\n";
882  {
884 #define FEATURE(Name, Predicate) \
885  ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
886  .toVector(Str);
887 #include "clang/Basic/Features.def"
888 #undef FEATURE
889  // Remove the newline and comma from the last entry to ensure this remains
890  // valid JSON.
891  OS << Str.substr(0, Str.size() - 2);
892  }
893  OS << "\n],\n";
894 
895  OS << "\n\"extensions\" : [\n";
896  {
898 #define EXTENSION(Name, Predicate) \
899  ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
900  .toVector(Str);
901 #include "clang/Basic/Features.def"
902 #undef EXTENSION
903  // Remove the newline and comma from the last entry to ensure this remains
904  // valid JSON.
905  OS << Str.substr(0, Str.size() - 2);
906  }
907  OS << "\n]\n";
908 
909  OS << "}";
910 }
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:76
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:7512
Defines the clang::FileManager interface and associated types.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:29
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:1296
InMemoryModuleCache & getModuleCache() const
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:84
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:1893
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:7337
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:581
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
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:34
The client can handle an AST file that cannot load because it&#39;s compiled configuration doesn&#39;t match ...
Definition: ASTReader.h:1521
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:903
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:908
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...
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:1276
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:232
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:158
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:328
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:226
StringRef Filename
Definition: Format.cpp:1707
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.
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:573
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:81
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:419
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:1568
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:907
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.
Kind
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:53
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:50
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:59
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:89
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:134
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:98
ASTDumpOutputFormat ASTDumpFormat
Specifies the output format of the AST.
const llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
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:354
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.
FrontendOptions - Options for controlling the behavior of the frontend.
std::string BlockName
The name used to identify this particular extension block within the resulting module file...
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:126
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:1281
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:4739
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:212
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
std::unique_ptr< ASTConsumer > CreateASTDumper(std::unique_ptr< raw_ostream > OS, StringRef FilterString, bool DumpDecls, bool Deserialize, bool DumpLookups, ASTDumpOutputFormat Format)
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
Definition: SourceManager.h:82
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:124
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...