Coverage Report

Created: 2020-02-15 09:57

/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
4.61k
  TranslationUnitKind getTranslationUnitKind() override {
83
4.61k
    return TU_Prefix;
84
4.61k
  }
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
122
class GenerateInterfaceStubAction : public ASTFrontendAction {
123
protected:
124
130
  TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
125
126
0
  bool hasASTFileSupport() const override { return false; }
127
};
128
129
class GenerateInterfaceIfsExpV1Action : public GenerateInterfaceStubAction {
130
protected:
131
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
132
                                                 StringRef InFile) override;
133
};
134
135
class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
136
private:
137
  bool BeginSourceFileAction(CompilerInstance &CI) override;
138
139
  std::unique_ptr<raw_pwrite_stream>
140
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
141
};
142
143
class GenerateModuleInterfaceAction : public GenerateModuleAction {
144
private:
145
  bool BeginSourceFileAction(CompilerInstance &CI) override;
146
147
  std::unique_ptr<raw_pwrite_stream>
148
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
149
};
150
151
class GenerateHeaderModuleAction : public GenerateModuleAction {
152
  /// The synthesized module input buffer for the current compilation.
153
  std::unique_ptr<llvm::MemoryBuffer> Buffer;
154
  std::vector<std::string> ModuleHeaders;
155
156
private:
157
  bool PrepareToExecuteAction(CompilerInstance &CI) override;
158
  bool BeginSourceFileAction(CompilerInstance &CI) override;
159
160
  std::unique_ptr<raw_pwrite_stream>
161
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
162
};
163
164
class SyntaxOnlyAction : public ASTFrontendAction {
165
protected:
166
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
167
                                                 StringRef InFile) override;
168
169
public:
170
  ~SyntaxOnlyAction() override;
171
10.4k
  bool hasCodeCompletionSupport() const override { return true; }
172
};
173
174
/// Dump information about the given module file, to be used for
175
/// basic debugging and discovery.
176
class DumpModuleInfoAction : public ASTFrontendAction {
177
protected:
178
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
179
                                                 StringRef InFile) override;
180
  bool BeginInvocation(CompilerInstance &CI) override;
181
  void ExecuteAction() override;
182
183
public:
184
0
  bool hasPCHSupport() const override { return false; }
185
5
  bool hasASTFileSupport() const override { return true; }
186
0
  bool hasIRSupport() const override { return false; }
187
0
  bool hasCodeCompletionSupport() const override { return false; }
188
};
189
190
class VerifyPCHAction : public ASTFrontendAction {
191
protected:
192
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
193
                                                 StringRef InFile) override;
194
195
  void ExecuteAction() override;
196
197
public:
198
0
  bool hasCodeCompletionSupport() const override { return false; }
199
};
200
201
class TemplightDumpAction : public ASTFrontendAction {
202
protected:
203
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
204
                                                 StringRef InFile) override;
205
206
  void ExecuteAction() override;
207
};
208
209
/**
210
 * Frontend action adaptor that merges ASTs together.
211
 *
212
 * This action takes an existing AST file and "merges" it into the AST
213
 * context, producing a merged context. This action is an action
214
 * adaptor, which forwards most of its calls to another action that
215
 * will consume the merged context.
216
 */
217
class ASTMergeAction : public FrontendAction {
218
  /// The action that the merge action adapts.
219
  std::unique_ptr<FrontendAction> AdaptedAction;
220
221
  /// The set of AST files to merge.
222
  std::vector<std::string> ASTFiles;
223
224
protected:
225
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
226
                                                 StringRef InFile) override;
227
228
  bool BeginSourceFileAction(CompilerInstance &CI) override;
229
230
  void ExecuteAction() override;
231
  void EndSourceFileAction() override;
232
233
public:
234
  ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
235
                 ArrayRef<std::string> ASTFiles);
236
  ~ASTMergeAction() override;
237
238
  bool usesPreprocessorOnly() const override;
239
  TranslationUnitKind getTranslationUnitKind() override;
240
  bool hasPCHSupport() const override;
241
  bool hasASTFileSupport() const override;
242
  bool hasCodeCompletionSupport() const override;
243
};
244
245
class PrintPreambleAction : public FrontendAction {
246
protected:
247
  void ExecuteAction() override;
248
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
249
0
                                                 StringRef) override {
250
0
    return nullptr;
251
0
  }
252
253
2
  bool usesPreprocessorOnly() const override { return true; }
254
};
255
256
class PrintDependencyDirectivesSourceMinimizerAction : public FrontendAction {
257
protected:
258
  void ExecuteAction() override;
259
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
260
0
                                                 StringRef) override {
261
0
    return nullptr;
262
0
  }
263
264
7
  bool usesPreprocessorOnly() const override { return true; }
265
};
266
267
//===----------------------------------------------------------------------===//
268
// Preprocessor Actions
269
//===----------------------------------------------------------------------===//
270
271
class DumpRawTokensAction : public PreprocessorFrontendAction {
272
protected:
273
  void ExecuteAction() override;
274
};
275
276
class DumpTokensAction : public PreprocessorFrontendAction {
277
protected:
278
  void ExecuteAction() override;
279
};
280
281
class PreprocessOnlyAction : public PreprocessorFrontendAction {
282
protected:
283
  void ExecuteAction() override;
284
};
285
286
class PrintPreprocessedAction : public PreprocessorFrontendAction {
287
protected:
288
  void ExecuteAction() override;
289
290
0
  bool hasPCHSupport() const override { return true; }
291
};
292
293
}  // end namespace clang
294
295
#endif