Coverage Report

Created: 2018-09-25 23:22

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Frontend/FrontendActions.h
Line
Count
Source (jump to first uncovered line)
1
//===-- FrontendActions.h - Useful Frontend Actions -------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
10
#ifndef LLVM_CLANG_FRONTEND_FRONTENDACTIONS_H
11
#define LLVM_CLANG_FRONTEND_FRONTENDACTIONS_H
12
13
#include "clang/Frontend/FrontendAction.h"
14
#include <string>
15
#include <vector>
16
17
namespace clang {
18
19
class Module;
20
class FileEntry;
21
22
//===----------------------------------------------------------------------===//
23
// Custom Consumer Actions
24
//===----------------------------------------------------------------------===//
25
26
class InitOnlyAction : public FrontendAction {
27
  void ExecuteAction() override;
28
29
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
30
                                                 StringRef InFile) override;
31
32
public:
33
  // Don't claim to only use the preprocessor, we want to follow the AST path,
34
  // but do nothing.
35
0
  bool usesPreprocessorOnly() const override { return false; }
36
};
37
38
class DumpCompilerOptionsAction : public FrontendAction {
39
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
40
0
                                                 StringRef InFile) override {
41
0
    return nullptr;
42
0
  }
43
44
  void ExecuteAction() override;
45
46
public:
47
3
  bool usesPreprocessorOnly() const override { return true; }
48
};
49
50
//===----------------------------------------------------------------------===//
51
// AST Consumer Actions
52
//===----------------------------------------------------------------------===//
53
54
class ASTPrintAction : public ASTFrontendAction {
55
protected:
56
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
57
                                                 StringRef InFile) override;
58
};
59
60
class ASTDumpAction : public ASTFrontendAction {
61
protected:
62
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
63
                                                 StringRef InFile) override;
64
};
65
66
class ASTDeclListAction : public ASTFrontendAction {
67
protected:
68
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
69
                                                 StringRef InFile) override;
70
};
71
72
class ASTViewAction : public ASTFrontendAction {
73
protected:
74
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
75
                                                 StringRef InFile) override;
76
};
77
78
class DeclContextPrintAction : public ASTFrontendAction {
79
protected:
80
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
81
                                                 StringRef InFile) override;
82
};
83
84
class GeneratePCHAction : public ASTFrontendAction {
85
protected:
86
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
87
                                                 StringRef InFile) override;
88
89
3.78k
  TranslationUnitKind getTranslationUnitKind() override {
90
3.78k
    return TU_Prefix;
91
3.78k
  }
92
93
0
  bool hasASTFileSupport() const override { return false; }
94
95
  bool shouldEraseOutputFiles() override;
96
97
public:
98
  /// Compute the AST consumer arguments that will be used to
99
  /// create the PCHGenerator instance returned by CreateASTConsumer.
100
  ///
101
  /// \returns false if an error occurred, true otherwise.
102
  static bool ComputeASTConsumerArguments(CompilerInstance &CI,
103
                                          std::string &Sysroot);
104
105
  /// Creates file to write the PCH into and returns a stream to write it
106
  /// into. On error, returns null.
107
  static std::unique_ptr<llvm::raw_pwrite_stream>
108
  CreateOutputFile(CompilerInstance &CI, StringRef InFile,
109
                   std::string &OutputFile);
110
111
  bool BeginSourceFileAction(CompilerInstance &CI) override;
112
};
113
114
class GenerateModuleAction : public ASTFrontendAction {
115
  virtual std::unique_ptr<raw_pwrite_stream>
116
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) = 0;
117
118
protected:
119
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
120
                                                 StringRef InFile) override;
121
122
2.90k
  TranslationUnitKind getTranslationUnitKind() override {
123
2.90k
    return TU_Module;
124
2.90k
  }
125
126
0
  bool hasASTFileSupport() const override { return false; }
127
};
128
129
class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
130
private:
131
  bool BeginSourceFileAction(CompilerInstance &CI) override;
132
133
  std::unique_ptr<raw_pwrite_stream>
134
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
135
};
136
137
class GenerateModuleInterfaceAction : public GenerateModuleAction {
138
private:
139
  bool BeginSourceFileAction(CompilerInstance &CI) override;
140
141
  std::unique_ptr<raw_pwrite_stream>
142
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
143
};
144
145
class GenerateHeaderModuleAction : public GenerateModuleAction {
146
  /// The synthesized module input buffer for the current compilation.
147
  std::unique_ptr<llvm::MemoryBuffer> Buffer;
148
  std::vector<std::string> ModuleHeaders;
149
150
private:
151
  bool PrepareToExecuteAction(CompilerInstance &CI) override;
152
  bool BeginSourceFileAction(CompilerInstance &CI) override;
153
154
  std::unique_ptr<raw_pwrite_stream>
155
  CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
156
};
157
158
class SyntaxOnlyAction : public ASTFrontendAction {
159
protected:
160
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
161
                                                 StringRef InFile) override;
162
163
public:
164
  ~SyntaxOnlyAction() override;
165
8.97k
  bool hasCodeCompletionSupport() const override { return true; }
166
};
167
168
/// Dump information about the given module file, to be used for
169
/// basic debugging and discovery.
170
class DumpModuleInfoAction : public ASTFrontendAction {
171
protected:
172
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
173
                                                 StringRef InFile) override;
174
  bool BeginInvocation(CompilerInstance &CI) override;
175
  void ExecuteAction() override;
176
177
public:
178
0
  bool hasPCHSupport() const override { return false; }
179
0
  bool hasASTFileSupport() const override { return true; }
180
0
  bool hasIRSupport() const override { return false; }
181
0
  bool hasCodeCompletionSupport() const override { return false; }
182
};
183
184
class VerifyPCHAction : public ASTFrontendAction {
185
protected:
186
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
187
                                                 StringRef InFile) override;
188
189
  void ExecuteAction() override;
190
191
public:
192
0
  bool hasCodeCompletionSupport() const override { return false; }
193
};
194
195
class TemplightDumpAction : public ASTFrontendAction {
196
protected:
197
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
198
                                                 StringRef InFile) override;
199
200
  void ExecuteAction() override;
201
};
202
203
/**
204
 * Frontend action adaptor that merges ASTs together.
205
 *
206
 * This action takes an existing AST file and "merges" it into the AST
207
 * context, producing a merged context. This action is an action
208
 * adaptor, which forwards most of its calls to another action that
209
 * will consume the merged context.
210
 */
211
class ASTMergeAction : public FrontendAction {
212
  /// The action that the merge action adapts.
213
  std::unique_ptr<FrontendAction> AdaptedAction;
214
215
  /// The set of AST files to merge.
216
  std::vector<std::string> ASTFiles;
217
218
protected:
219
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
220
                                                 StringRef InFile) override;
221
222
  bool BeginSourceFileAction(CompilerInstance &CI) override;
223
224
  void ExecuteAction() override;
225
  void EndSourceFileAction() override;
226
227
public:
228
  ASTMergeAction(std::unique_ptr<FrontendAction> AdaptedAction,
229
                 ArrayRef<std::string> ASTFiles);
230
  ~ASTMergeAction() override;
231
232
  bool usesPreprocessorOnly() const override;
233
  TranslationUnitKind getTranslationUnitKind() override;
234
  bool hasPCHSupport() const override;
235
  bool hasASTFileSupport() const override;
236
  bool hasCodeCompletionSupport() const override;
237
};
238
239
class PrintPreambleAction : public FrontendAction {
240
protected:
241
  void ExecuteAction() override;
242
  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
243
0
                                                 StringRef) override {
244
0
    return nullptr;
245
0
  }
246
247
2
  bool usesPreprocessorOnly() const override { return true; }
248
};
249
250
//===----------------------------------------------------------------------===//
251
// Preprocessor Actions
252
//===----------------------------------------------------------------------===//
253
254
class DumpRawTokensAction : public PreprocessorFrontendAction {
255
protected:
256
  void ExecuteAction() override;
257
};
258
259
class DumpTokensAction : public PreprocessorFrontendAction {
260
protected:
261
  void ExecuteAction() override;
262
};
263
264
class GeneratePTHAction : public PreprocessorFrontendAction {
265
protected:
266
  void ExecuteAction() override;
267
};
268
269
class PreprocessOnlyAction : public PreprocessorFrontendAction {
270
protected:
271
  void ExecuteAction() override;
272
};
273
274
class PrintPreprocessedAction : public PreprocessorFrontendAction {
275
protected:
276
  void ExecuteAction() override;
277
278
0
  bool hasPCHSupport() const override { return true; }
279
};
280
281
}  // end namespace clang
282
283
#endif