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 private:
124  bool BeginSourceFileAction(CompilerInstance &CI) override;
125 
126  std::unique_ptr<raw_pwrite_stream>
127  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
128 };
129 
131 private:
132  bool BeginSourceFileAction(CompilerInstance &CI) override;
133 
134  std::unique_ptr<raw_pwrite_stream>
135  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
136 };
137 
139  /// The synthesized module input buffer for the current compilation.
140  std::unique_ptr<llvm::MemoryBuffer> Buffer;
141  std::vector<std::string> ModuleHeaders;
142 
143 private:
144  bool PrepareToExecuteAction(CompilerInstance &CI) override;
145  bool BeginSourceFileAction(CompilerInstance &CI) override;
146 
147  std::unique_ptr<raw_pwrite_stream>
148  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
149 };
150 
152 protected:
153  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
154  StringRef InFile) override;
155 
156 public:
157  ~SyntaxOnlyAction() override;
158  bool hasCodeCompletionSupport() const override { return true; }
159 };
160 
161 /// Dump information about the given module file, to be used for
162 /// basic debugging and discovery.
164 protected:
165  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
166  StringRef InFile) override;
167  bool BeginInvocation(CompilerInstance &CI) override;
168  void ExecuteAction() override;
169 
170 public:
171  bool hasPCHSupport() const override { return false; }
172  bool hasASTFileSupport() const override { return true; }
173  bool hasIRSupport() const override { return false; }
174  bool hasCodeCompletionSupport() const override { return false; }
175 };
176 
178 protected:
179  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
180  StringRef InFile) override;
181 
182  void ExecuteAction() override;
183 
184 public:
185  bool hasCodeCompletionSupport() const override { return false; }
186 };
187 
189 protected:
190  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
191  StringRef InFile) override;
192 
193  void ExecuteAction() override;
194 };
195 
196 /**
197  * Frontend action adaptor that merges ASTs together.
198  *
199  * This action takes an existing AST file and "merges" it into the AST
200  * context, producing a merged context. This action is an action
201  * adaptor, which forwards most of its calls to another action that
202  * will consume the merged context.
203  */
205  /// The action that the merge action adapts.
206  std::unique_ptr<FrontendAction> AdaptedAction;
207 
208  /// The set of AST files to merge.
209  std::vector<std::string> ASTFiles;
210 
211 protected:
212  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
213  StringRef InFile) override;
214 
215  bool BeginSourceFileAction(CompilerInstance &CI) override;
216 
217  void ExecuteAction() override;
218  void EndSourceFileAction() override;
219 
220 public:
221  ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
222  ArrayRef<std::string> ASTFiles);
223  ~ASTMergeAction() override;
224 
225  bool usesPreprocessorOnly() const override;
227  bool hasPCHSupport() const override;
228  bool hasASTFileSupport() const override;
229  bool hasCodeCompletionSupport() const override;
230 };
231 
233 protected:
234  void ExecuteAction() override;
235  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
236  StringRef) override {
237  return nullptr;
238  }
239 
240  bool usesPreprocessorOnly() const override { return true; }
241 };
242 
243 //===----------------------------------------------------------------------===//
244 // Preprocessor Actions
245 //===----------------------------------------------------------------------===//
246 
248 protected:
249  void ExecuteAction() override;
250 };
251 
253 protected:
254  void ExecuteAction() override;
255 };
256 
258 protected:
259  void ExecuteAction() override;
260 };
261 
263 protected:
264  void ExecuteAction() override;
265 
266  bool hasPCHSupport() const override { return true; }
267 };
268 
269 } // end namespace clang
270 
271 #endif
bool hasCodeCompletionSupport() const override
Does this action support use with code completion?
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:367
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 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:361
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:370