Coverage Report

Created: 2020-09-22 08:39

/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
5.96k
  TranslationUnitKind getTranslationUnitKind() override {
83
5.96k
    return TU_Prefix;
84
5.96k
  }
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.82k
  TranslationUnitKind getTranslationUnitKind() override {
116
3.82k
    return TU_Module;
117
3.82k
  }
118
119
0
  bool hasASTFileSupport() const override { return false; }
120
};
121
122
class GenerateInterfaceStubsAction : public ASTFrontendAction {
123
protected:
124
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
125
                                                 StringRef InFile) override;
126
127
132
  TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
128
0
  bool hasASTFileSupport() const override { return false; }
129
};
130
131
class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
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
139
class GenerateModuleInterfaceAction : public GenerateModuleAction {
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
147
class GenerateHeaderModuleAction : public GenerateModuleAction {
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
160
class SyntaxOnlyAction : public ASTFrontendAction {
161
protected:
162
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
163
                                                 StringRef InFile) override;
164
165
public:
166
  ~SyntaxOnlyAction() override;
167
11.7k
  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.
172
class DumpModuleInfoAction : public ASTFrontendAction {
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
0
  bool hasPCHSupport() const override { return false; }
181
5
  bool hasASTFileSupport() const override { return true; }
182
0
  bool hasIRSupport() const override { return false; }
183
0
  bool hasCodeCompletionSupport() const override { return false; }
184
};
185
186
class VerifyPCHAction : public ASTFrontendAction {
187
protected:
188
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
189
                                                 StringRef InFile) override;
190
191
  void ExecuteAction() override;
192
193
public:
194
0
  bool hasCodeCompletionSupport() const override { return false; }
195
};
196
197
class TemplightDumpAction : public ASTFrontendAction {
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
 */
213
class ASTMergeAction : public FrontendAction {
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;
235
  TranslationUnitKind getTranslationUnitKind() override;
236
  bool hasPCHSupport() const override;
237
  bool hasASTFileSupport() const override;
238
  bool hasCodeCompletionSupport() const override;
239
};
240
241
class PrintPreambleAction : public FrontendAction {
242
protected:
243
  void ExecuteAction() override;
244
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
245
0
                                                 StringRef) override {
246
0
    return nullptr;
247
0
  }
248
249
2
  bool usesPreprocessorOnly() const override { return true; }
250
};
251
252
class PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
253
protected:
254
  void ExecuteAction() override;
255
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
256
0
                                                 StringRef) override {
257
0
    return nullptr;
258
0
  }
259
260
7
  bool usesPreprocessorOnly() const override { return true; }
261
};
262
263
//===----------------------------------------------------------------------===//
264
// Preprocessor Actions
265
//===----------------------------------------------------------------------===//
266
267
class DumpRawTokensAction : public PreprocessorFrontendAction {
268
protected:
269
  void ExecuteAction() override;
270
};
271
272
class DumpTokensAction : public PreprocessorFrontendAction {
273
protected:
274
  void ExecuteAction() override;
275
};
276
277
class PreprocessOnlyAction : public PreprocessorFrontendAction {
278
protected:
279
  void ExecuteAction() override;
280
};
281
282
class PrintPreprocessedAction : public PreprocessorFrontendAction {
283
protected:
284
  void ExecuteAction() override;
285
286
0
  bool hasPCHSupport() const override { return true; }
287
};
288
289
}  // end namespace clang
290
291
#endif