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 292