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