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 GenerateInterfaceStubAction : public ASTFrontendAction {
123 protected:
124   TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
125 
126   bool hasASTFileSupport() const override { return false; }
127 };
128 
129 class GenerateInterfaceIfsExpV1Action : public GenerateInterfaceStubAction {
130 protected:
131   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
132                                                  StringRef InFile) override;
133 };
134 
135 class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
136 private:
137   bool BeginSourceFileAction(CompilerInstance &CI) override;
138 
139   std::unique_ptr<raw_pwrite_stream>
140   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
141 };
142 
143 class GenerateModuleInterfaceAction : public GenerateModuleAction {
144 private:
145   bool BeginSourceFileAction(CompilerInstance &CI) override;
146 
147   std::unique_ptr<raw_pwrite_stream>
148   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
149 };
150 
151 class GenerateHeaderModuleAction : public GenerateModuleAction {
152   /// The synthesized module input buffer for the current compilation.
153   std::unique_ptr<llvm::MemoryBuffer> Buffer;
154   std::vector<std::string> ModuleHeaders;
155 
156 private:
157   bool PrepareToExecuteAction(CompilerInstance &CI) override;
158   bool BeginSourceFileAction(CompilerInstance &CI) override;
159 
160   std::unique_ptr<raw_pwrite_stream>
161   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
162 };
163 
164 class SyntaxOnlyAction : public ASTFrontendAction {
165 protected:
166   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
167                                                  StringRef InFile) override;
168 
169 public:
170   ~SyntaxOnlyAction() override;
171   bool hasCodeCompletionSupport() const override { return true; }
172 };
173 
174 /// Dump information about the given module file, to be used for
175 /// basic debugging and discovery.
176 class DumpModuleInfoAction : public ASTFrontendAction {
177 protected:
178   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
179                                                  StringRef InFile) override;
180   bool BeginInvocation(CompilerInstance &CI) override;
181   void ExecuteAction() override;
182 
183 public:
184   bool hasPCHSupport() const override { return false; }
185   bool hasASTFileSupport() const override { return true; }
186   bool hasIRSupport() const override { return false; }
187   bool hasCodeCompletionSupport() const override { return false; }
188 };
189 
190 class VerifyPCHAction : public ASTFrontendAction {
191 protected:
192   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
193                                                  StringRef InFile) override;
194 
195   void ExecuteAction() override;
196 
197 public:
198   bool hasCodeCompletionSupport() const override { return false; }
199 };
200 
201 class TemplightDumpAction : public ASTFrontendAction {
202 protected:
203   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
204                                                  StringRef InFile) override;
205 
206   void ExecuteAction() override;
207 };
208 
209 /**
210  * Frontend action adaptor that merges ASTs together.
211  *
212  * This action takes an existing AST file and "merges" it into the AST
213  * context, producing a merged context. This action is an action
214  * adaptor, which forwards most of its calls to another action that
215  * will consume the merged context.
216  */
217 class ASTMergeAction : public FrontendAction {
218   /// The action that the merge action adapts.
219   std::unique_ptr<FrontendAction> AdaptedAction;
220 
221   /// The set of AST files to merge.
222   std::vector<std::string> ASTFiles;
223 
224 protected:
225   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
226                                                  StringRef InFile) override;
227 
228   bool BeginSourceFileAction(CompilerInstance &CI) override;
229 
230   void ExecuteAction() override;
231   void EndSourceFileAction() override;
232 
233 public:
234   ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
235                  ArrayRef<std::string> ASTFiles);
236   ~ASTMergeAction() override;
237 
238   bool usesPreprocessorOnly() const override;
239   TranslationUnitKind getTranslationUnitKind() override;
240   bool hasPCHSupport() const override;
241   bool hasASTFileSupport() const override;
242   bool hasCodeCompletionSupport() const override;
243 };
244 
245 class PrintPreambleAction : public FrontendAction {
246 protected:
247   void ExecuteAction() override;
248   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
249                                                  StringRef) override {
250     return nullptr;
251   }
252 
253   bool usesPreprocessorOnly() const override { return true; }
254 };
255 
256 class PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
257 protected:
258   void ExecuteAction() override;
259   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
260                                                  StringRef) override {
261     return nullptr;
262   }
263 
264   bool usesPreprocessorOnly() const override { return true; }
265 };
266 
267 //===----------------------------------------------------------------------===//
268 // Preprocessor Actions
269 //===----------------------------------------------------------------------===//
270 
271 class DumpRawTokensAction : public PreprocessorFrontendAction {
272 protected:
273   void ExecuteAction() override;
274 };
275 
276 class DumpTokensAction : public PreprocessorFrontendAction {
277 protected:
278   void ExecuteAction() override;
279 };
280 
281 class PreprocessOnlyAction : public PreprocessorFrontendAction {
282 protected:
283   void ExecuteAction() override;
284 };
285 
286 class PrintPreprocessedAction : public PreprocessorFrontendAction {
287 protected:
288   void ExecuteAction() override;
289 
290   bool hasPCHSupport() const override { return true; }
291 };
292 
293 }  // end namespace clang
294 
295 #endif
296