Coverage Report

Created: 2019-02-23 12:57

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Frontend/FrontendOptions.h
Line
Count
Source (jump to first uncovered line)
1
//===- FrontendOptions.h ----------------------------------------*- 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_FRONTENDOPTIONS_H
10
#define LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
11
12
#include "clang/Frontend/CommandLineSourceLoc.h"
13
#include "clang/Serialization/ModuleFileExtension.h"
14
#include "clang/Sema/CodeCompleteOptions.h"
15
#include "llvm/ADT/StringRef.h"
16
#include <cassert>
17
#include <memory>
18
#include <string>
19
#include <vector>
20
#include <unordered_map>
21
22
namespace llvm {
23
24
class MemoryBuffer;
25
26
} // namespace llvm
27
28
namespace clang {
29
30
namespace frontend {
31
32
enum ActionKind {
33
  /// Parse ASTs and list Decl nodes.
34
  ASTDeclList,
35
36
  /// Parse ASTs and dump them.
37
  ASTDump,
38
39
  /// Parse ASTs and print them.
40
  ASTPrint,
41
42
  /// Parse ASTs and view them in Graphviz.
43
  ASTView,
44
45
  /// Dump the compiler configuration.
46
  DumpCompilerOptions,
47
48
  /// Dump out raw tokens.
49
  DumpRawTokens,
50
51
  /// Dump out preprocessed tokens.
52
  DumpTokens,
53
54
  /// Emit a .s file.
55
  EmitAssembly,
56
57
  /// Emit a .bc file.
58
  EmitBC,
59
60
  /// Translate input source into HTML.
61
  EmitHTML,
62
63
  /// Emit a .ll file.
64
  EmitLLVM,
65
66
  /// Generate LLVM IR, but do not emit anything.
67
  EmitLLVMOnly,
68
69
  /// Generate machine code, but don't emit anything.
70
  EmitCodeGenOnly,
71
72
  /// Emit a .o file.
73
  EmitObj,
74
75
  /// Parse and apply any fixits to the source.
76
  FixIt,
77
78
  /// Generate pre-compiled module from a module map.
79
  GenerateModule,
80
81
  /// Generate pre-compiled module from a C++ module interface file.
82
  GenerateModuleInterface,
83
84
  /// Generate pre-compiled module from a set of header files.
85
  GenerateHeaderModule,
86
87
  /// Generate pre-compiled header.
88
  GeneratePCH,
89
90
  /// Only execute frontend initialization.
91
  InitOnly,
92
93
  /// Dump information about a module file.
94
  ModuleFileInfo,
95
96
  /// Load and verify that a PCH file is usable.
97
  VerifyPCH,
98
99
  /// Parse and perform semantic analysis.
100
  ParseSyntaxOnly,
101
102
  /// Run a plugin action, \see ActionName.
103
  PluginAction,
104
105
  /// Print the "preamble" of the input file
106
  PrintPreamble,
107
108
  /// -E mode.
109
  PrintPreprocessedInput,
110
111
  /// Expand macros but not \#includes.
112
  RewriteMacros,
113
114
  /// ObjC->C Rewriter.
115
  RewriteObjC,
116
117
  /// Rewriter playground
118
  RewriteTest,
119
120
  /// Run one or more source code analyses.
121
  RunAnalysis,
122
123
  /// Dump template instantiations
124
  TemplightDump,
125
126
  /// Run migrator.
127
  MigrateSource,
128
129
  /// Just lex, no output.
130
  RunPreprocessorOnly
131
};
132
133
} // namespace frontend
134
135
/// The kind of a file that we've been handed as an input.
136
class InputKind {
137
private:
138
  unsigned Lang : 4;
139
  unsigned Fmt : 3;
140
  unsigned Preprocessed : 1;
141
142
public:
143
  /// The language for the input, used to select and validate the language
144
  /// standard and possible actions.
145
  enum Language {
146
    Unknown,
147
148
    /// Assembly: we accept this only so that we can preprocess it.
149
    Asm,
150
151
    /// LLVM IR: we accept this so that we can run the optimizer on it,
152
    /// and compile it to assembly or object code.
153
    LLVM_IR,
154
155
    ///@{ Languages that the frontend can parse and compile.
156
    C,
157
    CXX,
158
    ObjC,
159
    ObjCXX,
160
    OpenCL,
161
    CUDA,
162
    RenderScript,
163
    HIP,
164
    ///@}
165
  };
166
167
  /// The input file format.
168
  enum Format {
169
    Source,
170
    ModuleMap,
171
    Precompiled
172
  };
173
174
  constexpr InputKind(Language L = Unknown, Format F = Source,
175
                      bool PP = false)
176
842k
      : Lang(L), Fmt(F), Preprocessed(PP) {}
177
178
496k
  Language getLanguage() const { return static_cast<Language>(Lang); }
179
334k
  Format getFormat() const { return static_cast<Format>(Fmt); }
180
69.3k
  bool isPreprocessed() const { return Preprocessed; }
181
182
  /// Is the input kind fully-unknown?
183
141k
  bool isUnknown() const { return Lang == Unknown && 
Fmt == Source25.8k
; }
184
185
  /// Is the language of the input some dialect of Objective-C?
186
38.0k
  bool isObjectiveC() const { return Lang == ObjC || 
Lang == ObjCXX35.4k
; }
187
188
110k
  InputKind getPreprocessed() const {
189
110k
    return InputKind(getLanguage(), getFormat(), true);
190
110k
  }
191
192
202
  InputKind withFormat(Format F) const {
193
202
    return InputKind(getLanguage(), F, isPreprocessed());
194
202
  }
195
};
196
197
/// An input file for the front end.
198
class FrontendInputFile {
199
  /// The file name, or "-" to read from standard input.
200
  std::string File;
201
202
  /// The input, if it comes from a buffer rather than a file. This object
203
  /// does not own the buffer, and the caller is responsible for ensuring
204
  /// that it outlives any users.
205
  llvm::MemoryBuffer *Buffer = nullptr;
206
207
  /// The kind of input, e.g., C source, AST file, LLVM IR.
208
  InputKind Kind;
209
210
  /// Whether we're dealing with a 'system' input (vs. a 'user' input).
211
  bool IsSystem = false;
212
213
public:
214
95.3k
  FrontendInputFile() = default;
215
  FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
216
44.4k
      : File(File.str()), Kind(Kind), IsSystem(IsSystem) {}
217
  FrontendInputFile(llvm::MemoryBuffer *Buffer, InputKind Kind,
218
                    bool IsSystem = false)
219
4
      : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
220
221
247k
  InputKind getKind() const { return Kind; }
222
47.1k
  bool isSystem() const { return IsSystem; }
223
224
0
  bool isEmpty() const { return File.empty() && Buffer == nullptr; }
225
46.1k
  bool isFile() const { return !isBuffer(); }
226
91.8k
  bool isBuffer() const { return Buffer != nullptr; }
227
40.4k
  bool isPreprocessed() const { return Kind.isPreprocessed(); }
228
229
103k
  StringRef getFile() const {
230
103k
    assert(isFile());
231
103k
    return File;
232
103k
  }
233
234
8
  llvm::MemoryBuffer *getBuffer() const {
235
8
    assert(isBuffer());
236
8
    return Buffer;
237
8
  }
238
};
239
240
/// FrontendOptions - Options for controlling the behavior of the frontend.
241
class FrontendOptions {
242
public:
243
  /// Disable memory freeing on exit.
244
  unsigned DisableFree : 1;
245
246
  /// When generating PCH files, instruct the AST writer to create relocatable
247
  /// PCH files.
248
  unsigned RelocatablePCH : 1;
249
250
  /// Show the -help text.
251
  unsigned ShowHelp : 1;
252
253
  /// Show frontend performance metrics and statistics.
254
  unsigned ShowStats : 1;
255
256
  /// Show timers for individual actions.
257
  unsigned ShowTimers : 1;
258
259
  /// Show the -version text.
260
  unsigned ShowVersion : 1;
261
262
  /// Apply fixes even if there are unfixable errors.
263
  unsigned FixWhatYouCan : 1;
264
265
  /// Apply fixes only for warnings.
266
  unsigned FixOnlyWarnings : 1;
267
268
  /// Apply fixes and recompile.
269
  unsigned FixAndRecompile : 1;
270
271
  /// Apply fixes to temporary files.
272
  unsigned FixToTemporaries : 1;
273
274
  /// Emit ARC errors even if the migrator can fix them.
275
  unsigned ARCMTMigrateEmitARCErrors : 1;
276
277
  /// Skip over function bodies to speed up parsing in cases you do not need
278
  /// them (e.g. with code completion).
279
  unsigned SkipFunctionBodies : 1;
280
281
  /// Whether we can use the global module index if available.
282
  unsigned UseGlobalModuleIndex : 1;
283
284
  /// Whether we can generate the global module index if needed.
285
  unsigned GenerateGlobalModuleIndex : 1;
286
287
  /// Whether we include declaration dumps in AST dumps.
288
  unsigned ASTDumpDecls : 1;
289
290
  /// Whether we deserialize all decls when forming AST dumps.
291
  unsigned ASTDumpAll : 1;
292
293
  /// Whether we include lookup table dumps in AST dumps.
294
  unsigned ASTDumpLookups : 1;
295
296
  /// Whether we are performing an implicit module build.
297
  unsigned BuildingImplicitModule : 1;
298
299
  /// Whether we should embed all used files into the PCM file.
300
  unsigned ModulesEmbedAllFiles : 1;
301
302
  /// Whether timestamps should be written to the produced PCH file.
303
  unsigned IncludeTimestamps : 1;
304
305
  CodeCompleteOptions CodeCompleteOpts;
306
307
  enum {
308
    ARCMT_None,
309
    ARCMT_Check,
310
    ARCMT_Modify,
311
    ARCMT_Migrate
312
  } ARCMTAction = ARCMT_None;
313
314
  enum {
315
    ObjCMT_None = 0,
316
317
    /// Enable migration to modern ObjC literals.
318
    ObjCMT_Literals = 0x1,
319
320
    /// Enable migration to modern ObjC subscripting.
321
    ObjCMT_Subscripting = 0x2,
322
323
    /// Enable migration to modern ObjC readonly property.
324
    ObjCMT_ReadonlyProperty = 0x4,
325
326
    /// Enable migration to modern ObjC readwrite property.
327
    ObjCMT_ReadwriteProperty = 0x8,
328
329
    /// Enable migration to modern ObjC property.
330
    ObjCMT_Property = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty),
331
332
    /// Enable annotation of ObjCMethods of all kinds.
333
    ObjCMT_Annotation = 0x10,
334
335
    /// Enable migration of ObjC methods to 'instancetype'.
336
    ObjCMT_Instancetype = 0x20,
337
338
    /// Enable migration to NS_ENUM/NS_OPTIONS macros.
339
    ObjCMT_NsMacros = 0x40,
340
341
    /// Enable migration to add conforming protocols.
342
    ObjCMT_ProtocolConformance = 0x80,
343
344
    /// prefer 'atomic' property over 'nonatomic'.
345
    ObjCMT_AtomicProperty = 0x100,
346
347
    /// annotate property with NS_RETURNS_INNER_POINTER
348
    ObjCMT_ReturnsInnerPointerProperty = 0x200,
349
350
    /// use NS_NONATOMIC_IOSONLY for property 'atomic' attribute
351
    ObjCMT_NsAtomicIOSOnlyProperty = 0x400,
352
353
    /// Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
354
    ObjCMT_DesignatedInitializer = 0x800,
355
356
    /// Enable converting setter/getter expressions to property-dot syntx.
357
    ObjCMT_PropertyDotSyntax = 0x1000,
358
359
    ObjCMT_MigrateDecls = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty |
360
                           ObjCMT_Annotation | ObjCMT_Instancetype |
361
                           ObjCMT_NsMacros | ObjCMT_ProtocolConformance |
362
                           ObjCMT_NsAtomicIOSOnlyProperty |
363
                           ObjCMT_DesignatedInitializer),
364
    ObjCMT_MigrateAll = (ObjCMT_Literals | ObjCMT_Subscripting |
365
                         ObjCMT_MigrateDecls | ObjCMT_PropertyDotSyntax)
366
  };
367
  unsigned ObjCMTAction = ObjCMT_None;
368
  std::string ObjCMTWhiteListPath;
369
370
  std::string MTMigrateDir;
371
  std::string ARCMTMigrateReportOut;
372
373
  /// The input files and their types.
374
  std::vector<FrontendInputFile> Inputs;
375
376
  /// When the input is a module map, the original module map file from which
377
  /// that map was inferred, if any (for umbrella modules).
378
  std::string OriginalModuleMap;
379
380
  /// The output file, if any.
381
  std::string OutputFile;
382
383
  /// If given, the new suffix for fix-it rewritten files.
384
  std::string FixItSuffix;
385
386
  /// If given, filter dumped AST Decl nodes by this substring.
387
  std::string ASTDumpFilter;
388
389
  /// If given, enable code completion at the provided location.
390
  ParsedSourceLocation CodeCompletionAt;
391
392
  /// The frontend action to perform.
393
  frontend::ActionKind ProgramAction = frontend::ParseSyntaxOnly;
394
395
  /// The name of the action to run when using a plugin action.
396
  std::string ActionName;
397
398
  /// Args to pass to the plugins
399
  std::unordered_map<std::string,std::vector<std::string>> PluginArgs;
400
401
  /// The list of plugin actions to run in addition to the normal action.
402
  std::vector<std::string> AddPluginActions;
403
404
  /// The list of plugins to load.
405
  std::vector<std::string> Plugins;
406
407
  /// The list of module file extensions.
408
  std::vector<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions;
409
410
  /// The list of module map files to load before processing the input.
411
  std::vector<std::string> ModuleMapFiles;
412
413
  /// The list of additional prebuilt module files to load before
414
  /// processing the input.
415
  std::vector<std::string> ModuleFiles;
416
417
  /// The list of files to embed into the compiled module file.
418
  std::vector<std::string> ModulesEmbedFiles;
419
420
  /// The list of AST files to merge.
421
  std::vector<std::string> ASTMergeFiles;
422
423
  /// A list of arguments to forward to LLVM's option processing; this
424
  /// should only be used for debugging and experimental features.
425
  std::vector<std::string> LLVMArgs;
426
427
  /// File name of the file that will provide record layouts
428
  /// (in the format produced by -fdump-record-layouts).
429
  std::string OverrideRecordLayoutsFile;
430
431
  /// Auxiliary triple for CUDA compilation.
432
  std::string AuxTriple;
433
434
  /// Filename to write statistics to.
435
  std::string StatsFile;
436
437
public:
438
  FrontendOptions()
439
      : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
440
        ShowStats(false), ShowTimers(false), ShowVersion(false),
441
        FixWhatYouCan(false), FixOnlyWarnings(false), FixAndRecompile(false),
442
        FixToTemporaries(false), ARCMTMigrateEmitARCErrors(false),
443
        SkipFunctionBodies(false), UseGlobalModuleIndex(true),
444
        GenerateGlobalModuleIndex(true), ASTDumpDecls(false),
445
        ASTDumpLookups(false), BuildingImplicitModule(false),
446
53.1k
        ModulesEmbedAllFiles(false), IncludeTimestamps(true) {}
447
448
  /// getInputKindForExtension - Return the appropriate input kind for a file
449
  /// extension. For example, "c" would return InputKind::C.
450
  ///
451
  /// \return The input kind for the extension, or InputKind::Unknown if the
452
  /// extension is not recognized.
453
  static InputKind getInputKindForExtension(StringRef Extension);
454
};
455
456
} // namespace clang
457
458
#endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H