clang  11.0.0git
FrontendActions.h
Go to the documentation of this file.
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 
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 
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 
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 
54 protected:
55  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
56  StringRef InFile) override;
57 };
58 
60 protected:
61  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
62  StringRef InFile) override;
63 };
64 
66 protected:
67  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
68  StringRef InFile) override;
69 };
70 
72 protected:
73  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
74  StringRef InFile) override;
75 };
76 
78 protected:
79  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
80  StringRef InFile) override;
81 
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 
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 
116  return TU_Module;
117  }
118 
119  bool hasASTFileSupport() const override { return false; }
120 };
121 
123 protected:
124  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
125  StringRef InFile) override;
126 
128  bool hasASTFileSupport() const override { return false; }
129 };
130 
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 
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 
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 
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.
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 
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 
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  */
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;
236  bool hasPCHSupport() const override;
237  bool hasASTFileSupport() const override;
238  bool hasCodeCompletionSupport() const override;
239 };
240 
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 
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 
268 protected:
269  void ExecuteAction() override;
270 };
271 
273 protected:
274  void ExecuteAction() override;
275 };
276 
278 protected:
279  void ExecuteAction() override;
280 };
281 
283 protected:
284  void ExecuteAction() override;
285 
286  bool hasPCHSupport() const override { return true; }
287 };
288 
289 } // end namespace clang
290 
291 #endif
bool hasASTFileSupport() const override
Does this action support use with AST files?
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &, StringRef) override
Create the AST consumer object for this action, if supported.
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we&#39;re handling.
Dump information about the given module file, to be used for basic debugging and discovery.
Abstract base class for actions which can be performed by the frontend.
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:547
virtual bool hasASTFileSupport() const
Does this action support use with AST files?
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we&#39;re handling.
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
bool hasPCHSupport() const override
Does this action support use with PCH?
friend class ASTMergeAction
bool hasIRSupport() const override
Does this action support use with IR files?
bool hasPCHSupport() const override
Does this action support use with PCH?
virtual bool BeginInvocation(CompilerInstance &CI)
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &, StringRef) override
Create the AST consumer object for this action, if supported.
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
bool hasASTFileSupport() const override
Does this action support use with AST files?
bool hasASTFileSupport() const override
Does this action support use with AST files?
virtual void EndSourceFileAction()
Callback at the end of processing a single input.
virtual bool hasPCHSupport() const
Does this action support use with PCH?
Frontend action adaptor that merges ASTs together.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we&#39;re handling.
bool hasASTFileSupport() const override
Does this action support use with AST files?
Abstract base class to use for AST consumer-based frontend actions.
virtual bool PrepareToExecuteAction(CompilerInstance &CI)
Prepare to execute the action on the given CompilerInstance.
Abstract base class to use for preprocessor-based frontend actions.
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we&#39;re handling.
Dataflow Directional Tag Classes.
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
virtual bool BeginSourceFileAction(CompilerInstance &CI)
Callback at the start of processing a single input.
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:541
bool usesPreprocessorOnly() const override
Does this action only use the preprocessor?
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
Defines the clang::FrontendAction interface and various convenience abstract classes (clang::ASTFront...
The translation unit is a module.
Definition: LangOptions.h:550