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