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