contrib/llvm-project/clang/include/clang/Frontend/FrontendActions.h

   1 //===-- FrontendActions.h - Useful Frontend Actions -------------*- C++ -*-===//
   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
   9 #ifndef LLVM_CLANG_FRONTEND_FRONTENDACTIONS_H
  10 #define LLVM_CLANG_FRONTEND_FRONTENDACTIONS_H
  11
  12 #include "clang/Frontend/FrontendAction.h"
  13 #include <string>
  14 #include <vector>
  15
  16 namespace clang {
  17
  18 class Module;
  19 class FileEntry;
  20
  21 //===----------------------------------------------------------------------===//
  22 // Custom Consumer Actions
  23 //===----------------------------------------------------------------------===//
  24
  25 class InitOnlyAction : public FrontendAction {
  26   void ExecuteAction() override;
  27
  28   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  29                                                  StringRef InFile) override;
  30
  31 public:
  32   // Don't claim to only use the preprocessor, we want to follow the AST path,
  33   // but do nothing.
  34   bool usesPreprocessorOnly() const override { return false; }
  35 };
  36
  37 class DumpCompilerOptionsAction : public FrontendAction {
  38   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  39                                                  StringRef InFile) override {
  40     return nullptr;
  41   }
  42
  43   void ExecuteAction() override;
  44
  45 public:
  46   bool usesPreprocessorOnly() const override { return true; }
  47 };
  48
  49 //===----------------------------------------------------------------------===//
  50 // AST Consumer Actions
  51 //===----------------------------------------------------------------------===//
  52
  53 class ASTPrintAction : public ASTFrontendAction {
  54 protected:
  55   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  56                                                  StringRef InFile) override;
  57 };
  58
  59 class ASTDumpAction : public ASTFrontendAction {
  60 protected:
  61   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  62                                                  StringRef InFile) override;
  63 };
  64
  65 class ASTDeclListAction : public ASTFrontendAction {
  66 protected:
  67   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  68                                                  StringRef InFile) override;
  69 };
  70
  71 class ASTViewAction : public ASTFrontendAction {
  72 protected:
  73   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  74                                                  StringRef InFile) override;
  75 };
  76
  77 class GeneratePCHAction : public ASTFrontendAction {
  78 protected:
  79   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
  80                                                  StringRef InFile) override;
  81
  82   TranslationUnitKind getTranslationUnitKind() override {
  83     return TU_Prefix;
  84   }
  85
  86   bool hasASTFileSupport() const override { return false; }
  87
  88   bool shouldEraseOutputFiles() override;
  89
  90 public:
  91   /// Compute the AST consumer arguments that will be used to
  92   /// create the PCHGenerator instance returned by CreateASTConsumer.
  93   ///
  94   /// \returns false if an error occurred, true otherwise.
  95   static bool ComputeASTConsumerArguments(CompilerInstance &CI,
  96                                           std::string &Sysroot);
  97
  98   /// Creates file to write the PCH into and returns a stream to write it
  99   /// into. On error, returns null.
 100   static std::unique_ptr<llvm::raw_pwrite_stream>
 101   CreateOutputFile(CompilerInstance &CI, StringRef InFile,
 102                    std::string &OutputFile);
 103
 104   bool BeginSourceFileAction(CompilerInstance &CI) override;
 105 };
 106
 107 class GenerateModuleAction : public ASTFrontendAction {
 108   virtual std::unique_ptr<raw_pwrite_stream>
 109   CreateOutputFile(CompilerInstance &CI, StringRef InFile) = 0;
 110
 111 protected:
 112   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 113                                                  StringRef InFile) override;
 114
 115   TranslationUnitKind getTranslationUnitKind() override {
 116     return TU_Module;
 117   }
 118
 119   bool hasASTFileSupport() const override { return false; }
 120 };
 121
 122 class GenerateInterfaceStubsAction : public ASTFrontendAction {
 123 protected:
 124   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 125                                                  StringRef InFile) override;
 126
 127   TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
 128   bool hasASTFileSupport() const override { return false; }
 129 };
 130
 131 class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
 132 private:
 133   bool BeginSourceFileAction(CompilerInstance &CI) override;
 134
 135   std::unique_ptr<raw_pwrite_stream>
 136   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 137 };
 138
 139 class GenerateModuleInterfaceAction : public GenerateModuleAction {
 140 private:
 141   bool BeginSourceFileAction(CompilerInstance &CI) override;
 142
 143   std::unique_ptr<raw_pwrite_stream>
 144   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 145 };
 146
 147 class GenerateHeaderModuleAction : public GenerateModuleAction {
 148   /// The synthesized module input buffer for the current compilation.
 149   std::unique_ptr<llvm::MemoryBuffer> Buffer;
 150   std::vector<std::string> ModuleHeaders;
 151
 152 private:
 153   bool PrepareToExecuteAction(CompilerInstance &CI) override;
 154   bool BeginSourceFileAction(CompilerInstance &CI) override;
 155
 156   std::unique_ptr<raw_pwrite_stream>
 157   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 158 };
 159
 160 class SyntaxOnlyAction : public ASTFrontendAction {
 161 protected:
 162   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 163                                                  StringRef InFile) override;
 164
 165 public:
 166   ~SyntaxOnlyAction() override;
 167   bool hasCodeCompletionSupport() const override { return true; }
 168 };
 169
 170 /// Dump information about the given module file, to be used for
 171 /// basic debugging and discovery.
 172 class DumpModuleInfoAction : public ASTFrontendAction {
 173 protected:
 174   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 175                                                  StringRef InFile) override;
 176   bool BeginInvocation(CompilerInstance &CI) override;
 177   void ExecuteAction() override;
 178
 179 public:
 180   bool hasPCHSupport() const override { return false; }
 181   bool hasASTFileSupport() const override { return true; }
 182   bool hasIRSupport() const override { return false; }
 183   bool hasCodeCompletionSupport() const override { return false; }
 184 };
 185
 186 class VerifyPCHAction : public ASTFrontendAction {
 187 protected:
 188   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 189                                                  StringRef InFile) override;
 190
 191   void ExecuteAction() override;
 192
 193 public:
 194   bool hasCodeCompletionSupport() const override { return false; }
 195 };
 196
 197 class TemplightDumpAction : public ASTFrontendAction {
 198 protected:
 199   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 200                                                  StringRef InFile) override;
 201
 202   void ExecuteAction() override;
 203 };
 204
 205 /**
 206  * Frontend action adaptor that merges ASTs together.
 207  *
 208  * This action takes an existing AST file and "merges" it into the AST
 209  * context, producing a merged context. This action is an action
 210  * adaptor, which forwards most of its calls to another action that
 211  * will consume the merged context.
 212  */
 213 class ASTMergeAction : public FrontendAction {
 214   /// The action that the merge action adapts.
 215   std::unique_ptr<FrontendAction> AdaptedAction;
 216
 217   /// The set of AST files to merge.
 218   std::vector<std::string> ASTFiles;
 219
 220 protected:
 221   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 222                                                  StringRef InFile) override;
 223
 224   bool BeginSourceFileAction(CompilerInstance &CI) override;
 225
 226   void ExecuteAction() override;
 227   void EndSourceFileAction() override;
 228
 229 public:
 230   ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
 231                  ArrayRef<std::string> ASTFiles);
 232   ~ASTMergeAction() override;
 233
 234   bool usesPreprocessorOnly() const override;
 235   TranslationUnitKind getTranslationUnitKind() override;
 236   bool hasPCHSupport() const override;
 237   bool hasASTFileSupport() const override;
 238   bool hasCodeCompletionSupport() const override;
 239 };
 240
 241 class PrintPreambleAction : public FrontendAction {
 242 protected:
 243   void ExecuteAction() override;
 244   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
 245                                                  StringRef) override {
 246     return nullptr;
 247   }
 248
 249   bool usesPreprocessorOnly() const override { return true; }
 250 };
 251
 252 class PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
 253 protected:
 254   void ExecuteAction() override;
 255   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
 256                                                  StringRef) override {
 257     return nullptr;
 258   }
 259
 260   bool usesPreprocessorOnly() const override { return true; }
 261 };
 262
 263 //===----------------------------------------------------------------------===//
 264 // Preprocessor Actions
 265 //===----------------------------------------------------------------------===//
 266
 267 class DumpRawTokensAction : public PreprocessorFrontendAction {
 268 protected:
 269   void ExecuteAction() override;
 270 };
 271
 272 class DumpTokensAction : public PreprocessorFrontendAction {
 273 protected:
 274   void ExecuteAction() override;
 275 };
 276
 277 class PreprocessOnlyAction : public PreprocessorFrontendAction {
 278 protected:
 279   void ExecuteAction() override;
 280 };
 281
 282 class PrintPreprocessedAction : public PreprocessorFrontendAction {
 283 protected:
 284   void ExecuteAction() override;
 285
 286   bool hasPCHSupport() const override { return true; }
 287 };
 288
 289 }  // end namespace clang
 290
 291 #endif