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