Coverage Report

Created: 2022-07-16 07:03

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