Coverage Report

Created: 2021-01-23 06:44

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Frontend/FrontendActions.h
Line
Count
Source (jump to first uncovered line)
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
12
#include "clang/Frontend/FrontendAction.h"
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
25
class InitOnlyAction : public FrontendAction {
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
0
  bool usesPreprocessorOnly() const override { return false; }
35
};
36
37
class DumpCompilerOptionsAction : public FrontendAction {
38
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
39
0
                                                 StringRef InFile) override {
40
0
    return nullptr;
41
0
  }
42
43
  void ExecuteAction() override;
44
45
public:
46
3
  bool usesPreprocessorOnly() const override { return true; }
47
};
48
49
//===----------------------------------------------------------------------===//
50
// AST Consumer Actions
51
//===----------------------------------------------------------------------===//
52
53
class ASTPrintAction : public ASTFrontendAction {
54
protected:
55
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
56
                                                 StringRef InFile) override;
57
};
58
59
class ASTDumpAction : public ASTFrontendAction {
60
protected:
61
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
62
                                                 StringRef InFile) override;
63
};
64
65
class ASTDeclListAction : public ASTFrontendAction {
66
protected:
67
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
68
                                                 StringRef InFile) override;
69
};
70
71
class ASTViewAction : public ASTFrontendAction {
72
protected:
73
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
74
                                                 StringRef InFile) override;
75
};
76
77
class GeneratePCHAction : public ASTFrontendAction {
78
protected:
79
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
80
                                                 StringRef InFile) override;
81
82
6.21k
  TranslationUnitKind getTranslationUnitKind() override {
83
6.21k
    return TU_Prefix;
84
6.21k
  }
85
86
0
  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
107
class GenerateModuleAction : public ASTFrontendAction {
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
115
3.77k
  TranslationUnitKind getTranslationUnitKind() override {
116
3.77k
    return TU_Module;
117
3.77k
  }
118
119
0
  bool hasASTFileSupport() const override { return false; }
120
121
  bool shouldEraseOutputFiles() override;
122
};
123
124
class GenerateInterfaceStubsAction : public ASTFrontendAction {
125
protected:
126
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
127
                                                 StringRef InFile) override;
128
129
140
  TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
130
0
  bool hasASTFileSupport() const override { return false; }
131
};
132
133
class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
134
private:
135
  bool BeginSourceFileAction(CompilerInstance &CI) override;
136
137
  std::unique_ptr<raw_pwrite_stream>
138
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
139
};
140
141
class GenerateModuleInterfaceAction : public GenerateModuleAction {
142
private:
143
  bool BeginSourceFileAction(CompilerInstance &CI) override;
144
145
  std::unique_ptr<raw_pwrite_stream>
146
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
147
};
148
149
class GenerateHeaderModuleAction : public GenerateModuleAction {
150
  /// The synthesized module input buffer for the current compilation.
151
  std::unique_ptr<llvm::MemoryBuffer> Buffer;
152
  std::vector<std::string> ModuleHeaders;
153
154
private:
155
  bool PrepareToExecuteAction(CompilerInstance &CI) override;
156
  bool BeginSourceFileAction(CompilerInstance &CI) override;
157
158
  std::unique_ptr<raw_pwrite_stream>
159
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
160
};
161
162
class SyntaxOnlyAction : public ASTFrontendAction {
163
protected:
164
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
165
                                                 StringRef InFile) override;
166
167
public:
168
  ~SyntaxOnlyAction() override;
169
11.9k
  bool hasCodeCompletionSupport() const override { return true; }
170
};
171
172
/// Dump information about the given module file, to be used for
173
/// basic debugging and discovery.
174
class DumpModuleInfoAction : public ASTFrontendAction {
175
protected:
176
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
177
                                                 StringRef InFile) override;
178
  bool BeginInvocation(CompilerInstance &CI) override;
179
  void ExecuteAction() override;
180
181
public:
182
0
  bool hasPCHSupport() const override { return false; }
183
5
  bool hasASTFileSupport() const override { return true; }
184
0
  bool hasIRSupport() const override { return false; }
185
0
  bool hasCodeCompletionSupport() const override { return false; }
186
};
187
188
class VerifyPCHAction : public ASTFrontendAction {
189
protected:
190
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
191
                                                 StringRef InFile) override;
192
193
  void ExecuteAction() override;
194
195
public:
196
0
  bool hasCodeCompletionSupport() const override { return false; }
197
};
198
199
class TemplightDumpAction : public ASTFrontendAction {
200
protected:
201
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
202
                                                 StringRef InFile) override;
203
204
  void ExecuteAction() override;
205
};
206
207
/**
208
 * Frontend action adaptor that merges ASTs together.
209
 *
210
 * This action takes an existing AST file and "merges" it into the AST
211
 * context, producing a merged context. This action is an action
212
 * adaptor, which forwards most of its calls to another action that
213
 * will consume the merged context.
214
 */
215
class ASTMergeAction : public FrontendAction {
216
  /// The action that the merge action adapts.
217
  std::unique_ptr<FrontendAction> AdaptedAction;
218
219
  /// The set of AST files to merge.
220
  std::vector<std::string> ASTFiles;
221
222
protected:
223
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
224
                                                 StringRef InFile) override;
225
226
  bool BeginSourceFileAction(CompilerInstance &CI) override;
227
228
  void ExecuteAction() override;
229
  void EndSourceFileAction() override;
230
231
public:
232
  ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
233
                 ArrayRef<std::string> ASTFiles);
234
  ~ASTMergeAction() override;
235
236
  bool usesPreprocessorOnly() const override;
237
  TranslationUnitKind getTranslationUnitKind() override;
238
  bool hasPCHSupport() const override;
239
  bool hasASTFileSupport() const override;
240
  bool hasCodeCompletionSupport() const override;
241
};
242
243
class PrintPreambleAction : public FrontendAction {
244
protected:
245
  void ExecuteAction() override;
246
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
247
0
                                                 StringRef) override {
248
0
    return nullptr;
249
0
  }
250
251
2
  bool usesPreprocessorOnly() const override { return true; }
252
};
253
254
class PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
255
protected:
256
  void ExecuteAction() override;
257
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
258
0
                                                 StringRef) override {
259
0
    return nullptr;
260
0
  }
261
262
7
  bool usesPreprocessorOnly() const override { return true; }
263
};
264
265
//===----------------------------------------------------------------------===//
266
// Preprocessor Actions
267
//===----------------------------------------------------------------------===//
268
269
class DumpRawTokensAction : public PreprocessorFrontendAction {
270
protected:
271
  void ExecuteAction() override;
272
};
273
274
class DumpTokensAction : public PreprocessorFrontendAction {
275
protected:
276
  void ExecuteAction() override;
277
};
278
279
class PreprocessOnlyAction : public PreprocessorFrontendAction {
280
protected:
281
  void ExecuteAction() override;
282
};
283
284
class PrintPreprocessedAction : public PreprocessorFrontendAction {
285
protected:
286
  void ExecuteAction() override;
287
288
0
  bool hasPCHSupport() const override { return true; }
289
};
290
291
}  // end namespace clang
292
293
#endif