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