-
Notifications
You must be signed in to change notification settings - Fork 10.4k
/
Copy pathOptions.td
710 lines (578 loc) · 31.3 KB
/
Options.td
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
//===--- Options.td - Options for swift driver ----------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the options accepted by the swift driver.
//
//===----------------------------------------------------------------------===//
// Include the common option parsing interfaces.
include "llvm/Option/OptParser.td"
/////////
// Flags
// The option should be accepted by swift -frontend.
def FrontendOption : OptionFlag;
// The option should be accepted by swift-autolink-extract
def AutolinkExtractOption : OptionFlag;
// The option should be accepted by swift -modulewrap
def ModuleWrapOption : OptionFlag;
// The option should be accepted by swift-format
def SwiftFormatOption : OptionFlag;
// The option should not be accepted by the driver.
def NoDriverOption : OptionFlag;
// Some options should not be available depending on whether this is the
// interactive driver 'swift', or the batch compiler 'swiftc'.
def NoInteractiveOption : OptionFlag;
def NoBatchOption : OptionFlag;
// The option should not force a full rebuild if added, changed, or removed.
def DoesNotAffectIncrementalBuild : OptionFlag;
/////////
// Options
// The internal option ID must be a valid C++ identifier and results in a
// swift::driver::options::OPT_XX enum constant for XX.
//
// We want to unambiguously be able to refer to options from the driver source
// code, for this reason the option name is mangled into an ID. This mangling
// isn't guaranteed to have an inverse, but for practical purposes it does.
//
// The mangling scheme is to ignore the leading '-', and perform the following
// substitutions:
// _ => __
// - => _
// / => _SLASH
// # => _HASH
// ? => _QUESTION
// , => _COMMA
// = => _EQ
// C++ => CXX
// . => _
def internal_Group : OptionGroup<"<swift internal options>">;
def internal_debug_Group :
OptionGroup<"<swift debug/development internal options>">,
Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">;
class InternalDebugOpt : Group<internal_debug_Group>,
Flags<[HelpHidden, DoesNotAffectIncrementalBuild]>;
def driver_print_actions : Flag<["-"], "driver-print-actions">,
InternalDebugOpt, HelpText<"Dump list of actions to perform">;
def driver_print_output_file_map : Flag<["-"], "driver-print-output-file-map">,
InternalDebugOpt, HelpText<"Dump the contents of the output file map">;
def driver_print_bindings : Flag<["-"], "driver-print-bindings">,
InternalDebugOpt, HelpText<"Dump list of job inputs and outputs">;
def driver_print_jobs : Flag<["-"], "driver-print-jobs">, InternalDebugOpt,
HelpText<"Dump list of jobs to execute">;
def _HASH_HASH_HASH : Flag<["-"], "###">, Alias<driver_print_jobs>;
def driver_skip_execution : Flag<["-"], "driver-skip-execution">,
InternalDebugOpt,
HelpText<"Skip execution of subtasks when performing compilation">;
def driver_use_frontend_path : Separate<["-"], "driver-use-frontend-path">,
InternalDebugOpt,
HelpText<"Use the given executable to perform compilations">;
def driver_show_incremental : Flag<["-"], "driver-show-incremental">,
InternalDebugOpt,
HelpText<"With -v, dump information about why files are being rebuilt">;
def driver_show_job_lifecycle : Flag<["-"], "driver-show-job-lifecycle">,
InternalDebugOpt,
HelpText<"Show every step in the lifecycle of driver jobs">;
def driver_use_filelists : Flag<["-"], "driver-use-filelists">,
InternalDebugOpt, HelpText<"Pass input files as filelists whenever possible">;
def driver_always_rebuild_dependents :
Flag<["-"], "driver-always-rebuild-dependents">, InternalDebugOpt,
HelpText<"Always rebuild dependents of files that have been modified">;
def driver_mode : Joined<["--"], "driver-mode=">, Flags<[HelpHidden]>,
HelpText<"Set the driver mode to either 'swift' or 'swiftc'">;
def help : Flag<["-", "--"], "help">,
Flags<[FrontendOption, AutolinkExtractOption, ModuleWrapOption, SwiftFormatOption]>,
HelpText<"Display available options">;
def h : Flag<["-"], "h">, Alias<help>;
def help_hidden : Flag<["-", "--"], "help-hidden">,
Flags<[HelpHidden, FrontendOption]>,
HelpText<"Display available options, including hidden options">;
def v : Flag<["-"], "v">, Flags<[DoesNotAffectIncrementalBuild]>,
HelpText<"Show commands to run and use verbose output">;
def version : Flag<["-", "--"], "version">,
HelpText<"Print version information and exit">;
def parseable_output : Flag<["-"], "parseable-output">,
Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit textual output in a parseable format">;
// Standard Options
def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>;
def o : JoinedOrSeparate<["-"], "o">,
Flags<[FrontendOption, AutolinkExtractOption, ModuleWrapOption,
NoInteractiveOption, SwiftFormatOption]>,
HelpText<"Write output to <file>">, MetaVarName<"<file>">;
def j : JoinedOrSeparate<["-"], "j">, Flags<[DoesNotAffectIncrementalBuild]>,
HelpText<"Number of commands to execute in parallel">, MetaVarName<"<n>">;
def sdk : Separate<["-"], "sdk">, Flags<[FrontendOption]>,
HelpText<"Compile against <sdk>">, MetaVarName<"<sdk>">;
def swift_version : Separate<["-"], "swift-version">, Flags<[FrontendOption]>,
HelpText<"Interpret input according to a specific Swift language version number">,
MetaVarName<"<vers>">;
def tools_directory : Separate<["-"], "tools-directory">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Look for external executables (ld, clang, binutils) in <directory>">, MetaVarName<"<directory>">;
def D : JoinedOrSeparate<["-"], "D">, Flags<[FrontendOption]>,
HelpText<"Marks a conditional compilation flag as true">;
def F : JoinedOrSeparate<["-"], "F">, Flags<[FrontendOption]>,
HelpText<"Add directory to framework search path">;
def F_EQ : Joined<["-"], "F=">, Flags<[FrontendOption]>, Alias<F>;
def Fsystem : Separate<["-"], "Fsystem">, Flags<[FrontendOption]>,
HelpText<"Add directory to system framework search path">;
def I : JoinedOrSeparate<["-"], "I">, Flags<[FrontendOption]>,
HelpText<"Add directory to the import search path">;
def I_EQ : Joined<["-"], "I=">, Flags<[FrontendOption]>, Alias<I>;
def import_underlying_module : Flag<["-"], "import-underlying-module">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Implicitly imports the Objective-C half of a module">;
def import_objc_header : Separate<["-"], "import-objc-header">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Implicitly imports an Objective-C header file">;
def pch_output_dir: Separate<["-"], "pch-output-dir">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Directory to persist automatically created precompiled bridging headers">;
// FIXME: Unhide this once it doesn't depend on an output file map.
def incremental : Flag<["-"], "incremental">,
Flags<[NoInteractiveOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Perform an incremental build if possible">;
def nostdimport : Flag<["-"], "nostdimport">, Flags<[FrontendOption]>,
HelpText<"Don't search the standard library import path for modules">;
def output_file_map : Separate<["-"], "output-file-map">,
Flags<[NoInteractiveOption]>,
HelpText<"A file which specifies the location of outputs">,
MetaVarName<"<path>">;
def output_file_map_EQ : Joined<["-"], "output-file-map=">,
Alias<output_file_map>;
def save_temps : Flag<["-"], "save-temps">,
Flags<[NoInteractiveOption,DoesNotAffectIncrementalBuild]>,
HelpText<"Save intermediate compilation results">;
def driver_time_compilation : Flag<["-"], "driver-time-compilation">,
Flags<[NoInteractiveOption,DoesNotAffectIncrementalBuild]>,
HelpText<"Prints the total time it took to execute all compilation tasks">;
def stats_output_dir: Separate<["-"], "stats-output-dir">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Directory to write unified compilation-statistics files to">;
def trace_stats_events: Flag<["-"], "trace-stats-events">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Trace changes to stats in -stats-output-dir">;
def emit_dependencies : Flag<["-"], "emit-dependencies">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit basic Make-compatible dependencies files">;
def emit_loaded_module_trace : Flag<["-"], "emit-loaded-module-trace">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Emit a JSON file containing information about what modules were loaded">;
def emit_loaded_module_trace_path : Separate<["-"], "emit-loaded-module-trace-path">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Emit the loaded module trace JSON to <path>">,
MetaVarName<"<path>">;
def emit_loaded_module_trace_path_EQ : Joined<["-"], "emit-loaded-module-trace-path=">,
Flags<[FrontendOption, NoInteractiveOption]>, Alias<emit_loaded_module_trace_path>;
def emit_tbd : Flag<["-"], "emit-tbd">,
HelpText<"Emit a TBD file">,
Flags<[FrontendOption, NoInteractiveOption]>;
def emit_tbd_path : Separate<["-"], "emit-tbd-path">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Emit the TBD file to <path>">,
MetaVarName<"<path>">;
def emit_tbd_path_EQ : Joined<["-"], "emit-tbd-path=">,
Flags<[FrontendOption, NoInteractiveOption]>, Alias<emit_tbd_path>;
def serialize_diagnostics : Flag<["-"], "serialize-diagnostics">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Serialize diagnostics in a binary format">;
def module_cache_path : Separate<["-"], "module-cache-path">,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Specifies the Clang module cache path">;
def module_name : Separate<["-"], "module-name">, Flags<[FrontendOption]>,
HelpText<"Name of the module to build">;
def module_name_EQ : Joined<["-"], "module-name=">, Flags<[FrontendOption]>,
Alias<module_name>;
def module_link_name : Separate<["-"], "module-link-name">,
Flags<[FrontendOption]>,
HelpText<"Library to link against when using this module">;
def module_link_name_EQ : Joined<["-"], "module-link-name=">,
Flags<[FrontendOption]>, Alias<module_link_name>;
def autolink_force_load : Flag<["-"], "autolink-force-load">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Force ld to link against this module even if no symbols are used">;
def emit_module : Flag<["-"], "emit-module">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit an importable module">;
def emit_module_path : Separate<["-"], "emit-module-path">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit an importable module to <path>">,
MetaVarName<"<path>">;
def emit_module_path_EQ : Joined<["-"], "emit-module-path=">,
Flags<[FrontendOption, NoInteractiveOption]>, Alias<emit_module_path>;
def emit_objc_header : Flag<["-"], "emit-objc-header">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit an Objective-C header file">;
def emit_objc_header_path : Separate<["-"], "emit-objc-header-path">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
MetaVarName<"<path>">, HelpText<"Emit an Objective-C header file to <path>">;
def import_cf_types : Flag<["-"], "import-cf-types">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Recognize and import CF types as class types">;
def solver_memory_threshold : Separate<["-"], "solver-memory-threshold">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set the upper bound for memory consumption, in bytes, by the constraint solver">;
def solver_shrink_unsolved_threshold : Separate<["-"], "solver-shrink-unsolved-threshold">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set The upper bound to number of sub-expressions unsolved before termination of the shrink phrase">;
def value_recursion_threshold : Separate<["-"], "value-recursion-threshold">,
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Set the maximum depth for direct recursion in value types">;
def disable_swift_bridge_attr : Flag<["-"], "disable-swift-bridge-attr">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Disable using the swift bridge attribute">;
def enable_bridging_pch : Flag<["-"], "enable-bridging-pch">,
Flags<[HelpHidden]>,
HelpText<"Enable automatic generation of bridging PCH files">;
def disable_bridging_pch : Flag<["-"], "disable-bridging-pch">,
Flags<[HelpHidden]>,
HelpText<"Disable automatic generation of bridging PCH files">;
// Diagnostic control options
def suppress_warnings : Flag<["-"], "suppress-warnings">,
Flags<[FrontendOption]>,
HelpText<"Suppress all warnings">;
def warnings_as_errors : Flag<["-"], "warnings-as-errors">,
Flags<[FrontendOption]>,
HelpText<"Treat warnings as errors">;
def continue_building_after_errors : Flag<["-"], "continue-building-after-errors">,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Continue building, even after errors are encountered">;
def warn_swift3_objc_inference_complete :
Flag<["-"], "warn-swift3-objc-inference-complete">,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Warn about deprecated @objc inference in Swift 3 for every declaration that will no longer be inferred as @objc in Swift 4">;
def warn_swift3_objc_inference_minimal :
Flag<["-"], "warn-swift3-objc-inference-minimal">,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Warn about deprecated @objc inference in Swift 3 based on direct uses of the Objective-C entrypoint">;
def typo_correction_limit : Separate<["-"], "typo-correction-limit">,
Flags<[FrontendOption, HelpHidden]>,
MetaVarName<"<n>">,
HelpText<"Limit the number of times the compiler will attempt typo correction to <n>">;
def warn_swift3_objc_inference : Flag<["-"], "warn-swift3-objc-inference">,
Alias<warn_swift3_objc_inference_complete>,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild, HelpHidden]>;
def Rpass_EQ : Joined<["-"], "Rpass=">,
Flags<[FrontendOption]>,
HelpText<"Report performed transformations by optimization passes whose "
"name matches the given POSIX regular expression">;
def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">,
Flags<[FrontendOption]>,
HelpText<"Report missed transformations by optimization passes whose "
"name matches the given POSIX regular expression">;
def save_optimization_record : Flag<["-"], "save-optimization-record">,
Flags<[FrontendOption]>, HelpText<"Generate a YAML optimization record file">;
def save_optimization_record_path :
Separate<["-"], "save-optimization-record-path">,
Flags<[FrontendOption]>,
HelpText<"Specify the file name of any generated YAML optimization record">;
// Platform options.
def enable_app_extension : Flag<["-"], "application-extension">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Restrict code to those available for App Extensions">;
// Linker options
def linker_option_Group : OptionGroup<"<linker-specific options>">;
def l : Joined<["-"], "l">, Group<linker_option_Group>,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Specifies a library which should be linked against">;
def framework : Separate<["-"], "framework">, Group<linker_option_Group>,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Specifies a framework which should be linked against">;
def L : JoinedOrSeparate<["-"], "L">, Group<linker_option_Group>,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Add directory to library link search path">;
def L_EQ : Joined<["-"], "L=">, Alias<L>;
def link_objc_runtime : Flag<["-"], "link-objc-runtime">,
Flags<[DoesNotAffectIncrementalBuild]>;
def no_link_objc_runtime : Flag<["-"], "no-link-objc-runtime">,
Flags<[HelpHidden, DoesNotAffectIncrementalBuild]>,
HelpText<"Don't link in additions to the Objective-C runtime">;
def static_stdlib: Flag<["-"], "static-stdlib">,
Flags<[DoesNotAffectIncrementalBuild]>,
HelpText<"Statically link the Swift standard library">;
def no_static_stdlib: Flag<["-"], "no-static-stdlib">,
Flags<[HelpHidden,DoesNotAffectIncrementalBuild]>,
HelpText<"Don't statically link the Swift standard library">;
def static_executable : Flag<["-"], "static-executable">,
HelpText<"Statically link the executable">;
def no_static_executable : Flag<["-"], "no-static-executable">,
Flags<[HelpHidden]>,
HelpText<"Don't statically link the executable">;
def use_ld : Joined<["-"], "use-ld=">,
Flags<[DoesNotAffectIncrementalBuild]>,
HelpText<"Specifies the linker to be used">;
def Xlinker : Separate<["-"], "Xlinker">,
Flags<[DoesNotAffectIncrementalBuild]>,
HelpText<"Specifies an option which should be passed to the linker">;
// Optimization levels
def O_Group : OptionGroup<"<optimization level options>">;
def Onone : Flag<["-"], "Onone">, Group<O_Group>, Flags<[FrontendOption]>,
HelpText<"Compile without any optimization">;
def O : Flag<["-"], "O">, Group<O_Group>, Flags<[FrontendOption]>,
HelpText<"Compile with optimizations">;
def Osize : Flag<["-"], "Osize">, Group<O_Group>, Flags<[FrontendOption]>,
HelpText<"Compile with optimizations and target small code size">;
def Ounchecked : Flag<["-"], "Ounchecked">, Group<O_Group>,
Flags<[FrontendOption]>,
HelpText<"Compile with optimizations and remove runtime safety checks">;
def Oplayground : Flag<["-"], "Oplayground">, Group<O_Group>,
Flags<[HelpHidden, FrontendOption]>,
HelpText<"Compile with optimizations appropriate for a playground">;
def RemoveRuntimeAsserts : Flag<["-"], "remove-runtime-asserts">,
Flags<[FrontendOption]>,
HelpText<"Remove runtime safety checks.">;
def AssumeSingleThreaded : Flag<["-"], "assume-single-threaded">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Assume that code will be executed in a single-threaded "
"environment">;
// Debug info options
def g_Group : OptionGroup<"<debug info options>">;
def g : Flag<["-"], "g">, Group<g_Group>, Flags<[FrontendOption]>,
HelpText<"Emit debug info. "
"This is the preferred setting for debugging with LLDB.">;
def gnone : Flag<["-"], "gnone">, Group<g_Group>, Flags<[FrontendOption]>,
HelpText<"Don't emit debug info">;
def gline_tables_only : Flag<["-"], "gline-tables-only">,
Group<g_Group>, Flags<[FrontendOption]>,
HelpText<"Emit minimal debug info for backtraces only">;
def gdwarf_types : Flag<["-"], "gdwarf-types">,
Group<g_Group>, Flags<[FrontendOption]>,
HelpText<"Emit full DWARF type info.">;
// Verify debug info
def verify_debug_info : Flag<["-"], "verify-debug-info">,
Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Verify the binary representation of debug output.">;
// Assert configuration identifiers.
def AssertConfig : Separate<["-"], "assert-config">,
Flags<[FrontendOption]>,
HelpText<"Specify the assert_configuration replacement. "
"Possible values are Debug, Release, Unchecked, DisableReplacement.">;
// Code formatting options
def code_formatting_Group : OptionGroup<"<code formatting options>">;
def use_tabs : Flag<["-"], "use-tabs">, Group<code_formatting_Group>,
Flags<[NoInteractiveOption, NoBatchOption, SwiftFormatOption]>,
HelpText<"Use tabs for indentation.">;
def indent_switch_case : Flag<["-"], "indent-switch-case">,
Group<code_formatting_Group>,
Flags<[NoInteractiveOption, NoBatchOption, SwiftFormatOption]>,
HelpText<"Indent cases in switch statements.">;
def in_place : Flag<["-"], "in-place">, Group<code_formatting_Group>,
Flags<[NoInteractiveOption, NoBatchOption, SwiftFormatOption]>,
HelpText<"Overwrite input file with formatted file.">;
def tab_width : Separate<["-"], "tab-width">, Group<code_formatting_Group>,
Flags<[NoInteractiveOption, NoBatchOption, SwiftFormatOption]>,
HelpText<"Width of tab character.">, MetaVarName<"<n>">;
def indent_width : Separate<["-"], "indent-width">, Group<code_formatting_Group>,
Flags<[NoInteractiveOption, NoBatchOption, SwiftFormatOption]>,
HelpText<"Number of characters to indent.">, MetaVarName<"<n>">;
def line_range : Separate<["-"], "line-range">, Group<code_formatting_Group>,
Flags<[NoInteractiveOption, NoBatchOption, SwiftFormatOption]>,
HelpText<"<start line>:<end line>. Formats a range of lines (1-based). "
"Can only be used with one input file.">, MetaVarName<"<n:n>">;
// Migrator Options
def update_code : Flag<["-"], "update-code">,
HelpText<"Update Swift code">,
Flags<[FrontendOption, HelpHidden, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def migrate_keep_objc_visibility: Flag<["-"], "migrate-keep-objc-visibility">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"When migrating, add '@objc' to declarations that would've been implicitly visible in Swift 3">;
def disable_migrator_fixits: Flag<["-"], "disable-migrator-fixits">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Disable the Migrator phase which automatically applies fix-its">;
def emit_remap_file_path: Separate<["-"], "emit-remap-file-path">,
Flags<[FrontendOption, NoDriverOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit the replacement map describing Swift Migrator changes to <path>">,
MetaVarName<"<path>">;
def emit_migrated_file_path: Separate<["-"], "emit-migrated-file-path">,
Flags<[FrontendOption, NoDriverOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Emit the migrated source file to <path>">,
MetaVarName<"<path>">;
def dump_migration_states_dir: Separate<["-"], "dump-migration-states-dir">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Dump the input text, output text, and states for migration to <path>">,
MetaVarName<"<path>">;
def api_diff_data_file: Separate<["-"], "api-diff-data-file">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"API migration data is from <path>">,
MetaVarName<"<path>">;
def dump_usr: Flag<["-"], "dump-usr">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Dump USR for each declaration reference">;
// FIXME: Remove these once Xcode stops appending these flags.
// rdar://problem/31844718
def migrator_update_sdk: Flag<["-"], "migrator-update-sdk">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Does nothing. Temporary compatibility flag for Xcode.">;
def migrator_update_swift: Flag<["-"], "migrator-update-swift">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Does nothing. Temporary compatibility flag for Xcode.">;
// File types
def parse_as_library : Flag<["-"], "parse-as-library">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Parse the input file(s) as libraries, not scripts">;
def parse_sil : Flag<["-"], "parse-sil">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Parse the input file as SIL code, not Swift source">;
def parse_stdlib : Flag<["-"], "parse-stdlib">,
Flags<[FrontendOption, HelpHidden]>,
HelpText<"Parse the input file(s) as the Swift standard library">;
def modes_Group : OptionGroup<"<mode options>">, HelpText<"MODES">;
class ModeOpt : Group<modes_Group>;
// Output Modes
def emit_executable : Flag<["-"], "emit-executable">,
HelpText<"Emit a linked executable">, ModeOpt,
Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_library : Flag<["-"], "emit-library">,
HelpText<"Emit a linked library">, ModeOpt,
Flags<[NoInteractiveOption]>;
def emit_object : Flag<["-"], "emit-object">,
HelpText<"Emit object file(s) (-c)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_assembly : Flag<["-"], "emit-assembly">,
HelpText<"Emit assembly file(s) (-S)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_bc : Flag<["-"], "emit-bc">,
HelpText<"Emit LLVM BC file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_ir : Flag<["-"], "emit-ir">,
HelpText<"Emit LLVM IR file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_sil : Flag<["-"], "emit-sil">,
HelpText<"Emit canonical SIL file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_silgen : Flag<["-"], "emit-silgen">,
HelpText<"Emit raw SIL file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_sib : Flag<["-"], "emit-sib">,
HelpText<"Emit serialized AST + canonical SIL file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_sibgen : Flag<["-"], "emit-sibgen">,
HelpText<"Emit serialized AST + raw SIL file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def emit_imported_modules : Flag<["-"], "emit-imported-modules">,
HelpText<"Emit a list of the imported modules">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def c : Flag<["-"], "c">, Alias<emit_object>,
Flags<[FrontendOption, NoInteractiveOption]>, ModeOpt;
def S: Flag<["-"], "S">, Alias<emit_assembly>,
Flags<[FrontendOption, NoInteractiveOption]>, ModeOpt;
def fixit_all : Flag<["-"], "fixit-all">,
HelpText<"Apply all fixits from diagnostics without any filtering">,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
// No Output Modes
def parse: Flag<["-"], "parse">,
HelpText<"Parse input file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def typecheck : Flag<["-"], "typecheck">,
HelpText<"Parse and type-check input file(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def dump_parse : Flag<["-"], "dump-parse">,
HelpText<"Parse input file(s) and dump AST(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def dump_ast : Flag<["-"], "dump-ast">,
HelpText<"Parse and type-check input file(s) and dump AST(s)">, ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def dump_scope_maps : Separate<["-"], "dump-scope-maps">,
HelpText<"Parse and type-check input file(s) and dump the scope map(s)">,
MetaVarName<"<expanded-or-list-of-line:column>">,
ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def dump_type_refinement_contexts :
Flag<["-"], "dump-type-refinement-contexts">,
HelpText<"Type-check input file(s) and dump type refinement contexts(s)">,
ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def print_ast : Flag<["-"], "print-ast">,
HelpText<"Parse and type-check input file(s) and pretty print AST(s)">,
ModeOpt,
Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
// Other Modes
def repl : Flag<["-"], "repl">,
HelpText<"REPL mode (the default if there is no input file)">,
Flags<[FrontendOption, NoBatchOption, HelpHidden]>, ModeOpt;
def lldb_repl : Flag<["-"], "lldb-repl">, HelpText<"LLDB-enhanced REPL mode">,
Flags<[NoBatchOption, HelpHidden]>, ModeOpt;
def deprecated_integrated_repl : Flag<["-"], "deprecated-integrated-repl">,
Flags<[FrontendOption, NoBatchOption]>, ModeOpt;
def i : Flag<["-"], "i">, ModeOpt; // only used to provide diagnostics.
def whole_module_optimization : Flag<["-"], "whole-module-optimization">,
HelpText<"Optimize input files together instead of individually">,
Flags<[FrontendOption, NoInteractiveOption]>;
def wmo : Flag<["-"], "wmo">, Alias<whole_module_optimization>,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>;
def force_single_frontend_invocation :
Flag<["-"], "force-single-frontend-invocation">,
Alias<whole_module_optimization>,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>;
def num_threads : Separate<["-"], "num-threads">,
Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Enable multi-threading and specify number of threads">,
MetaVarName<"<n>">;
def Xfrontend : Separate<["-"], "Xfrontend">, Flags<[HelpHidden]>,
MetaVarName<"<arg>">, HelpText<"Pass <arg> to the Swift frontend">;
def Xcc : Separate<["-"], "Xcc">, Flags<[FrontendOption]>,
MetaVarName<"<arg>">,
HelpText<"Pass <arg> to the C/C++/Objective-C compiler">;
def Xllvm : Separate<["-"], "Xllvm">,
Flags<[FrontendOption, HelpHidden]>,
MetaVarName<"<arg>">, HelpText<"Pass <arg> to LLVM.">;
def resource_dir : Separate<["-"], "resource-dir">,
Flags<[FrontendOption, HelpHidden]>,
MetaVarName<"</usr/lib/swift>">,
HelpText<"The directory that holds the compiler resource files">;
def target : Separate<["-"], "target">,
Flags<[FrontendOption, ModuleWrapOption]>,
HelpText<"Generate code for the given target">;
def target_legacy_spelling : Joined<["--"], "target=">,
Flags<[FrontendOption]>, Alias<target>;
def target_cpu : Separate<["-"], "target-cpu">, Flags<[FrontendOption]>,
HelpText<"Generate code for a particular CPU variant">;
def profile_generate : Flag<["-"], "profile-generate">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Generate instrumented code to collect execution counts">;
def profile_use : CommaJoined<["-"], "profile-use=">,
Flags<[FrontendOption, NoInteractiveOption]>, MetaVarName<"<profdata>">,
HelpText<"Supply a profdata file to enable profile-guided optimization">;
def profile_coverage_mapping : Flag<["-"], "profile-coverage-mapping">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Generate coverage data for use with profiled execution counts">;
def embed_bitcode : Flag<["-"], "embed-bitcode">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Embed LLVM IR bitcode as data">;
def embed_bitcode_marker : Flag<["-"], "embed-bitcode-marker">,
Flags<[FrontendOption, NoInteractiveOption]>,
HelpText<"Embed placeholder LLVM IR data as a marker">;
def enable_testing : Flag<["-"], "enable-testing">,
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
HelpText<"Allows this module's internal API to be accessed for testing">;
def sanitize_EQ : CommaJoined<["-"], "sanitize=">,
Flags<[FrontendOption, NoInteractiveOption]>, MetaVarName<"<check>">,
HelpText<"Turn on runtime checks for erroneous behavior.">;
def sanitize_coverage_EQ : CommaJoined<["-"], "sanitize-coverage=">,
Flags<[FrontendOption, NoInteractiveOption]>,
MetaVarName<"<type>">,
HelpText<"Specify the type of coverage instrumentation for Sanitizers and"
" additional options separated by commas">;
def index_file : Flag<["-"], "index-file">,
HelpText<"Produce index data for a source file">, ModeOpt,
Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>;
def index_file_path : Separate<["-"], "index-file-path">,
Flags<[NoInteractiveOption, DoesNotAffectIncrementalBuild]>,
HelpText<"Produce index data for file <path>">,
MetaVarName<"<path>">;
def index_store_path : Separate<["-"], "index-store-path">,
Flags<[FrontendOption]>, MetaVarName<"<path>">,
HelpText<"Store indexing data to <path>">;
def enforce_exclusivity_EQ : Joined<["-"], "enforce-exclusivity=">,
Flags<[FrontendOption]>, MetaVarName<"<enforcement>">,
HelpText<"Enforce law of exclusivity">;
include "FrontendOptions.td"