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