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