Coverage Report

Created: 2020-02-25 14:32

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