clang  9.0.0svn
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:
125 
126  bool hasASTFileSupport() const override { return false; }
127 };
128 
129 // Support different interface stub formats this way:
131 protected:
132  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
133  StringRef InFile) override;
134 };
135 
137 protected:
138  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
139  StringRef InFile) override;
140 };
141 
143 private:
144  bool BeginSourceFileAction(CompilerInstance &CI) override;
145 
146  std::unique_ptr<raw_pwrite_stream>
147  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
148 };
149 
151 private:
152  bool BeginSourceFileAction(CompilerInstance &CI) override;
153 
154  std::unique_ptr<raw_pwrite_stream>
155  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
156 };
157 
159  /// The synthesized module input buffer for the current compilation.
160  std::unique_ptr<llvm::MemoryBuffer> Buffer;
161  std::vector<std::string> ModuleHeaders;
162 
163 private:
164  bool PrepareToExecuteAction(CompilerInstance &CI) override;
165  bool BeginSourceFileAction(CompilerInstance &CI) override;
166 
167  std::unique_ptr<raw_pwrite_stream>
168  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
169 };
170 
172 protected:
173  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
174  StringRef InFile) override;
175 
176 public:
177  ~SyntaxOnlyAction() override;
178  bool hasCodeCompletionSupport() const override { return true; }
179 };
180 
181 /// Dump information about the given module file, to be used for
182 /// basic debugging and discovery.
184 protected:
185  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
186  StringRef InFile) override;
187  bool BeginInvocation(CompilerInstance &CI) override;
188  void ExecuteAction() override;
189 
190 public:
191  bool hasPCHSupport() const override { return false; }
192  bool hasASTFileSupport() const override { return true; }
193  bool hasIRSupport() const override { return false; }
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 public:
205  bool hasCodeCompletionSupport() const override { return false; }
206 };
207 
209 protected:
210  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
211  StringRef InFile) override;
212 
213  void ExecuteAction() override;
214 };
215 
216 /**
217  * Frontend action adaptor that merges ASTs together.
218  *
219  * This action takes an existing AST file and "merges" it into the AST
220  * context, producing a merged context. This action is an action
221  * adaptor, which forwards most of its calls to another action that
222  * will consume the merged context.
223  */
225  /// The action that the merge action adapts.
226  std::unique_ptr<FrontendAction> AdaptedAction;
227 
228  /// The set of AST files to merge.
229  std::vector<std::string> ASTFiles;
230 
231 protected:
232  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
233  StringRef InFile) override;
234 
235  bool BeginSourceFileAction(CompilerInstance &CI) override;
236 
237  void ExecuteAction() override;
238  void EndSourceFileAction() override;
239 
240 public:
241  ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
242  ArrayRef<std::string> ASTFiles);
243  ~ASTMergeAction() override;
244 
245  bool usesPreprocessorOnly() const override;
247  bool hasPCHSupport() const override;
248  bool hasASTFileSupport() const override;
249  bool hasCodeCompletionSupport() const override;
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 
264 protected:
265  void ExecuteAction() override;
266  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
267  StringRef) override {
268  return nullptr;
269  }
270 
271  bool usesPreprocessorOnly() const override { return true; }
272 };
273 
274 //===----------------------------------------------------------------------===//
275 // Preprocessor Actions
276 //===----------------------------------------------------------------------===//
277 
279 protected:
280  void ExecuteAction() override;
281 };
282 
284 protected:
285  void ExecuteAction() override;
286 };
287 
289 protected:
290  void ExecuteAction() override;
291 };
292 
294 protected:
295  void ExecuteAction() override;
296 
297  bool hasPCHSupport() const override { return true; }
298 };
299 
300 } // end namespace clang
301 
302 #endif
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.
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:368
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.
bool hasASTFileSupport() const override
Does this action support use with AST files?
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:362
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...
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we&#39;re handling.
The translation unit is a module.
Definition: LangOptions.h:371