1 //===--- Options.td - Options for clang -----------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file defines the options accepted by clang.
11 //===----------------------------------------------------------------------===//
13 // Include the common option parsing interfaces.
14 include "llvm/Option/OptParser.td"
19 // DriverOption - The option is a "driver" option, and should not be forwarded
21 def DriverOption : OptionFlag;
23 // LinkerInput - The option is a linker input.
24 def LinkerInput : OptionFlag;
26 // NoArgumentUnused - Don't report argument unused warnings for this option; this
27 // is useful for options like -static or -dynamic which a user may always end up
28 // passing, even if the platform defaults to (or only supports) that option.
29 def NoArgumentUnused : OptionFlag;
31 // Unsupported - The option is unsupported, and the driver will reject command
33 def Unsupported : OptionFlag;
35 // Ignored - The option is unsupported, and the driver will silently ignore it.
36 def Ignored : OptionFlag;
38 // CoreOption - This is considered a "core" Clang option, available in both
39 // clang and clang-cl modes.
40 def CoreOption : OptionFlag;
42 // CLOption - This is a cl.exe compatibility option. Options with this flag
43 // are made available when the driver is running in CL compatibility mode.
44 def CLOption : OptionFlag;
46 // CC1Option - This option should be accepted by clang -cc1.
47 def CC1Option : OptionFlag;
49 // CC1AsOption - This option should be accepted by clang -cc1as.
50 def CC1AsOption : OptionFlag;
52 // NoDriverOption - This option should not be accepted by the driver.
53 def NoDriverOption : OptionFlag;
55 // A short name to show in documentation. The name will be interpreted as rST.
56 class DocName<string name> { string DocName = name; }
58 // A brief description to show in documentation, interpreted as rST.
59 class DocBrief<code descr> { code DocBrief = descr; }
61 // Indicates that this group should be flattened into its parent when generating
63 class DocFlatten { bit DocFlatten = 1; }
65 // Indicates that this warning is ignored, but accepted with a warning for
67 class IgnoredGCCCompat : Flags<[HelpHidden]> {}
72 def Action_Group : OptionGroup<"<action group>">, DocName<"Actions">,
73 DocBrief<[{The action to perform on the input.}]>;
75 // Meta-group for options which are only used for compilation,
76 // and not linking etc.
77 def CompileOnly_Group : OptionGroup<"<CompileOnly group>">,
78 DocName<"Compilation flags">, DocBrief<[{
79 Flags controlling the behavior of Clang during compilation. These flags have
80 no effect during actions that do not perform compilation.}]>;
82 def Preprocessor_Group : OptionGroup<"<Preprocessor group>">,
83 Group<CompileOnly_Group>,
84 DocName<"Preprocessor flags">, DocBrief<[{
85 Flags controlling the behavior of the Clang preprocessor.}]>;
87 def IncludePath_Group : OptionGroup<"<I/i group>">, Group<Preprocessor_Group>,
88 DocName<"Include path management">,
90 Flags controlling how ``#include``\s are resolved to files.}]>;
92 def I_Group : OptionGroup<"<I group>">, Group<IncludePath_Group>, DocFlatten;
93 def i_Group : OptionGroup<"<i group>">, Group<IncludePath_Group>, DocFlatten;
94 def clang_i_Group : OptionGroup<"<clang i group>">, Group<i_Group>, DocFlatten;
96 def M_Group : OptionGroup<"<M group>">, Group<Preprocessor_Group>,
97 DocName<"Dependency file generation">, DocBrief<[{
98 Flags controlling generation of a dependency file for ``make``-like build
101 def d_Group : OptionGroup<"<d group>">, Group<Preprocessor_Group>,
102 DocName<"Dumping preprocessor state">, DocBrief<[{
103 Flags allowing the state of the preprocessor to be dumped in various ways.}]>;
105 def Diag_Group : OptionGroup<"<W/R group>">, Group<CompileOnly_Group>,
106 DocName<"Diagnostic flags">, DocBrief<[{
107 Flags controlling which warnings, errors, and remarks Clang will generate.
108 See the :doc:`full list of warning and remark flags <DiagnosticsReference>`.}]>;
110 def R_Group : OptionGroup<"<R group>">, Group<Diag_Group>, DocFlatten;
111 def R_value_Group : OptionGroup<"<R (with value) group>">, Group<R_Group>,
113 def W_Group : OptionGroup<"<W group>">, Group<Diag_Group>, DocFlatten;
114 def W_value_Group : OptionGroup<"<W (with value) group>">, Group<W_Group>,
117 def f_Group : OptionGroup<"<f group>">, Group<CompileOnly_Group>,
118 DocName<"Target-independent compilation options">;
120 def f_clang_Group : OptionGroup<"<f (clang-only) group>">,
121 Group<CompileOnly_Group>, DocFlatten;
122 def pedantic_Group : OptionGroup<"<pedantic group>">, Group<f_Group>,
124 def opencl_Group : OptionGroup<"<opencl group>">, Group<f_Group>,
125 DocName<"OpenCL flags">;
127 def sycl_Group : OptionGroup<"<SYCL group>">, Group<f_Group>,
128 DocName<"SYCL flags">;
130 def m_Group : OptionGroup<"<m group>">, Group<CompileOnly_Group>,
131 DocName<"Target-dependent compilation options">;
133 // Feature groups - these take command line options that correspond directly to
134 // target specific features and can be translated directly from command line
136 def m_aarch64_Features_Group : OptionGroup<"<aarch64 features group>">,
137 Group<m_Group>, DocName<"AARCH64">;
138 def m_amdgpu_Features_Group : OptionGroup<"<amdgpu features group>">,
139 Group<m_Group>, DocName<"AMDGPU">;
140 def m_arm_Features_Group : OptionGroup<"<arm features group>">,
141 Group<m_Group>, DocName<"ARM">;
142 def m_hexagon_Features_Group : OptionGroup<"<hexagon features group>">,
143 Group<m_Group>, DocName<"Hexagon">;
144 // The features added by this group will not be added to target features.
145 // These are explicitly handled.
146 def m_hexagon_Features_HVX_Group : OptionGroup<"<hexagon features group>">,
147 Group<m_Group>, DocName<"Hexagon">;
148 def m_mips_Features_Group : OptionGroup<"<mips features group>">,
149 Group<m_Group>, DocName<"MIPS">;
150 def m_ppc_Features_Group : OptionGroup<"<ppc features group>">,
151 Group<m_Group>, DocName<"PowerPC">;
152 def m_wasm_Features_Group : OptionGroup<"<wasm features group>">,
153 Group<m_Group>, DocName<"WebAssembly">;
154 // The features added by this group will not be added to target features.
155 // These are explicitly handled.
156 def m_wasm_Features_Driver_Group : OptionGroup<"<wasm driver features group>">,
157 Group<m_Group>, DocName<"WebAssembly Driver">;
158 def m_x86_Features_Group : OptionGroup<"<x86 features group>">,
159 Group<m_Group>, Flags<[CoreOption]>, DocName<"X86">;
160 def m_riscv_Features_Group : OptionGroup<"<riscv features group>">,
161 Group<m_Group>, DocName<"RISCV">;
163 def m_libc_Group : OptionGroup<"<m libc group>">, Group<m_mips_Features_Group>,
166 def O_Group : OptionGroup<"<O group>">, Group<CompileOnly_Group>,
167 DocName<"Optimization level">, DocBrief<[{
168 Flags controlling how much optimization should be performed.}]>;
170 def DebugInfo_Group : OptionGroup<"<g group>">, Group<CompileOnly_Group>,
171 DocName<"Debug information generation">, DocBrief<[{
172 Flags controlling how much and what kind of debug information should be
175 def g_Group : OptionGroup<"<g group>">, Group<DebugInfo_Group>,
176 DocName<"Kind and level of debug information">;
177 def gN_Group : OptionGroup<"<gN group>">, Group<g_Group>,
178 DocName<"Debug level">;
179 def ggdbN_Group : OptionGroup<"<ggdbN group>">, Group<gN_Group>, DocFlatten;
180 def gTune_Group : OptionGroup<"<gTune group>">, Group<g_Group>,
181 DocName<"Debugger to tune debug information for">;
182 def g_flags_Group : OptionGroup<"<g flags group>">, Group<DebugInfo_Group>,
183 DocName<"Debug information flags">;
185 def StaticAnalyzer_Group : OptionGroup<"<Static analyzer group>">,
186 DocName<"Static analyzer flags">, DocBrief<[{
187 Flags controlling the behavior of the Clang Static Analyzer.}]>;
189 // gfortran options that we recognize in the driver and pass along when
190 // invoking GCC to compile Fortran code.
191 def gfortran_Group : OptionGroup<"<gfortran group>">,
192 DocName<"Fortran compilation flags">, DocBrief<[{
193 Flags that will be passed onto the ``gfortran`` compiler when Clang is given
196 def Link_Group : OptionGroup<"<T/e/s/t/u group>">, DocName<"Linker flags">,
197 DocBrief<[{Flags that are passed on to the linker}]>;
198 def T_Group : OptionGroup<"<T group>">, Group<Link_Group>, DocFlatten;
199 def u_Group : OptionGroup<"<u group>">, Group<Link_Group>, DocFlatten;
201 def reserved_lib_Group : OptionGroup<"<reserved libs group>">,
202 Flags<[Unsupported]>;
204 // Temporary groups for clang options which we know we don't support,
205 // but don't want to verbosely warn the user about.
206 def clang_ignored_f_Group : OptionGroup<"<clang ignored f group>">,
207 Group<f_Group>, Flags<[Ignored]>;
208 def clang_ignored_m_Group : OptionGroup<"<clang ignored m group>">,
209 Group<m_Group>, Flags<[Ignored]>;
211 // Group for clang options in the process of deprecation.
212 // Please include the version that deprecated the flag as comment to allow
213 // easier garbage collection.
214 def clang_ignored_legacy_options_Group : OptionGroup<"<clang legacy flags>">,
215 Group<f_Group>, Flags<[Ignored]>;
217 // Retired with clang-5.0
218 def : Flag<["-"], "fslp-vectorize-aggressive">, Group<clang_ignored_legacy_options_Group>;
219 def : Flag<["-"], "fno-slp-vectorize-aggressive">, Group<clang_ignored_legacy_options_Group>;
221 // Retired with clang-10.0. Previously controlled X86 MPX ISA.
222 def mmpx : Flag<["-"], "mmpx">, Group<clang_ignored_legacy_options_Group>;
223 def mno_mpx : Flag<["-"], "mno-mpx">, Group<clang_ignored_legacy_options_Group>;
225 // Group that ignores all gcc optimizations that won't be implemented
226 def clang_ignored_gcc_optimization_f_Group : OptionGroup<
227 "<clang_ignored_gcc_optimization_f_Group>">, Group<f_Group>, Flags<[Ignored]>;
229 // A boolean option which is opt-in in CC1. The positive option exists in CC1 and
230 // Args.hasArg(OPT_ffoo) is used to check that the flag is enabled.
231 // This is useful if the option is usually disabled.
232 multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="",
233 string help="", list<OptionFlag> flags=[]> {
234 def f#NAME : Flag<["-"], "f"#name>, Flags<!listconcat([CC1Option], flags)>,
235 Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>;
236 def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<flags>,
237 Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>;
240 // A boolean option which is opt-out in CC1. The negative option exists in CC1 and
241 // Args.hasArg(OPT_fno_foo) is used to check that the flag is disabled.
242 multiclass OptOutFFlag<string name, string pos_prefix, string neg_prefix,
243 string help="", list<OptionFlag> flags=[]> {
244 def f#NAME : Flag<["-"], "f"#name>, Flags<flags>,
245 Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>;
246 def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<!listconcat([CC1Option], flags)>,
247 Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>;
253 // The internal option ID must be a valid C++ identifier and results in a
254 // clang::driver::options::OPT_XX enum constant for XX.
256 // We want to unambiguously be able to refer to options from the driver source
257 // code, for this reason the option name is mangled into an ID. This mangling
258 // isn't guaranteed to have an inverse, but for practical purposes it does.
260 // The mangling scheme is to ignore the leading '-', and perform the following
272 // Developer Driver Options
274 def internal_Group : OptionGroup<"<clang internal options>">, Flags<[HelpHidden]>;
275 def internal_driver_Group : OptionGroup<"<clang driver internal options>">,
276 Group<internal_Group>, HelpText<"DRIVER OPTIONS">;
277 def internal_debug_Group :
278 OptionGroup<"<clang debug/development internal options>">,
279 Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">;
281 class InternalDriverOpt : Group<internal_driver_Group>,
282 Flags<[DriverOption, HelpHidden]>;
283 def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>,
284 Flags<[CoreOption, DriverOption, HelpHidden]>,
285 HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'">;
286 def rsp_quoting : Joined<["--"], "rsp-quoting=">, Group<internal_driver_Group>,
287 Flags<[CoreOption, DriverOption, HelpHidden]>,
288 HelpText<"Set the rsp quoting to either 'posix', or 'windows'">;
289 def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt,
290 HelpText<"Name for native GCC compiler">,
291 MetaVarName<"<gcc-path>">;
293 class InternalDebugOpt : Group<internal_debug_Group>,
294 Flags<[DriverOption, HelpHidden, CoreOption]>;
295 def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt,
296 HelpText<"Simulate installation in the given directory">;
297 def ccc_print_phases : Flag<["-"], "ccc-print-phases">, InternalDebugOpt,
298 HelpText<"Dump list of actions to perform">;
299 def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, InternalDebugOpt,
300 HelpText<"Show bindings of tools to actions">;
302 def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, InternalDriverOpt,
303 HelpText<"Check for ARC migration issues that need manual handling">;
304 def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, InternalDriverOpt,
305 HelpText<"Apply modifications to files to conform to ARC">;
306 def ccc_arcmt_migrate : Separate<["-"], "ccc-arcmt-migrate">, InternalDriverOpt,
307 HelpText<"Apply modifications and produces temporary files that conform to ARC">;
308 def arcmt_migrate_report_output : Separate<["-"], "arcmt-migrate-report-output">,
309 HelpText<"Output path for the plist report">, Flags<[CC1Option]>;
310 def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">,
311 HelpText<"Emit ARC errors even if the migrator can fix them">,
313 def gen_reproducer: Flag<["-"], "gen-reproducer">, InternalDebugOpt,
314 HelpText<"Auto-generates preprocessed source files and a reproduction script">;
315 def gen_cdb_fragment_path: Separate<["-"], "gen-cdb-fragment-path">, InternalDebugOpt,
316 HelpText<"Emit a compilation database fragment to the specified directory">;
318 def _migrate : Flag<["--"], "migrate">, Flags<[DriverOption]>,
319 HelpText<"Run the migrator">;
320 def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">,
322 HelpText<"Apply modifications and produces temporary files to migrate to "
323 "modern ObjC syntax">;
324 def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>,
325 HelpText<"Enable migration to modern ObjC literals">;
326 def objcmt_migrate_subscripting : Flag<["-"], "objcmt-migrate-subscripting">, Flags<[CC1Option]>,
327 HelpText<"Enable migration to modern ObjC subscripting">;
328 def objcmt_migrate_property : Flag<["-"], "objcmt-migrate-property">, Flags<[CC1Option]>,
329 HelpText<"Enable migration to modern ObjC property">;
330 def objcmt_migrate_all : Flag<["-"], "objcmt-migrate-all">, Flags<[CC1Option]>,
331 HelpText<"Enable migration to modern ObjC">;
332 def objcmt_migrate_readonly_property : Flag<["-"], "objcmt-migrate-readonly-property">, Flags<[CC1Option]>,
333 HelpText<"Enable migration to modern ObjC readonly property">;
334 def objcmt_migrate_readwrite_property : Flag<["-"], "objcmt-migrate-readwrite-property">, Flags<[CC1Option]>,
335 HelpText<"Enable migration to modern ObjC readwrite property">;
336 def objcmt_migrate_property_dot_syntax : Flag<["-"], "objcmt-migrate-property-dot-syntax">, Flags<[CC1Option]>,
337 HelpText<"Enable migration of setter/getter messages to property-dot syntax">;
338 def objcmt_migrate_annotation : Flag<["-"], "objcmt-migrate-annotation">, Flags<[CC1Option]>,
339 HelpText<"Enable migration to property and method annotations">;
340 def objcmt_migrate_instancetype : Flag<["-"], "objcmt-migrate-instancetype">, Flags<[CC1Option]>,
341 HelpText<"Enable migration to infer instancetype for method result type">;
342 def objcmt_migrate_nsmacros : Flag<["-"], "objcmt-migrate-ns-macros">, Flags<[CC1Option]>,
343 HelpText<"Enable migration to NS_ENUM/NS_OPTIONS macros">;
344 def objcmt_migrate_protocol_conformance : Flag<["-"], "objcmt-migrate-protocol-conformance">, Flags<[CC1Option]>,
345 HelpText<"Enable migration to add protocol conformance on classes">;
346 def objcmt_atomic_property : Flag<["-"], "objcmt-atomic-property">, Flags<[CC1Option]>,
347 HelpText<"Make migration to 'atomic' properties">;
348 def objcmt_returns_innerpointer_property : Flag<["-"], "objcmt-returns-innerpointer-property">, Flags<[CC1Option]>,
349 HelpText<"Enable migration to annotate property with NS_RETURNS_INNER_POINTER">;
350 def objcmt_ns_nonatomic_iosonly: Flag<["-"], "objcmt-ns-nonatomic-iosonly">, Flags<[CC1Option]>,
351 HelpText<"Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute">;
352 def objcmt_migrate_designated_init : Flag<["-"], "objcmt-migrate-designated-init">, Flags<[CC1Option]>,
353 HelpText<"Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods">;
354 def objcmt_whitelist_dir_path: Joined<["-"], "objcmt-whitelist-dir-path=">, Flags<[CC1Option]>,
355 HelpText<"Only modify files with a filename contained in the provided directory path">;
356 // The misspelt "white-list" [sic] alias is due for removal.
357 def : Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>,
358 Alias<objcmt_whitelist_dir_path>;
360 // Make sure all other -ccc- options are rejected.
361 def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>;
365 def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,
366 HelpText<"Print (but do not run) the commands to run for this compilation">;
367 def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>,
368 Flags<[DriverOption, CoreOption]>;
369 def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>, Group<gfortran_Group>;
370 def B : JoinedOrSeparate<["-"], "B">, MetaVarName<"<dir>">,
371 HelpText<"Add <dir> to search path for binaries and object files used implicitly">;
372 def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
373 HelpText<"Include comments from within macros in preprocessed output">;
374 def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
375 HelpText<"Include comments in preprocessed output">;
376 def D : JoinedOrSeparate<["-"], "D">, Group<Preprocessor_Group>,
377 Flags<[CC1Option]>, MetaVarName<"<macro>=<value>">,
378 HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">;
379 def E : Flag<["-"], "E">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
380 HelpText<"Only run the preprocessor">;
381 def F : JoinedOrSeparate<["-"], "F">, Flags<[RenderJoined,CC1Option]>,
382 HelpText<"Add directory to framework include search path">;
383 def G : JoinedOrSeparate<["-"], "G">, Flags<[DriverOption]>, Group<m_Group>,
384 MetaVarName<"<size>">, HelpText<"Put objects of at most <size> bytes "
385 "into small data section (MIPS / Hexagon)">;
386 def G_EQ : Joined<["-"], "G=">, Flags<[DriverOption]>, Group<m_Group>, Alias<G>;
387 def H : Flag<["-"], "H">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
388 HelpText<"Show header includes and nesting depth">;
389 def I_ : Flag<["-"], "I-">, Group<I_Group>,
390 HelpText<"Restrict all prior -I flags to double-quoted inclusion and "
391 "remove current directory from include path">;
392 def I : JoinedOrSeparate<["-"], "I">, Group<I_Group>,
393 Flags<[CC1Option,CC1AsOption]>, MetaVarName<"<dir>">,
394 HelpText<"Add directory to include search path">;
395 def L : JoinedOrSeparate<["-"], "L">, Flags<[RenderJoined]>, Group<Link_Group>,
396 MetaVarName<"<dir>">, HelpText<"Add directory to library search path">;
397 def MD : Flag<["-"], "MD">, Group<M_Group>,
398 HelpText<"Write a depfile containing user and system headers">;
399 def MMD : Flag<["-"], "MMD">, Group<M_Group>,
400 HelpText<"Write a depfile containing user headers">;
401 def M : Flag<["-"], "M">, Group<M_Group>,
402 HelpText<"Like -MD, but also implies -E and writes to stdout by default">;
403 def MM : Flag<["-"], "MM">, Group<M_Group>,
404 HelpText<"Like -MMD, but also implies -E and writes to stdout by default">;
405 def MF : JoinedOrSeparate<["-"], "MF">, Group<M_Group>,
406 HelpText<"Write depfile output from -MMD, -MD, -MM, or -M to <file>">,
407 MetaVarName<"<file>">;
408 def MG : Flag<["-"], "MG">, Group<M_Group>, Flags<[CC1Option]>,
409 HelpText<"Add missing headers to depfile">;
410 def MJ : JoinedOrSeparate<["-"], "MJ">, Group<M_Group>,
411 HelpText<"Write a compilation database entry per input">;
412 def MP : Flag<["-"], "MP">, Group<M_Group>, Flags<[CC1Option]>,
413 HelpText<"Create phony target for each dependency (other than main file)">;
414 def MQ : JoinedOrSeparate<["-"], "MQ">, Group<M_Group>, Flags<[CC1Option]>,
415 HelpText<"Specify name of main file output to quote in depfile">;
416 def MT : JoinedOrSeparate<["-"], "MT">, Group<M_Group>, Flags<[CC1Option]>,
417 HelpText<"Specify name of main file output in depfile">;
418 def MV : Flag<["-"], "MV">, Group<M_Group>, Flags<[CC1Option]>,
419 HelpText<"Use NMake/Jom format for the depfile">;
420 def Mach : Flag<["-"], "Mach">, Group<Link_Group>;
421 def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>;
422 def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>;
423 def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>,
424 HelpText<"Treat source input files as Objective-C++ inputs">;
425 def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
426 HelpText<"Treat source input files as Objective-C inputs">;
427 def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>;
428 def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["1"]>;
429 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
430 def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
431 HelpText<"Disable linemarker output in -E mode">;
432 def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>,
433 HelpText<"Emit metadata containing compiler name and version">;
434 def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>,
435 HelpText<"Do not emit metadata containing compiler name and version">;
436 def : Flag<["-"], "fident">, Group<f_Group>, Alias<Qy>, Flags<[CC1Option]>;
437 def : Flag<["-"], "fno-ident">, Group<f_Group>, Alias<Qn>, Flags<[CC1Option]>;
438 def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>,
439 HelpText<"Don't emit warning for unused driver arguments">;
440 def Q : Flag<["-"], "Q">, IgnoredGCCCompat;
441 def Rpass_EQ : Joined<["-"], "Rpass=">, Group<R_value_Group>, Flags<[CC1Option]>,
442 HelpText<"Report transformations performed by optimization passes whose "
443 "name matches the given POSIX regular expression">;
444 def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">, Group<R_value_Group>,
446 HelpText<"Report missed transformations by optimization passes whose "
447 "name matches the given POSIX regular expression">;
448 def Rpass_analysis_EQ : Joined<["-"], "Rpass-analysis=">, Group<R_value_Group>,
450 HelpText<"Report transformation analysis from optimization passes whose "
451 "name matches the given POSIX regular expression">;
452 def R_Joined : Joined<["-"], "R">, Group<R_Group>, Flags<[CC1Option, CoreOption]>,
453 MetaVarName<"<remark>">, HelpText<"Enable the specified remark">;
454 def S : Flag<["-"], "S">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
455 HelpText<"Only run preprocess and compilation steps">;
456 def Tbss : JoinedOrSeparate<["-"], "Tbss">, Group<T_Group>,
457 MetaVarName<"<addr>">, HelpText<"Set starting address of BSS to <addr>">;
458 def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>,
459 MetaVarName<"<addr>">, HelpText<"Set starting address of DATA to <addr>">;
460 def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>,
461 MetaVarName<"<addr>">, HelpText<"Set starting address of TEXT to <addr>">;
462 def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>,
463 MetaVarName<"<script>">, HelpText<"Specify <script> as linker script">;
464 def U : JoinedOrSeparate<["-"], "U">, Group<Preprocessor_Group>,
465 Flags<[CC1Option]>, MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">;
466 def V : JoinedOrSeparate<["-"], "V">, Flags<[DriverOption, Unsupported]>;
467 def Wa_COMMA : CommaJoined<["-"], "Wa,">,
468 HelpText<"Pass the comma separated arguments in <arg> to the assembler">,
469 MetaVarName<"<arg>">;
470 def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
471 def WCL4 : Flag<["-"], "WCL4">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
472 def Wdeprecated : Flag<["-"], "Wdeprecated">, Group<W_Group>, Flags<[CC1Option]>,
473 HelpText<"Enable warnings for deprecated constructs and define __DEPRECATED">;
474 def Wno_deprecated : Flag<["-"], "Wno-deprecated">, Group<W_Group>, Flags<[CC1Option]>;
475 def Wl_COMMA : CommaJoined<["-"], "Wl,">, Flags<[LinkerInput, RenderAsInput]>,
476 HelpText<"Pass the comma separated arguments in <arg> to the linker">,
477 MetaVarName<"<arg>">, Group<Link_Group>;
478 // FIXME: This is broken; these should not be Joined arguments.
479 def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Group<W_Group>,
481 def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>,
483 def Wp_COMMA : CommaJoined<["-"], "Wp,">,
484 HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,
485 MetaVarName<"<arg>">, Group<Preprocessor_Group>;
486 def Wundef_prefix_EQ : CommaJoined<["-"], "Wundef-prefix=">, Group<W_value_Group>,
487 Flags<[CC1Option, CoreOption, HelpHidden]>, MetaVarName<"<arg>">,
488 HelpText<"Enable warnings for undefined macros with a prefix in the comma separated list <arg>">;
489 def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
490 def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
491 def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>,
492 MetaVarName<"<warning>">, HelpText<"Enable the specified warning">;
493 def Xanalyzer : Separate<["-"], "Xanalyzer">,
494 HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">,
495 Group<StaticAnalyzer_Group>;
496 def Xarch__ : JoinedAndSeparate<["-"], "Xarch_">, Flags<[DriverOption]>;
497 def Xarch_host : Separate<["-"], "Xarch_host">, Flags<[DriverOption]>,
498 HelpText<"Pass <arg> to the CUDA/HIP host compilation">, MetaVarName<"<arg>">;
499 def Xarch_device : Separate<["-"], "Xarch_device">, Flags<[DriverOption]>,
500 HelpText<"Pass <arg> to the CUDA/HIP device compilation">, MetaVarName<"<arg>">;
501 def Xassembler : Separate<["-"], "Xassembler">,
502 HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">,
503 Group<CompileOnly_Group>;
504 def Xclang : Separate<["-"], "Xclang">,
505 HelpText<"Pass <arg> to the clang compiler">, MetaVarName<"<arg>">,
506 Flags<[DriverOption, CoreOption]>, Group<CompileOnly_Group>;
507 def Xcuda_fatbinary : Separate<["-"], "Xcuda-fatbinary">,
508 HelpText<"Pass <arg> to fatbinary invocation">, MetaVarName<"<arg>">;
509 def Xcuda_ptxas : Separate<["-"], "Xcuda-ptxas">,
510 HelpText<"Pass <arg> to the ptxas assembler">, MetaVarName<"<arg>">;
511 def Xopenmp_target : Separate<["-"], "Xopenmp-target">,
512 HelpText<"Pass <arg> to the target offloading toolchain.">, MetaVarName<"<arg>">;
513 def Xopenmp_target_EQ : JoinedAndSeparate<["-"], "Xopenmp-target=">,
514 HelpText<"Pass <arg> to the target offloading toolchain identified by <triple>.">,
515 MetaVarName<"<triple> <arg>">;
516 def z : Separate<["-"], "z">, Flags<[LinkerInput, RenderAsInput]>,
517 HelpText<"Pass -z <arg> to the linker">, MetaVarName<"<arg>">,
519 def Xlinker : Separate<["-"], "Xlinker">, Flags<[LinkerInput, RenderAsInput]>,
520 HelpText<"Pass <arg> to the linker">, MetaVarName<"<arg>">,
522 def Xpreprocessor : Separate<["-"], "Xpreprocessor">, Group<Preprocessor_Group>,
523 HelpText<"Pass <arg> to the preprocessor">, MetaVarName<"<arg>">;
524 def X_Flag : Flag<["-"], "X">, Group<Link_Group>;
525 def X_Joined : Joined<["-"], "X">, IgnoredGCCCompat;
526 def Z_Flag : Flag<["-"], "Z">, Group<Link_Group>;
527 // FIXME: All we do with this is reject it. Remove.
528 def Z_Joined : Joined<["-"], "Z">;
529 def all__load : Flag<["-"], "all_load">;
530 def allowable__client : Separate<["-"], "allowable_client">;
531 def ansi : Flag<["-", "--"], "ansi">;
532 def arch__errors__fatal : Flag<["-"], "arch_errors_fatal">;
533 def arch : Separate<["-"], "arch">, Flags<[DriverOption]>;
534 def arch__only : Separate<["-"], "arch_only">;
535 def a : Joined<["-"], "a">;
536 def autocomplete : Joined<["--"], "autocomplete=">;
537 def bind__at__load : Flag<["-"], "bind_at_load">;
538 def bundle__loader : Separate<["-"], "bundle_loader">;
539 def bundle : Flag<["-"], "bundle">;
540 def b : JoinedOrSeparate<["-"], "b">, Flags<[Unsupported]>;
541 def cl_opt_disable : Flag<["-"], "cl-opt-disable">, Group<opencl_Group>, Flags<[CC1Option]>,
542 HelpText<"OpenCL only. This option disables all optimizations. By default optimizations are enabled.">;
543 def cl_strict_aliasing : Flag<["-"], "cl-strict-aliasing">, Group<opencl_Group>, Flags<[CC1Option]>,
544 HelpText<"OpenCL only. This option is added for compatibility with OpenCL 1.0.">;
545 def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group<opencl_Group>, Flags<[CC1Option]>,
546 HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">;
547 def cl_finite_math_only : Flag<["-"], "cl-finite-math-only">, Group<opencl_Group>, Flags<[CC1Option]>,
548 HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">;
549 def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_Group>, Flags<[CC1Option]>,
550 HelpText<"OpenCL only. Generate kernel argument metadata.">;
551 def cl_unsafe_math_optimizations : Flag<["-"], "cl-unsafe-math-optimizations">, Group<opencl_Group>, Flags<[CC1Option]>,
552 HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.">;
553 def cl_fast_relaxed_math : Flag<["-"], "cl-fast-relaxed-math">, Group<opencl_Group>, Flags<[CC1Option]>,
554 HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.">;
555 def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC1Option]>,
556 HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">;
557 def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>,
558 HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">;
559 def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>,
560 HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,clc++,CLC++">;
561 def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>,
562 HelpText<"OpenCL only. Allow denormals to be flushed to zero.">;
563 def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
564 HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">;
565 def cl_uniform_work_group_size : Flag<["-"], "cl-uniform-work-group-size">, Group<opencl_Group>, Flags<[CC1Option]>,
566 HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">;
567 def client__name : JoinedOrSeparate<["-"], "client_name">;
568 def combine : Flag<["-", "--"], "combine">, Flags<[DriverOption, Unsupported]>;
569 def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
570 def config : Separate<["--"], "config">, Flags<[DriverOption]>,
571 HelpText<"Specifies configuration file">;
572 def config_system_dir_EQ : Joined<["--"], "config-system-dir=">, Flags<[DriverOption, HelpHidden]>,
573 HelpText<"System directory for configuration files">;
574 def config_user_dir_EQ : Joined<["--"], "config-user-dir=">, Flags<[DriverOption, HelpHidden]>,
575 HelpText<"User directory for configuration files">;
576 def coverage : Flag<["-", "--"], "coverage">, Flags<[CoreOption]>;
577 def cpp_precomp : Flag<["-"], "cpp-precomp">, Group<clang_ignored_f_Group>;
578 def current__version : JoinedOrSeparate<["-"], "current_version">;
579 def cxx_isystem : JoinedOrSeparate<["-"], "cxx-isystem">, Group<clang_i_Group>,
580 HelpText<"Add directory to the C++ SYSTEM include search path">, Flags<[CC1Option]>,
581 MetaVarName<"<directory>">;
582 def c : Flag<["-"], "c">, Flags<[DriverOption]>, Group<Action_Group>,
583 HelpText<"Only run preprocess, compile, and assemble steps">;
584 def fconvergent_functions : Flag<["-"], "fconvergent-functions">, Group<f_Group>, Flags<[CC1Option]>,
585 HelpText<"Assume functions may be convergent">;
587 def gpu_use_aux_triple_only : Flag<["--"], "gpu-use-aux-triple-only">,
588 InternalDriverOpt, HelpText<"Prepare '-aux-triple' only without populating "
589 "'-aux-target-cpu' and '-aux-target-feature'.">;
590 def cuda_device_only : Flag<["--"], "cuda-device-only">,
591 HelpText<"Compile CUDA code for device only">;
592 def cuda_host_only : Flag<["--"], "cuda-host-only">,
593 HelpText<"Compile CUDA code for host only. Has no effect on non-CUDA "
595 def cuda_compile_host_device : Flag<["--"], "cuda-compile-host-device">,
596 HelpText<"Compile CUDA code for both host and device (default). Has no "
597 "effect on non-CUDA compilations.">;
598 def cuda_include_ptx_EQ : Joined<["--"], "cuda-include-ptx=">, Flags<[DriverOption]>,
599 HelpText<"Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.">;
600 def no_cuda_include_ptx_EQ : Joined<["--"], "no-cuda-include-ptx=">, Flags<[DriverOption]>,
601 HelpText<"Do not include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.">;
602 def offload_arch_EQ : Joined<["--"], "offload-arch=">, Flags<[DriverOption]>,
603 HelpText<"CUDA/HIP offloading device architecture (e.g. sm_35, gfx906). May be specified more than once.">;
604 def cuda_gpu_arch_EQ : Joined<["--"], "cuda-gpu-arch=">, Flags<[DriverOption]>,
605 Alias<offload_arch_EQ>;
606 def hip_link : Flag<["--"], "hip-link">,
607 HelpText<"Link clang-offload-bundler bundles for HIP">;
608 def no_offload_arch_EQ : Joined<["--"], "no-offload-arch=">, Flags<[DriverOption]>,
609 HelpText<"Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. "
610 "'all' resets the list to its default value.">;
611 def emit_static_lib : Flag<["--"], "emit-static-lib">,
612 HelpText<"Enable linker job to emit a static library.">;
613 def no_cuda_gpu_arch_EQ : Joined<["--"], "no-cuda-gpu-arch=">, Flags<[DriverOption]>,
614 Alias<no_offload_arch_EQ>;
615 def cuda_noopt_device_debug : Flag<["--"], "cuda-noopt-device-debug">,
616 HelpText<"Enable device-side debug info generation. Disables ptxas optimizations.">;
617 def no_cuda_version_check : Flag<["--"], "no-cuda-version-check">,
618 HelpText<"Don't error out if the detected version of the CUDA install is "
619 "too low for the requested CUDA gpu architecture.">;
620 def no_cuda_noopt_device_debug : Flag<["--"], "no-cuda-noopt-device-debug">;
621 def cuda_path_EQ : Joined<["--"], "cuda-path=">, Group<i_Group>,
622 HelpText<"CUDA installation path">;
623 def cuda_path_ignore_env : Flag<["--"], "cuda-path-ignore-env">, Group<i_Group>,
624 HelpText<"Ignore environment variables to detect CUDA installation">;
625 def ptxas_path_EQ : Joined<["--"], "ptxas-path=">, Group<i_Group>,
626 HelpText<"Path to ptxas (used for compiling CUDA code)">;
627 def fcuda_flush_denormals_to_zero : Flag<["-"], "fcuda-flush-denormals-to-zero">,
628 HelpText<"Flush denormal floating point values to zero in CUDA device mode.">;
629 def fno_cuda_flush_denormals_to_zero : Flag<["-"], "fno-cuda-flush-denormals-to-zero">;
630 defm cuda_approx_transcendentals : OptInFFlag<"cuda-approx-transcendentals", "Use", "Don't use",
631 " approximate transcendental functions">;
632 defm gpu_rdc : OptInFFlag<"gpu-rdc",
633 "Generate relocatable device code, also known as separate compilation mode", "", "">;
634 def : Flag<["-"], "fcuda-rdc">, Alias<fgpu_rdc>;
635 def : Flag<["-"], "fno-cuda-rdc">, Alias<fno_gpu_rdc>;
636 defm cuda_short_ptr : OptInFFlag<"cuda-short-ptr",
637 "Use 32-bit pointers for accessing const/local/shared address spaces">;
638 def rocm_path_EQ : Joined<["--"], "rocm-path=">, Group<i_Group>,
639 HelpText<"ROCm installation path, used for finding and automatically linking required bitcode libraries.">;
640 def rocm_device_lib_path_EQ : Joined<["--"], "rocm-device-lib-path=">, Group<Link_Group>,
641 HelpText<"ROCm device library path. Alternative to rocm-path.">;
642 def : Joined<["--"], "hip-device-lib-path=">, Alias<rocm_device_lib_path_EQ>;
643 def hip_device_lib_EQ : Joined<["--"], "hip-device-lib=">, Group<Link_Group>,
644 HelpText<"HIP device library">;
645 def hip_version_EQ : Joined<["--"], "hip-version=">,
646 HelpText<"HIP version in the format of major.minor.patch">;
647 def fhip_dump_offload_linker_script : Flag<["-"], "fhip-dump-offload-linker-script">,
648 Group<f_Group>, Flags<[NoArgumentUnused, HelpHidden]>;
649 defm hip_new_launch_api : OptInFFlag<"hip-new-launch-api",
650 "Use", "Don't use", " new kernel launching API for HIP">;
651 defm gpu_allow_device_init : OptInFFlag<"gpu-allow-device-init",
652 "Allow", "Don't allow", " device side init function in HIP">;
653 def gpu_max_threads_per_block_EQ : Joined<["--"], "gpu-max-threads-per-block=">,
655 HelpText<"Default max threads per block for kernel launch bounds for HIP">;
656 def libomptarget_nvptx_path_EQ : Joined<["--"], "libomptarget-nvptx-path=">, Group<i_Group>,
657 HelpText<"Path to libomptarget-nvptx libraries">;
658 def dD : Flag<["-"], "dD">, Group<d_Group>, Flags<[CC1Option]>,
659 HelpText<"Print macro definitions in -E mode in addition to normal output">;
660 def dI : Flag<["-"], "dI">, Group<d_Group>, Flags<[CC1Option]>,
661 HelpText<"Print include directives in -E mode in addition to normal output">;
662 def dM : Flag<["-"], "dM">, Group<d_Group>, Flags<[CC1Option]>,
663 HelpText<"Print macro definitions in -E mode instead of normal output">;
664 def dead__strip : Flag<["-"], "dead_strip">;
665 def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>,
666 HelpText<"Filename (or -) to write dependency output to">;
667 def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
668 HelpText<"Filename to write DOT-formatted header dependencies to">;
669 def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
670 Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
671 def dumpmachine : Flag<["-"], "dumpmachine">;
672 def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
673 def dumpversion : Flag<["-"], "dumpversion">;
674 def dylib__file : Separate<["-"], "dylib_file">;
675 def dylinker__install__name : JoinedOrSeparate<["-"], "dylinker_install_name">;
676 def dylinker : Flag<["-"], "dylinker">;
677 def dynamiclib : Flag<["-"], "dynamiclib">;
678 def dynamic : Flag<["-"], "dynamic">, Flags<[NoArgumentUnused]>;
679 def d_Flag : Flag<["-"], "d">, Group<d_Group>;
680 def d_Joined : Joined<["-"], "d">, Group<d_Group>;
681 def emit_ast : Flag<["-"], "emit-ast">,
682 HelpText<"Emit Clang AST files for source inputs">;
683 def emit_llvm : Flag<["-"], "emit-llvm">, Flags<[CC1Option]>, Group<Action_Group>,
684 HelpText<"Use the LLVM representation for assembler and object files">;
685 def emit_interface_stubs : Flag<["-"], "emit-interface-stubs">, Flags<[CC1Option]>, Group<Action_Group>,
686 HelpText<"Generate Inteface Stub Files.">;
687 def emit_merged_ifs : Flag<["-"], "emit-merged-ifs">,
688 Flags<[CC1Option]>, Group<Action_Group>,
689 HelpText<"Generate Interface Stub Files, emit merged text not binary.">;
690 def interface_stub_version_EQ : JoinedOrSeparate<["-"], "interface-stub-version=">, Flags<[CC1Option]>;
691 def exported__symbols__list : Separate<["-"], "exported_symbols_list">;
692 def e : JoinedOrSeparate<["-"], "e">, Group<Link_Group>;
693 def fmax_tokens_EQ : Joined<["-"], "fmax-tokens=">, Group<f_Group>, Flags<[CC1Option]>,
694 HelpText<"Max total number of preprocessed tokens for -Wmax-tokens.">;
695 def fPIC : Flag<["-"], "fPIC">, Group<f_Group>;
696 def fno_PIC : Flag<["-"], "fno-PIC">, Group<f_Group>;
697 def fPIE : Flag<["-"], "fPIE">, Group<f_Group>;
698 def fno_PIE : Flag<["-"], "fno-PIE">, Group<f_Group>;
699 defm access_control : OptOutFFlag<"no-access-control", "", "Disable C++ access control">;
700 def falign_functions : Flag<["-"], "falign-functions">, Group<f_Group>;
701 def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<f_Group>;
702 def fno_align_functions: Flag<["-"], "fno-align-functions">, Group<f_Group>;
703 defm allow_editor_placeholders : OptInFFlag<"allow-editor-placeholders", "Treat editor placeholders as valid source code">;
704 def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>;
705 def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>,
706 HelpText<"Use Apple's kernel extensions ABI">;
707 def fapple_pragma_pack : Flag<["-"], "fapple-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>,
708 HelpText<"Enable Apple gcc-compatible #pragma pack handling">;
709 def shared_libsan : Flag<["-"], "shared-libsan">,
710 HelpText<"Dynamically link the sanitizer runtime">;
711 def static_libsan : Flag<["-"], "static-libsan">,
712 HelpText<"Statically link the sanitizer runtime">;
713 def : Flag<["-"], "shared-libasan">, Alias<shared_libsan>;
714 def fasm : Flag<["-"], "fasm">, Group<f_Group>;
716 defm asm_blocks : OptInFFlag<"asm-blocks", "">;
718 def fassume_sane_operator_new : Flag<["-"], "fassume-sane-operator-new">, Group<f_Group>;
719 def fastcp : Flag<["-"], "fastcp">, Group<f_Group>;
720 def fastf : Flag<["-"], "fastf">, Group<f_Group>;
721 def fast : Flag<["-"], "fast">, Group<f_Group>;
722 def fasynchronous_unwind_tables : Flag<["-"], "fasynchronous-unwind-tables">, Group<f_Group>;
724 def fdouble_square_bracket_attributes : Flag<[ "-" ], "fdouble-square-bracket-attributes">,
725 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
726 HelpText<"Enable '[[]]' attributes in all C and C++ language modes">;
727 def fno_double_square_bracket_attributes : Flag<[ "-" ], "fno-double-square-bracket-attributes">,
728 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
729 HelpText<"Disable '[[]]' attributes in all C and C++ language modes">;
731 defm autolink : OptOutFFlag<"autolink", "", "Disable generation of linker directives for automatic library linking">;
734 defm coroutines_ts : OptInFFlag<"coroutines-ts", "Enable support for the C++ Coroutines TS">;
736 def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
737 Group<f_Group>, Flags<[DriverOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">,
738 HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">;
739 def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>,
740 Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>,
741 HelpText<"Embed LLVM IR bitcode as data">;
742 def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">,
743 Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>,
744 HelpText<"Embed placeholder LLVM IR data as a marker">;
745 defm gnu_inline_asm : OptOutFFlag<"gnu-inline-asm", "", "Disable GNU style inline asm">;
747 def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>,
749 def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Group>,
751 def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">,
752 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
753 HelpText<"Enable sample-based profile guided optimizations">;
754 def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">,
755 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
756 HelpText<"Specifies that the sample profile is accurate">,
757 DocBrief<[{Specifies that the sample profile is accurate. If the sample
758 profile is accurate, callsites without profile samples are marked
759 as cold. Otherwise, treat callsites without profile samples as if
760 we have no profile}]>;
761 def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">,
762 Group<f_Group>, Flags<[DriverOption]>;
763 def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>,
764 Alias<fprofile_sample_use>;
765 def fno_auto_profile : Flag<["-"], "fno-auto-profile">, Group<f_Group>,
766 Alias<fno_profile_sample_use>;
767 def fauto_profile_EQ : Joined<["-"], "fauto-profile=">,
768 Alias<fprofile_sample_use_EQ>;
769 def fauto_profile_accurate : Flag<["-"], "fauto-profile-accurate">,
770 Group<f_Group>, Alias<fprofile_sample_accurate>;
771 def fno_auto_profile_accurate : Flag<["-"], "fno-auto-profile-accurate">,
772 Group<f_Group>, Alias<fno_profile_sample_accurate>;
773 def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">,
774 Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
775 HelpText<"The compilation directory to embed in the debug info.">;
776 def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">,
777 Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
778 Alias<fdebug_compilation_dir>;
779 defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling",
780 "Emit extra debug info to make sample profile more accurate">;
781 def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">,
782 Group<f_Group>, Flags<[CoreOption]>,
783 HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
784 def fprofile_instr_generate_EQ : Joined<["-"], "fprofile-instr-generate=">,
785 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<file>">,
786 HelpText<"Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)">;
787 def fprofile_instr_use : Flag<["-"], "fprofile-instr-use">, Group<f_Group>,
789 def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">,
790 Group<f_Group>, Flags<[CoreOption]>,
791 HelpText<"Use instrumentation data for profile-guided optimization">;
792 def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">,
793 Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">,
794 HelpText<"Use the remappings described in <file> to match the profile data against names in the program">;
795 def fprofile_remapping_file : Separate<["-"], "fprofile-remapping-file">,
796 Group<f_Group>, Flags<[CoreOption]>, Alias<fprofile_remapping_file_EQ>;
797 defm coverage_mapping : OptInFFlag<"coverage-mapping",
798 "Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "",
800 def fprofile_generate : Flag<["-"], "fprofile-generate">,
801 Group<f_Group>, Flags<[CoreOption]>,
802 HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
803 def fprofile_generate_EQ : Joined<["-"], "fprofile-generate=">,
804 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">,
805 HelpText<"Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
806 def fcs_profile_generate : Flag<["-"], "fcs-profile-generate">,
807 Group<f_Group>, Flags<[CoreOption]>,
808 HelpText<"Generate instrumented code to collect context sensitive execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
809 def fcs_profile_generate_EQ : Joined<["-"], "fcs-profile-generate=">,
810 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">,
811 HelpText<"Generate instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
812 def fprofile_use : Flag<["-"], "fprofile-use">, Group<f_Group>,
813 Alias<fprofile_instr_use>;
814 def fprofile_use_EQ : Joined<["-"], "fprofile-use=">,
815 Group<f_Group>, Flags<[DriverOption]>, MetaVarName<"<pathname>">,
816 HelpText<"Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.">;
817 def fno_profile_instr_generate : Flag<["-"], "fno-profile-instr-generate">,
818 Group<f_Group>, Flags<[CoreOption]>,
819 HelpText<"Disable generation of profile instrumentation.">;
820 def fno_profile_generate : Flag<["-"], "fno-profile-generate">,
821 Group<f_Group>, Flags<[CoreOption]>,
822 HelpText<"Disable generation of profile instrumentation.">;
823 def fno_profile_instr_use : Flag<["-"], "fno-profile-instr-use">,
824 Group<f_Group>, Flags<[CoreOption]>,
825 HelpText<"Disable using instrumentation data for profile-guided optimization">;
826 def fno_profile_use : Flag<["-"], "fno-profile-use">,
827 Alias<fno_profile_instr_use>;
828 def fprofile_filter_files_EQ : Joined<["-"], "fprofile-filter-files=">,
829 Group<f_Group>, Flags<[CC1Option, CoreOption]>,
830 HelpText<"Instrument only functions from files where names match any regex separated by a semi-colon">;
831 def fprofile_exclude_files_EQ : Joined<["-"], "fprofile-exclude-files=">,
832 Group<f_Group>, Flags<[CC1Option, CoreOption]>,
833 HelpText<"Instrument only functions from files where names don't match all the regexes separated by a semi-colon">;
834 def forder_file_instrumentation : Flag<["-"], "forder-file-instrumentation">,
835 Group<f_Group>, Flags<[CC1Option, CoreOption]>,
836 HelpText<"Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
838 defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption]>;
839 defm blocks : OptInFFlag<"blocks", "Enable the 'blocks' language feature", "", "", [CoreOption]>;
840 def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>;
841 def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>,
842 HelpText<"Accept non-standard constructs supported by the Borland compiler">;
843 def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>, Flags<[CoreOption]>;
844 def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>,
845 Flags<[DriverOption]>, HelpText<"Load the clang builtins module map file.">;
846 defm caret_diagnostics : OptOutFFlag<"caret-diagnostics", "", "">;
847 def fclang_abi_compat_EQ : Joined<["-"], "fclang-abi-compat=">, Group<f_clang_Group>,
848 Flags<[CC1Option]>, MetaVarName<"<version>">, Values<"<major>.<minor>,latest">,
849 HelpText<"Attempt to match the ABI of Clang <version>">;
850 def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>;
851 defm color_diagnostics : OptInFFlag<"color-diagnostics", "Enable", "Disable", " colors in diagnostics", [CoreOption]>;
852 def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>,
853 Flags<[CoreOption, DriverOption]>;
854 def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
855 def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>,
856 Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">,
857 MarshallingInfoFlag<"DiagnosticOpts->UseANSIEscapeCodes", "false">;
858 def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
859 HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,
860 MetaVarName<"<arg>">;
861 def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group<f_clang_Group>, Flags<[CC1Option]>;
862 def frecord_command_line : Flag<["-"], "frecord-command-line">,
863 Group<f_clang_Group>;
864 def fno_record_command_line : Flag<["-"], "fno-record-command-line">,
865 Group<f_clang_Group>;
866 def : Flag<["-"], "frecord-gcc-switches">, Alias<frecord_command_line>;
867 def : Flag<["-"], "fno-record-gcc-switches">, Alias<fno_record_command_line>;
868 def fcommon : Flag<["-"], "fcommon">, Group<f_Group>,
869 Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">;
870 def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>;
871 def fcomplete_member_pointers : Flag<["-"], "fcomplete-member-pointers">, Group<f_clang_Group>,
872 Flags<[CoreOption, CC1Option]>,
873 HelpText<"Require member pointer base types to be complete if they would be significant under the Microsoft ABI">;
874 def fno_complete_member_pointers : Flag<["-"], "fno-complete-member-pointers">, Group<f_clang_Group>,
876 HelpText<"Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI">;
877 def fcf_runtime_abi_EQ : Joined<["-"], "fcf-runtime-abi=">, Group<f_Group>,
879 def fconstant_cfstrings : Flag<["-"], "fconstant-cfstrings">, Group<f_Group>;
880 def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>;
881 def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>;
882 def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>;
883 def fexperimental_new_constant_interpreter : Flag<["-"], "fexperimental-new-constant-interpreter">, Group<f_Group>,
884 HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>;
885 def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">,
887 def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>,
888 HelpText<"Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash">;
889 def fcrash_diagnostics_dir : Joined<["-"], "fcrash-diagnostics-dir=">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>;
890 def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>;
891 defm cxx_exceptions: OptInFFlag<"cxx-exceptions", "Enable C++ exceptions">;
892 def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>,
893 Flags<[DriverOption]>;
894 def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>;
895 def fdebug_pass_structure : Flag<["-"], "fdebug-pass-structure">, Group<f_Group>;
896 def fdepfile_entry : Joined<["-"], "fdepfile-entry=">,
897 Group<f_clang_Group>, Flags<[CC1Option]>;
898 def fdiagnostics_fixit_info : Flag<["-"], "fdiagnostics-fixit-info">, Group<f_clang_Group>;
899 def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group<f_clang_Group>,
900 Flags<[CoreOption, CC1Option]>, HelpText<"Print fix-its in machine parseable form">;
901 def fdiagnostics_print_source_range_info : Flag<["-"], "fdiagnostics-print-source-range-info">,
902 Group<f_clang_Group>, Flags<[CC1Option]>,
903 HelpText<"Print source range spans in numeric form">;
904 def fdiagnostics_show_hotness : Flag<["-"], "fdiagnostics-show-hotness">, Group<f_Group>,
905 Flags<[CC1Option]>, HelpText<"Enable profile hotness information in diagnostic line">;
906 def fdiagnostics_hotness_threshold_EQ : Joined<["-"], "fdiagnostics-hotness-threshold=">,
907 Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<number>">,
908 HelpText<"Prevent optimization remarks from being output if they do not have at least this profile count">;
909 def fdiagnostics_show_option : Flag<["-"], "fdiagnostics-show-option">, Group<f_Group>,
910 HelpText<"Print option name with mappable diagnostics">;
911 def fdiagnostics_show_note_include_stack : Flag<["-"], "fdiagnostics-show-note-include-stack">,
912 Group<f_Group>, Flags<[CC1Option]>, HelpText<"Display include stacks for diagnostic notes">;
913 def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>;
914 def fdiagnostics_show_category_EQ : Joined<["-"], "fdiagnostics-show-category=">, Group<f_clang_Group>;
915 def fdiagnostics_show_template_tree : Flag<["-"], "fdiagnostics-show-template-tree">,
916 Group<f_Group>, Flags<[CC1Option]>,
917 HelpText<"Print a template comparison tree for differing templates">;
918 def fdeclspec : Flag<["-"], "fdeclspec">, Group<f_clang_Group>,
919 HelpText<"Allow __declspec as a keyword">, Flags<[CC1Option]>;
920 def fdiscard_value_names : Flag<["-"], "fdiscard-value-names">, Group<f_clang_Group>,
921 HelpText<"Discard value names in LLVM IR">, Flags<[DriverOption]>;
922 def fno_discard_value_names : Flag<["-"], "fno-discard-value-names">, Group<f_clang_Group>,
923 HelpText<"Do not discard value names in LLVM IR">, Flags<[DriverOption]>;
924 def fdollars_in_identifiers : Flag<["-"], "fdollars-in-identifiers">, Group<f_Group>,
925 HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;
926 def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
927 def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
928 defm dwarf_directory_asm : OptOutFFlag<"dwarf-directory-asm", "", "">;
929 def felide_constructors : Flag<["-"], "felide-constructors">, Group<f_Group>;
930 def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>,
932 HelpText<"Do not elide types when printing diagnostics">;
933 def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>;
934 def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
935 HelpText<"Emit all declarations, even if unused">;
936 def femulated_tls : Flag<["-"], "femulated-tls">, Group<f_Group>, Flags<[CC1Option]>,
937 HelpText<"Use emutls functions to access thread_local variables">;
938 def fno_emulated_tls : Flag<["-"], "fno-emulated-tls">, Group<f_Group>, Flags<[CC1Option]>;
939 def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
940 def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
941 defm exceptions : OptInFFlag<"exceptions", "Enable", "Disable", " support for exception handling">;
942 def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>,
943 Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">;
944 def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>,
945 Flags<[CC1Option]>, HelpText<"Use SjLj style exceptions">;
946 def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group<f_Group>,
947 Flags<[CC1Option]>, HelpText<"Use SEH style exceptions">;
948 def fwasm_exceptions : Flag<["-"], "fwasm-exceptions">, Group<f_Group>,
949 Flags<[CC1Option]>, HelpText<"Use WebAssembly style exceptions">;
950 def fignore_exceptions : Flag<["-"], "fignore-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
951 HelpText<"Enable support for ignoring exception handling constructs">;
952 def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">,
953 Group<clang_ignored_gcc_optimization_f_Group>;
954 def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
955 def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
956 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
957 def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
958 def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
959 def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
960 def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
961 def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
962 def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group<f_Group>, Flags<[CC1Option]>;
963 def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[DriverOption]>,
964 HelpText<"Controls the semantics of floating-point calculations.">;
965 def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>, Flags<[CC1Option]>,
966 HelpText<"Specifies the exception behavior of floating-point operations.">;
967 defm fast_math : OptInFFlag<"fast-math", "Allow aggressive, lossy floating-point optimizations">;
968 defm math_errno : OptInFFlag<"math-errno", "Require math functions to indicate errors by setting errno">;
969 def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>, Flags<[CoreOption]>;
970 def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>;
971 def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>;
972 defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches">;
973 defm force_enable_int128 : OptInFFlag<"force-enable-int128", "Enable", "Disable", " support for int128_t type">;
974 defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused", [DriverOption]>;
975 defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">;
976 defm cxx_static_destructors : OptOutFFlag<"c++-static-destructors", "",
977 "Disable C++ static destructor registration">;
978 def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>,
981 // Begin sanitizer flags. These should all be core options exposed in all driver
983 let Flags = [CC1Option, CoreOption] in {
985 def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>,
986 MetaVarName<"<check>">,
987 HelpText<"Turn on runtime checks for various forms of undefined "
988 "or suspicious behavior. See user manual for available checks">;
989 def fno_sanitize_EQ : CommaJoined<["-"], "fno-sanitize=">, Group<f_clang_Group>,
990 Flags<[CoreOption, DriverOption]>;
991 def fsanitize_blacklist : Joined<["-"], "fsanitize-blacklist=">,
992 Group<f_clang_Group>,
993 HelpText<"Path to blacklist file for sanitizers">;
994 def fsanitize_system_blacklist : Joined<["-"], "fsanitize-system-blacklist=">,
995 HelpText<"Path to system blacklist file for sanitizers">,
997 def fno_sanitize_blacklist : Flag<["-"], "fno-sanitize-blacklist">,
998 Group<f_clang_Group>,
999 HelpText<"Don't use blacklist file for sanitizers">;
1000 def fsanitize_coverage
1001 : CommaJoined<["-"], "fsanitize-coverage=">,
1002 Group<f_clang_Group>,
1003 HelpText<"Specify the type of coverage instrumentation for Sanitizers">;
1004 def fno_sanitize_coverage
1005 : CommaJoined<["-"], "fno-sanitize-coverage=">,
1006 Group<f_clang_Group>, Flags<[CoreOption, DriverOption]>,
1007 HelpText<"Disable specified features of coverage instrumentation for "
1008 "Sanitizers">, Values<"func,bb,edge,indirect-calls,trace-bb,trace-cmp,trace-div,trace-gep,8bit-counters,trace-pc,trace-pc-guard,no-prune,inline-8bit-counters,inline-bool-flag">;
1009 def fsanitize_coverage_allowlist : Joined<["-"], "fsanitize-coverage-allowlist=">,
1010 Group<f_clang_Group>, Flags<[CoreOption, DriverOption]>,
1011 HelpText<"Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones">;
1012 def : Joined<["-"], "fsanitize-coverage-whitelist=">,
1013 Group<f_clang_Group>, Flags<[CoreOption, HelpHidden]>, Alias<fsanitize_coverage_allowlist>,
1014 HelpText<"Deprecated, use -fsanitize-coverage-allowlist= instead">;
1015 def fsanitize_coverage_blocklist : Joined<["-"], "fsanitize-coverage-blocklist=">,
1016 Group<f_clang_Group>, Flags<[CoreOption, DriverOption]>,
1017 HelpText<"Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones">;
1018 def : Joined<["-"], "fsanitize-coverage-blacklist=">,
1019 Group<f_clang_Group>, Flags<[CoreOption, HelpHidden]>, Alias<fsanitize_coverage_blocklist>,
1020 HelpText<"Deprecated, use -fsanitize-coverage-blocklist= instead">;
1021 def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">,
1022 Group<f_clang_Group>,
1023 HelpText<"Enable origins tracking in MemorySanitizer">;
1024 def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">,
1025 Group<f_clang_Group>,
1026 HelpText<"Enable origins tracking in MemorySanitizer">;
1027 def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">,
1028 Group<f_clang_Group>,
1029 Flags<[CoreOption, DriverOption]>,
1030 HelpText<"Disable origins tracking in MemorySanitizer">;
1031 def fsanitize_memory_use_after_dtor : Flag<["-"], "fsanitize-memory-use-after-dtor">,
1032 Group<f_clang_Group>,
1033 HelpText<"Enable use-after-destroy detection in MemorySanitizer">;
1034 def fno_sanitize_memory_use_after_dtor : Flag<["-"], "fno-sanitize-memory-use-after-dtor">,
1035 Group<f_clang_Group>,
1036 HelpText<"Disable use-after-destroy detection in MemorySanitizer">;
1037 def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">,
1038 Group<f_clang_Group>,
1039 HelpText<"Level of field padding for AddressSanitizer">;
1040 def fsanitize_address_use_after_scope : Flag<["-"], "fsanitize-address-use-after-scope">,
1041 Group<f_clang_Group>,
1042 HelpText<"Enable use-after-scope detection in AddressSanitizer">;
1043 def fno_sanitize_address_use_after_scope : Flag<["-"], "fno-sanitize-address-use-after-scope">,
1044 Group<f_clang_Group>,
1045 Flags<[CoreOption, DriverOption]>,
1046 HelpText<"Disable use-after-scope detection in AddressSanitizer">;
1047 def fsanitize_address_poison_custom_array_cookie
1048 : Flag<[ "-" ], "fsanitize-address-poison-custom-array-cookie">,
1049 Group<f_clang_Group>,
1050 HelpText<"Enable poisoning array cookies when using custom operator new[] in AddressSanitizer">;
1051 def fno_sanitize_address_poison_custom_array_cookie
1052 : Flag<[ "-" ], "fno-sanitize-address-poison-custom-array-cookie">,
1053 Group<f_clang_Group>,
1054 HelpText<"Disable poisoning array cookies when using custom operator new[] in AddressSanitizer">;
1055 def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">,
1056 Group<f_clang_Group>,
1057 HelpText<"Enable linker dead stripping of globals in AddressSanitizer">;
1058 def fsanitize_address_use_odr_indicator
1059 : Flag<["-"], "fsanitize-address-use-odr-indicator">,
1060 Group<f_clang_Group>,
1061 HelpText<"Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size">;
1062 def fno_sanitize_address_use_odr_indicator
1063 : Flag<["-"], "fno-sanitize-address-use-odr-indicator">,
1064 Group<f_clang_Group>,
1065 HelpText<"Disable ODR indicator globals">;
1066 // Note: This flag was introduced when it was necessary to distinguish between
1067 // ABI for correct codegen. This is no longer needed, but the flag is
1068 // not removed since targeting either ABI will behave the same.
1069 // This way we cause no disturbance to existing scripts & code, and if we
1070 // want to use this flag in the future we will cause no disturbance then
1072 def fsanitize_hwaddress_abi_EQ
1073 : Joined<["-"], "fsanitize-hwaddress-abi=">,
1074 Group<f_clang_Group>,
1075 HelpText<"Select the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor). This option is currently unused.">;
1076 def fsanitize_recover_EQ : CommaJoined<["-"], "fsanitize-recover=">,
1077 Group<f_clang_Group>,
1078 HelpText<"Enable recovery for specified sanitizers">;
1079 def fno_sanitize_recover_EQ : CommaJoined<["-"], "fno-sanitize-recover=">,
1080 Group<f_clang_Group>, Flags<[CoreOption, DriverOption]>,
1081 HelpText<"Disable recovery for specified sanitizers">;
1082 def fsanitize_recover : Flag<["-"], "fsanitize-recover">, Group<f_clang_Group>,
1083 Alias<fsanitize_recover_EQ>, AliasArgs<["all"]>;
1084 def fno_sanitize_recover : Flag<["-"], "fno-sanitize-recover">,
1085 Flags<[CoreOption, DriverOption]>, Group<f_clang_Group>,
1086 Alias<fno_sanitize_recover_EQ>, AliasArgs<["all"]>;
1087 def fsanitize_trap_EQ : CommaJoined<["-"], "fsanitize-trap=">, Group<f_clang_Group>,
1088 HelpText<"Enable trapping for specified sanitizers">;
1089 def fno_sanitize_trap_EQ : CommaJoined<["-"], "fno-sanitize-trap=">, Group<f_clang_Group>,
1090 Flags<[CoreOption, DriverOption]>,
1091 HelpText<"Disable trapping for specified sanitizers">;
1092 def fsanitize_trap : Flag<["-"], "fsanitize-trap">, Group<f_clang_Group>,
1093 Alias<fsanitize_trap_EQ>, AliasArgs<["all"]>,
1094 HelpText<"Enable trapping for all sanitizers">;
1095 def fno_sanitize_trap : Flag<["-"], "fno-sanitize-trap">, Group<f_clang_Group>,
1096 Alias<fno_sanitize_trap_EQ>, AliasArgs<["all"]>,
1097 Flags<[CoreOption, DriverOption]>,
1098 HelpText<"Disable trapping for all sanitizers">;
1099 def fsanitize_undefined_trap_on_error
1100 : Flag<["-"], "fsanitize-undefined-trap-on-error">, Group<f_clang_Group>,
1101 Alias<fsanitize_trap_EQ>, AliasArgs<["undefined"]>;
1102 def fno_sanitize_undefined_trap_on_error
1103 : Flag<["-"], "fno-sanitize-undefined-trap-on-error">, Group<f_clang_Group>,
1104 Alias<fno_sanitize_trap_EQ>, AliasArgs<["undefined"]>;
1105 def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">,
1106 Group<f_clang_Group>;
1107 def fno_sanitize_minimal_runtime : Flag<["-"], "fno-sanitize-minimal-runtime">,
1108 Group<f_clang_Group>;
1109 def fsanitize_link_runtime : Flag<["-"], "fsanitize-link-runtime">,
1110 Group<f_clang_Group>;
1111 def fno_sanitize_link_runtime : Flag<["-"], "fno-sanitize-link-runtime">,
1112 Group<f_clang_Group>;
1113 def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">,
1114 Group<f_clang_Group>;
1115 def fno_sanitize_link_cxx_runtime : Flag<["-"], "fno-sanitize-link-c++-runtime">,
1116 Group<f_clang_Group>;
1117 def fsanitize_cfi_cross_dso : Flag<["-"], "fsanitize-cfi-cross-dso">,
1118 Group<f_clang_Group>,
1119 HelpText<"Enable control flow integrity (CFI) checks for cross-DSO calls.">;
1120 def fno_sanitize_cfi_cross_dso : Flag<["-"], "fno-sanitize-cfi-cross-dso">,
1121 Flags<[CoreOption, DriverOption]>,
1122 Group<f_clang_Group>,
1123 HelpText<"Disable control flow integrity (CFI) checks for cross-DSO calls.">;
1124 def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">,
1125 Group<f_clang_Group>,
1126 HelpText<"Generalize pointers in CFI indirect call type signature checks">;
1127 def fsanitize_cfi_canonical_jump_tables : Flag<["-"], "fsanitize-cfi-canonical-jump-tables">,
1128 Group<f_clang_Group>,
1129 HelpText<"Make the jump table addresses canonical in the symbol table">;
1130 def fno_sanitize_cfi_canonical_jump_tables : Flag<["-"], "fno-sanitize-cfi-canonical-jump-tables">,
1131 Group<f_clang_Group>,
1132 Flags<[CoreOption, DriverOption]>,
1133 HelpText<"Do not make the jump table addresses canonical in the symbol table">;
1134 def fsanitize_stats : Flag<["-"], "fsanitize-stats">,
1135 Group<f_clang_Group>,
1136 HelpText<"Enable sanitizer statistics gathering.">;
1137 def fno_sanitize_stats : Flag<["-"], "fno-sanitize-stats">,
1138 Group<f_clang_Group>,
1139 Flags<[CoreOption, DriverOption]>,
1140 HelpText<"Disable sanitizer statistics gathering.">;
1141 def fsanitize_thread_memory_access : Flag<["-"], "fsanitize-thread-memory-access">,
1142 Group<f_clang_Group>,
1143 HelpText<"Enable memory access instrumentation in ThreadSanitizer (default)">;
1144 def fno_sanitize_thread_memory_access : Flag<["-"], "fno-sanitize-thread-memory-access">,
1145 Group<f_clang_Group>,
1146 Flags<[CoreOption, DriverOption]>,
1147 HelpText<"Disable memory access instrumentation in ThreadSanitizer">;
1148 def fsanitize_thread_func_entry_exit : Flag<["-"], "fsanitize-thread-func-entry-exit">,
1149 Group<f_clang_Group>,
1150 HelpText<"Enable function entry/exit instrumentation in ThreadSanitizer (default)">;
1151 def fno_sanitize_thread_func_entry_exit : Flag<["-"], "fno-sanitize-thread-func-entry-exit">,
1152 Group<f_clang_Group>,
1153 Flags<[CoreOption, DriverOption]>,
1154 HelpText<"Disable function entry/exit instrumentation in ThreadSanitizer">;
1155 def fsanitize_thread_atomics : Flag<["-"], "fsanitize-thread-atomics">,
1156 Group<f_clang_Group>,
1157 HelpText<"Enable atomic operations instrumentation in ThreadSanitizer (default)">;
1158 def fno_sanitize_thread_atomics : Flag<["-"], "fno-sanitize-thread-atomics">,
1159 Group<f_clang_Group>,
1160 Flags<[CoreOption, DriverOption]>,
1161 HelpText<"Disable atomic operations instrumentation in ThreadSanitizer">;
1162 def fsanitize_undefined_strip_path_components_EQ : Joined<["-"], "fsanitize-undefined-strip-path-components=">,
1163 Group<f_clang_Group>, MetaVarName<"<number>">,
1164 HelpText<"Strip (or keep only, if negative) a given number of path components "
1165 "when emitting check metadata.">;
1167 } // end -f[no-]sanitize* flags
1169 def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">,
1171 def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">,
1173 def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
1174 def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
1175 def freciprocal_math :
1176 Flag<["-"], "freciprocal-math">, Group<f_Group>, Flags<[CC1Option]>,
1177 HelpText<"Allow division operations to be reassociated">;
1178 def fno_reciprocal_math : Flag<["-"], "fno-reciprocal-math">, Group<f_Group>;
1179 def ffinite_math_only : Flag<["-"], "ffinite-math-only">, Group<f_Group>, Flags<[CC1Option]>;
1180 def fno_finite_math_only : Flag<["-"], "fno-finite-math-only">, Group<f_Group>;
1181 def fsigned_zeros : Flag<["-"], "fsigned-zeros">, Group<f_Group>;
1182 def fno_signed_zeros :
1183 Flag<["-"], "fno-signed-zeros">, Group<f_Group>, Flags<[CC1Option]>,
1184 HelpText<"Allow optimizations that ignore the sign of floating point zeros">;
1185 def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>;
1186 def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>;
1187 def fhonor_infinities : Flag<["-"], "fhonor-infinities">, Group<f_Group>;
1188 def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>;
1189 // This option was originally misspelt "infinites" [sic].
1190 def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
1191 def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
1192 def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>;
1193 def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>;
1194 def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>, Flags<[CC1Option]>;
1195 def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>, Flags<[CC1Option]>;
1196 def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>,
1197 Flags<[CC1Option]>, HelpText<"Form fused FP ops (e.g. FMAs): fast (everywhere)"
1198 " | on (according to FP_CONTRACT pragma) | off (never fuse). Default"
1199 " is 'fast' for CUDA/HIP and 'on' otherwise.">, Values<"fast,on,off">;
1201 defm strict_float_cast_overflow : OptOutFFlag<"strict-float-cast-overflow",
1202 "Assume that overflowing float-to-int casts are undefined (default)",
1203 "Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions">;
1205 def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>;
1206 def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>;
1208 defm rewrite_imports : OptInFFlag<"rewrite-imports", "">;
1209 defm rewrite_includes : OptInFFlag<"rewrite-includes", "">;
1211 defm delete_null_pointer_checks : OptOutFFlag<"delete-null-pointer-checks",
1212 "Treat usage of null pointers as undefined behavior (default)",
1213 "Do not treat usage of null pointers as undefined behavior">;
1215 def frewrite_map_file : Separate<["-"], "frewrite-map-file">,
1217 Flags<[ DriverOption, CC1Option ]>;
1218 def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">,
1220 Flags<[DriverOption]>;
1222 defm use_line_directives : OptInFFlag<"use-line-directives", "Use #line in preprocessed output">;
1224 def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>,
1225 HelpText<"Assert that the compilation takes place in a freestanding environment">;
1226 def fgnuc_version_EQ : Joined<["-"], "fgnuc-version=">, Group<f_Group>,
1227 HelpText<"Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)">,
1228 Flags<[CC1Option, CoreOption]>;
1229 def fgnu_keywords : Flag<["-"], "fgnu-keywords">, Group<f_Group>, Flags<[CC1Option]>,
1230 HelpText<"Allow GNU-extension keywords regardless of language standard">;
1231 defm gnu89_inline : OptInFFlag<"gnu89-inline", "Use the gnu89 inline semantics">;
1232 def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>,
1233 HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;
1234 def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>;
1235 def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>,
1237 def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>;
1238 def finline_functions : Flag<["-"], "finline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
1239 HelpText<"Inline suitable functions">;
1240 def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
1241 HelpText<"Inline functions which are (explicitly or implicitly) marked inline">;
1242 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
1243 def fglobal_isel : Flag<["-"], "fglobal-isel">, Group<f_clang_Group>,
1244 HelpText<"Enables the global instruction selector">;
1245 def fexperimental_isel : Flag<["-"], "fexperimental-isel">, Group<f_clang_Group>,
1246 Alias<fglobal_isel>;
1247 def fexperimental_new_pass_manager : Flag<["-"], "fexperimental-new-pass-manager">,
1248 Group<f_clang_Group>, Flags<[CC1Option]>,
1249 HelpText<"Enables an experimental new pass manager in LLVM.">;
1250 def fexperimental_strict_floating_point : Flag<["-"], "fexperimental-strict-floating-point">,
1251 Group<f_clang_Group>, Flags<[CC1Option]>,
1252 HelpText<"Enables experimental strict floating point in LLVM.">;
1253 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
1254 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
1255 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
1256 HelpText<"Generate calls to instrument function entry and exit">;
1257 def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>,
1258 HelpText<"Like -finstrument-functions, but insert the calls after inlining">;
1259 def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>,
1260 HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">;
1261 def fcf_protection_EQ : Joined<["-"], "fcf-protection=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1262 HelpText<"Instrument control-flow architecture protection. Options: return, branch, full, none.">, Values<"return,branch,full,none">;
1263 def fcf_protection : Flag<["-"], "fcf-protection">, Group<f_Group>, Flags<[CoreOption, CC1Option]>,
1264 Alias<fcf_protection_EQ>, AliasArgs<["full"]>,
1265 HelpText<"Enable cf-protection in 'full' mode">;
1267 defm xray_instrument : OptInFFlag<"xray-instrument", "Generate XRay instrumentation sleds on function entry and exit">;
1269 def fxray_instruction_threshold_EQ :
1270 JoinedOrSeparate<["-"], "fxray-instruction-threshold=">,
1271 Group<f_Group>, Flags<[CC1Option]>,
1272 HelpText<"Sets the minimum function size to instrument with XRay">;
1273 def fxray_instruction_threshold_ :
1274 JoinedOrSeparate<["-"], "fxray-instruction-threshold">,
1275 Group<f_Group>, Flags<[CC1Option]>;
1277 def fxray_always_instrument :
1278 JoinedOrSeparate<["-"], "fxray-always-instrument=">,
1279 Group<f_Group>, Flags<[CC1Option]>,
1280 HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">;
1281 def fxray_never_instrument :
1282 JoinedOrSeparate<["-"], "fxray-never-instrument=">,
1283 Group<f_Group>, Flags<[CC1Option]>,
1284 HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.">;
1285 def fxray_attr_list :
1286 JoinedOrSeparate<["-"], "fxray-attr-list=">,
1287 Group<f_Group>, Flags<[CC1Option]>,
1288 HelpText<"Filename defining the list of functions/types for imbuing XRay attributes.">;
1290 JoinedOrSeparate<["-"], "fxray-modes=">,
1291 Group<f_Group>, Flags<[CC1Option]>,
1292 HelpText<"List of modes to link in by default into XRay instrumented binaries.">;
1294 defm xray_always_emit_customevents : OptInFFlag<"xray-always-emit-customevents",
1295 "Always emit __xray_customevent(...) calls even if the containing function is not always instrumented">;
1297 defm xray_always_emit_typedevents : OptInFFlag<"xray-always-emit-typedevents",
1298 "Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented">;
1300 defm xray_ignore_loops : OptInFFlag<"xray-ignore-loops",
1301 "Don't instrument functions with loops unless they also meet the minimum function size">;
1302 defm xray_function_index : OptOutFFlag<"xray-function-index", "",
1303 "Omit function index section at the expense of single-function patching performance">;
1305 def fxray_link_deps : Flag<["-"], "fxray-link-deps">, Group<f_Group>,
1307 HelpText<"Tells clang to add the link dependencies for XRay.">;
1308 def fnoxray_link_deps : Flag<["-"], "fnoxray-link-deps">, Group<f_Group>,
1311 def fxray_instrumentation_bundle :
1312 JoinedOrSeparate<["-"], "fxray-instrumentation-bundle=">,
1313 Group<f_Group>, Flags<[CC1Option]>,
1314 HelpText<"Select which XRay instrumentation points to emit. Options: all, none, function-entry, function-exit, function, custom. Default is 'all'. 'function' includes both 'function-entry' and 'function-exit'.">;
1316 def ffine_grained_bitfield_accesses : Flag<["-"],
1317 "ffine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
1318 HelpText<"Use separate accesses for consecutive bitfield runs with legal widths and alignments.">;
1319 def fno_fine_grained_bitfield_accesses : Flag<["-"],
1320 "fno-fine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
1321 HelpText<"Use large-integer access for consecutive bitfield runs.">;
1323 def fexperimental_relative_cxx_abi_vtables : Flag<["-"], "fexperimental-relative-c++-abi-vtables">,
1324 Group<f_Group>, Flags<[CC1Option]>,
1325 HelpText<"Use the experimental C++ class ABI for classes with virtual tables">;
1326 def fno_experimental_relative_cxx_abi_vtables : Flag<["-"], "fno-experimental-relative-c++-abi-vtables">,
1327 Group<f_Group>, Flags<[CC1Option]>,
1328 HelpText<"Do not use the experimental C++ class ABI for classes with virtual tables">;
1330 def flat__namespace : Flag<["-"], "flat_namespace">;
1331 def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Group<f_Group>,
1332 HelpText<"Enable implicit vector bit-casts">, Values<"none,integer,all">, Flags<[CC1Option]>;
1333 def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>,
1334 Alias<flax_vector_conversions_EQ>, AliasArgs<["integer"]>;
1335 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
1336 def fapple_link_rtlib : Flag<["-"], "fapple-link-rtlib">, Group<f_Group>,
1337 HelpText<"Force linking the clang builtins runtime library">;
1338 def flto_EQ : Joined<["-"], "flto=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1339 HelpText<"Set LTO mode to either 'full' or 'thin'">, Values<"thin,full">;
1340 def flto : Flag<["-"], "flto">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1341 HelpText<"Enable LTO in 'full' mode">;
1342 def fno_lto : Flag<["-"], "fno-lto">, Group<f_Group>,
1343 HelpText<"Disable LTO mode (default)">;
1344 def flto_jobs_EQ : Joined<["-"], "flto-jobs=">,
1345 Flags<[CC1Option]>, Group<f_Group>,
1346 HelpText<"Controls the backend parallelism of -flto=thin (default "
1347 "of 0 means the number of threads will be derived from "
1348 "the number of CPUs detected)">;
1349 def fthinlto_index_EQ : Joined<["-"], "fthinlto-index=">,
1350 Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1351 HelpText<"Perform ThinLTO importing using provided function summary index">;
1352 def fthin_link_bitcode_EQ : Joined<["-"], "fthin-link-bitcode=">,
1353 Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1354 HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">;
1355 def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">,
1356 Group<f_Group>, Flags<[DriverOption, CoreOption]>;
1357 def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>,
1358 Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">;
1359 def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>,
1360 HelpText<"Format message diagnostics so that they fit within N columns">;
1361 def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1362 HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;
1363 def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1364 HelpText<"Enable full Microsoft Visual C++ compatibility">;
1365 def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>;
1366 def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[DriverOption, CoreOption]>,
1367 HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
1368 def fms_compatibility_version
1369 : Joined<["-"], "fms-compatibility-version=">,
1371 Flags<[ CC1Option, CoreOption ]>,
1372 HelpText<"Dot-separated value representing the Microsoft compiler "
1373 "version number to report in _MSC_VER (0 = don't define it "
1375 def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,
1376 HelpText<"Parse templated function definitions at the end of the "
1377 "translation unit">, Flags<[CC1Option, CoreOption]>;
1378 def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
1379 def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
1380 Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
1381 HelpText<"Specify the module cache path">;
1382 def fmodules_user_build_path : Separate<["-"], "fmodules-user-build-path">, Group<i_Group>,
1383 Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
1384 HelpText<"Specify the module user build path">;
1385 def fprebuilt_module_path : Joined<["-"], "fprebuilt-module-path=">, Group<i_Group>,
1386 Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
1387 HelpText<"Specify the prebuilt module path">;
1388 def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>,
1389 Flags<[CC1Option]>, MetaVarName<"<seconds>">,
1390 HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">;
1391 def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>,
1392 Flags<[CC1Option]>, MetaVarName<"<seconds>">,
1393 HelpText<"Specify the interval (in seconds) after which a module file will be considered unused">;
1394 def fmodules_search_all : Flag <["-"], "fmodules-search-all">, Group<f_Group>,
1395 Flags<[DriverOption, CC1Option]>,
1396 HelpText<"Search even non-imported modules to resolve references">;
1397 def fbuild_session_timestamp : Joined<["-"], "fbuild-session-timestamp=">,
1398 Group<i_Group>, Flags<[CC1Option]>, MetaVarName<"<time since Epoch in seconds>">,
1399 HelpText<"Time when the current build session started">;
1400 def fbuild_session_file : Joined<["-"], "fbuild-session-file=">,
1401 Group<i_Group>, MetaVarName<"<file>">,
1402 HelpText<"Use the last modification time of <file> as the build session timestamp">;
1403 def fmodules_validate_once_per_build_session : Flag<["-"], "fmodules-validate-once-per-build-session">,
1404 Group<i_Group>, Flags<[CC1Option]>,
1405 HelpText<"Don't verify input files for the modules if the module has been "
1406 "successfully validated or loaded during this build session">;
1407 def fmodules_disable_diagnostic_validation : Flag<["-"], "fmodules-disable-diagnostic-validation">,
1408 Group<i_Group>, Flags<[CC1Option]>,
1409 HelpText<"Disable validation of the diagnostic options when loading the module">;
1410 def fmodules_validate_system_headers : Flag<["-"], "fmodules-validate-system-headers">,
1411 Group<i_Group>, Flags<[CC1Option]>,
1412 HelpText<"Validate the system headers that a module depends on when loading the module">;
1413 def fno_modules_validate_system_headers : Flag<["-"], "fno-modules-validate-system-headers">,
1414 Group<i_Group>, Flags<[DriverOption]>;
1416 def fvalidate_ast_input_files_content:
1417 Flag <["-"], "fvalidate-ast-input-files-content">,
1418 Group<f_Group>, Flags<[CC1Option]>,
1419 HelpText<"Compute and store the hash of input files used to build an AST."
1420 " Files with mismatching mtime's are considered valid"
1421 " if both contents is identical">;
1422 def fmodules_validate_input_files_content:
1423 Flag <["-"], "fmodules-validate-input-files-content">,
1424 Group<f_Group>, Flags<[DriverOption]>,
1425 HelpText<"Validate PCM input files based on content if mtime differs">;
1426 def fno_modules_validate_input_files_content:
1427 Flag <["-"], "fno_modules-validate-input-files-content">,
1428 Group<f_Group>, Flags<[DriverOption]>;
1429 def fpch_validate_input_files_content:
1430 Flag <["-"], "fpch-validate-input-files-content">,
1431 Group<f_Group>, Flags<[DriverOption]>,
1432 HelpText<"Validate PCH input files based on content if mtime differs">;
1433 def fno_pch_validate_input_files_content:
1434 Flag <["-"], "fno_pch-validate-input-files-content">,
1435 Group<f_Group>, Flags<[DriverOption]>;
1436 def fpch_instantiate_templates:
1437 Flag <["-"], "fpch-instantiate-templates">,
1438 Group<f_Group>, Flags<[CC1Option]>,
1439 HelpText<"Instantiate templates already while building a PCH">;
1440 def fno_pch_instantiate_templates:
1441 Flag <["-"], "fno-pch-instantiate-templates">,
1442 Group<f_Group>, Flags<[CC1Option]>;
1443 defm pch_codegen: OptInFFlag<"pch-codegen", "Generate ", "Do not generate ",
1444 "code for uses of this PCH that assumes an explicit object file will be built for the PCH">;
1445 defm pch_debuginfo: OptInFFlag<"pch-debuginfo", "Generate ", "Do not generate ",
1446 "debug info for types in an object file built from this PCH and do not generate them elsewhere">;
1448 def fmodules : Flag <["-"], "fmodules">, Group<f_Group>,
1449 Flags<[DriverOption, CC1Option]>,
1450 HelpText<"Enable the 'modules' language feature">;
1451 def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group>,
1452 Flags<[DriverOption, CC1Option]>,
1453 HelpText<"Implicitly search the file system for module map files.">;
1454 def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_Group>,
1455 Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">;
1456 def fmodule_maps : Flag <["-"], "fmodule-maps">, Alias<fimplicit_module_maps>;
1457 def fmodule_name_EQ : Joined<["-"], "fmodule-name=">, Group<f_Group>,
1458 Flags<[DriverOption,CC1Option]>, MetaVarName<"<name>">,
1459 HelpText<"Specify the name of the module to build">;
1460 def fmodule_name : Separate<["-"], "fmodule-name">, Alias<fmodule_name_EQ>;
1461 def fmodule_implementation_of : Separate<["-"], "fmodule-implementation-of">,
1462 Flags<[CC1Option]>, Alias<fmodule_name_EQ>;
1463 def fsystem_module : Flag<["-"], "fsystem-module">, Flags<[CC1Option]>,
1464 HelpText<"Build this module as a system module. Only used with -emit-module">;
1465 def fmodule_map_file : Joined<["-"], "fmodule-map-file=">,
1466 Group<f_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"<file>">,
1467 HelpText<"Load this module map file">;
1468 def fmodule_file : Joined<["-"], "fmodule-file=">,
1469 Group<i_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"[<name>=]<file>">,
1470 HelpText<"Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.">;
1471 def fmodules_ignore_macro : Joined<["-"], "fmodules-ignore-macro=">, Group<f_Group>, Flags<[CC1Option]>,
1472 HelpText<"Ignore the definition of the given macro when building and loading modules">;
1473 def fmodules_decluse : Flag <["-"], "fmodules-decluse">, Group<f_Group>,
1474 Flags<[DriverOption,CC1Option]>,
1475 HelpText<"Require declaration of modules used within a module">;
1476 def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>,
1477 Flags<[DriverOption,CC1Option]>,
1478 HelpText<"Like -fmodules-decluse but requires all headers to be in modules">;
1479 def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>,
1480 Flags<[DriverOption, CC1Option]>;
1481 def fno_implicit_modules :
1482 Flag <["-"], "fno-implicit-modules">,
1483 Group<f_Group>, Flags<[DriverOption, CC1Option]>;
1484 def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>;
1486 def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>;
1487 def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>;
1488 def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>;
1489 def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>;
1490 def fno_apple_pragma_pack : Flag<["-"], "fno-apple-pragma-pack">, Group<f_Group>;
1491 def fno_asm : Flag<["-"], "fno-asm">, Group<f_Group>;
1492 def fno_asynchronous_unwind_tables : Flag<["-"], "fno-asynchronous-unwind-tables">, Group<f_Group>;
1493 def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>,
1494 HelpText<"Don't assume that C++'s global operator new can't alias any pointer">,
1496 def fno_borland_extensions : Flag<["-"], "fno-borland-extensions">, Group<f_Group>;
1497 def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1498 HelpText<"Disable implicit builtin knowledge of functions">;
1499 def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1500 HelpText<"Disable implicit builtin knowledge of a specific function">;
1501 def fno_diagnostics_color : Flag<["-"], "fno-diagnostics-color">, Group<f_Group>,
1502 Flags<[CoreOption, DriverOption]>;
1503 def fno_common : Flag<["-"], "fno-common">, Group<f_Group>, Flags<[CC1Option]>,
1504 HelpText<"Compile common globals like normal definitions">;
1505 def fno_constant_cfstrings : Flag<["-"], "fno-constant-cfstrings">, Group<f_Group>,
1507 HelpText<"Disable creation of CodeFoundation-type constant strings">;
1508 def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>,
1509 Flags<[DriverOption]>;
1510 def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>,
1511 Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">;
1512 def fno_diagnostics_show_hotness : Flag<["-"], "fno-diagnostics-show-hotness">, Group<f_Group>;
1513 def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_Group>, Flags<[CC1Option]>;
1514 def fno_diagnostics_show_note_include_stack : Flag<["-"], "fno-diagnostics-show-note-include-stack">,
1515 Flags<[CC1Option]>, Group<f_Group>;
1516 def fdigraphs : Flag<["-"], "fdigraphs">, Group<f_Group>, Flags<[CC1Option]>,
1517 HelpText<"Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)">;
1518 def fno_digraphs : Flag<["-"], "fno-digraphs">, Group<f_Group>, Flags<[CC1Option]>,
1519 HelpText<"Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'">;
1520 def fno_declspec : Flag<["-"], "fno-declspec">, Group<f_clang_Group>,
1521 HelpText<"Disallow __declspec as a keyword">, Flags<[CC1Option]>;
1522 def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>,
1523 HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;
1524 def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
1525 HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;
1526 def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
1527 def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
1528 def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
1529 def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
1530 def fno_global_isel : Flag<["-"], "fno-global-isel">, Group<f_clang_Group>,
1531 HelpText<"Disables the global instruction selector">;
1532 def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>,
1533 Alias<fno_global_isel>;
1534 def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">,
1535 Group<f_clang_Group>, Flags<[CC1Option]>,
1536 HelpText<"Disables an experimental new pass manager in LLVM.">;
1537 def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>,
1538 HelpText<"Use the given vector functions library">, Values<"Accelerate,MASSV,SVML,none">;
1539 def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
1540 Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>;
1541 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
1542 HelpText<"Disallow merging of constants">;
1543 def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
1544 Flags<[DriverOption]>;
1545 def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>,
1546 Flags<[DriverOption]>;
1547 def fno_module_maps : Flag <["-"], "fno-module-maps">, Alias<fno_implicit_module_maps>;
1548 def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>,
1549 Flags<[DriverOption]>;
1550 def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>,
1551 Flags<[DriverOption]>;
1552 def fimplicit_modules : Flag <["-"], "fimplicit-modules">, Group<f_Group>,
1553 Flags<[DriverOption]>;
1554 def fmodule_file_deps : Flag <["-"], "fmodule-file-deps">, Group<f_Group>,
1555 Flags<[DriverOption]>;
1556 def fno_module_file_deps : Flag <["-"], "fno-module-file-deps">, Group<f_Group>,
1557 Flags<[DriverOption]>;
1558 def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>,
1559 Flags<[CoreOption]>;
1560 def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>,
1561 Flags<[CoreOption]>;
1562 def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>,
1563 HelpText<"Disable delayed template parsing">,
1564 Flags<[DriverOption, CoreOption]>;
1565 def fno_objc_exceptions: Flag<["-"], "fno-objc-exceptions">, Group<f_Group>;
1566 def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>;
1567 def fno_objc_weak : Flag<["-"], "fno-objc-weak">, Group<f_Group>, Flags<[CC1Option]>;
1568 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
1569 def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>,
1570 HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,
1572 def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>;
1573 def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>;
1574 def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>,
1575 Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;
1576 def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
1577 Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">;
1578 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
1579 Flags<[CC1Option]>, HelpText<"Disable spell-checking">;
1580 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
1581 HelpText<"Disable the use of stack protectors">;
1582 def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>,
1583 Flags<[DriverOption, CoreOption]>;
1584 def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>;
1585 def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>;
1586 def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>;
1587 def fno_strict_vtable_pointers: Flag<["-"], "fno-strict-vtable-pointers">,
1589 def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>;
1590 def fno_temp_file : Flag<["-"], "fno-temp-file">, Group<f_Group>,
1591 Flags<[CC1Option, CoreOption]>, HelpText<
1592 "Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes">;
1593 def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>,
1594 Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">;
1595 def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>,
1596 HelpText<"Don't use __cxa_atexit for calling destructors">;
1597 def fno_register_global_dtors_with_atexit : Flag<["-"], "fno-register-global-dtors-with-atexit">, Group<f_Group>,
1598 HelpText<"Don't use atexit or __cxa_atexit to register global destructors">;
1599 def fno_unit_at_a_time : Flag<["-"], "fno-unit-at-a-time">, Group<f_Group>;
1600 def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>;
1601 def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>;
1602 def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>;
1603 def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>;
1604 def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>,
1605 HelpText<"Synthesize retain and release calls for Objective-C pointers">;
1606 def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>;
1607 def fobjc_convert_messages_to_runtime_calls :
1608 Flag<["-"], "fobjc-convert-messages-to-runtime-calls">, Group<f_Group>;
1609 def fno_objc_convert_messages_to_runtime_calls :
1610 Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group<f_Group>, Flags<[CC1Option]>;
1611 def fobjc_arc_exceptions : Flag<["-"], "fobjc-arc-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
1612 HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">;
1613 def fno_objc_arc_exceptions : Flag<["-"], "fno-objc-arc-exceptions">, Group<f_Group>;
1614 def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>;
1615 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
1616 def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>,
1617 HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;
1618 def fapplication_extension : Flag<["-"], "fapplication-extension">,
1619 Group<f_Group>, Flags<[CC1Option]>,
1620 HelpText<"Restrict code to those available for App Extensions">;
1621 def fno_application_extension : Flag<["-"], "fno-application-extension">,
1623 def frelaxed_template_template_args : Flag<["-"], "frelaxed-template-template-args">,
1624 Flags<[CC1Option]>, HelpText<"Enable C++17 relaxed template template argument matching">,
1626 def fno_relaxed_template_template_args : Flag<["-"], "fno-relaxed-template-template-args">,
1628 def fsized_deallocation : Flag<["-"], "fsized-deallocation">, Flags<[CC1Option]>,
1629 HelpText<"Enable C++14 sized global deallocation functions">, Group<f_Group>;
1630 def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Group<f_Group>;
1631 def faligned_allocation : Flag<["-"], "faligned-allocation">, Flags<[CC1Option]>,
1632 HelpText<"Enable C++17 aligned allocation functions">, Group<f_Group>;
1633 def fno_aligned_allocation: Flag<["-"], "fno-aligned-allocation">,
1634 Group<f_Group>, Flags<[CC1Option]>;
1635 def fnew_alignment_EQ : Joined<["-"], "fnew-alignment=">,
1636 HelpText<"Specifies the largest alignment guaranteed by '::operator new(size_t)'">,
1637 MetaVarName<"<align>">, Group<f_Group>, Flags<[CC1Option]>;
1638 def : Separate<["-"], "fnew-alignment">, Alias<fnew_alignment_EQ>;
1639 def : Flag<["-"], "faligned-new">, Alias<faligned_allocation>;
1640 def : Flag<["-"], "fno-aligned-new">, Alias<fno_aligned_allocation>;
1641 def faligned_new_EQ : Joined<["-"], "faligned-new=">;
1643 def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
1644 def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;
1645 def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">,
1647 def fno_objc_infer_related_result_type : Flag<["-"],
1648 "fno-objc-infer-related-result-type">, Group<f_Group>,
1650 "do not infer Objective-C related result type based on method family">,
1652 def fobjc_link_runtime: Flag<["-"], "fobjc-link-runtime">, Group<f_Group>;
1653 def fobjc_weak : Flag<["-"], "fobjc-weak">, Group<f_Group>, Flags<[CC1Option]>,
1654 HelpText<"Enable ARC-style weak references in Objective-C">;
1656 // Objective-C ABI options.
1657 def fobjc_runtime_EQ : Joined<["-"], "fobjc-runtime=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1658 HelpText<"Specify the target Objective-C runtime kind and version">;
1659 def fobjc_abi_version_EQ : Joined<["-"], "fobjc-abi-version=">, Group<f_Group>;
1660 def fobjc_nonfragile_abi_version_EQ : Joined<["-"], "fobjc-nonfragile-abi-version=">, Group<f_Group>;
1661 def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>;
1662 def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>;
1664 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
1665 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
1666 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
1667 HelpText<"Parse OpenMP pragmas and generate parallel code.">;
1668 def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
1669 def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
1670 def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;
1671 def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>,
1672 Flags<[NoArgumentUnused, HelpHidden]>;
1673 def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>,
1674 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1675 def fopenmp_targets_EQ : CommaJoined<["-"], "fopenmp-targets=">, Flags<[DriverOption, CC1Option]>,
1676 HelpText<"Specify comma-separated list of triples OpenMP offloading targets to be supported">;
1677 def fopenmp_relocatable_target : Flag<["-"], "fopenmp-relocatable-target">,
1678 Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1679 def fnoopenmp_relocatable_target : Flag<["-"], "fnoopenmp-relocatable-target">,
1680 Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1681 def fopenmp_simd : Flag<["-"], "fopenmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
1682 HelpText<"Emit OpenMP code only for SIMD-based constructs.">;
1683 def fopenmp_enable_irbuilder : Flag<["-"], "fopenmp-enable-irbuilder">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>,
1684 HelpText<"Use the experimental OpenMP-IR-Builder codegen path.">;
1685 def fno_openmp_simd : Flag<["-"], "fno-openmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
1686 def fopenmp_cuda_mode : Flag<["-"], "fopenmp-cuda-mode">, Group<f_Group>,
1687 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1688 def fno_openmp_cuda_mode : Flag<["-"], "fno-openmp-cuda-mode">, Group<f_Group>,
1689 Flags<[NoArgumentUnused, HelpHidden]>;
1690 def fopenmp_cuda_force_full_runtime : Flag<["-"], "fopenmp-cuda-force-full-runtime">, Group<f_Group>,
1691 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1692 def fno_openmp_cuda_force_full_runtime : Flag<["-"], "fno-openmp-cuda-force-full-runtime">, Group<f_Group>,
1693 Flags<[NoArgumentUnused, HelpHidden]>;
1694 def fopenmp_cuda_number_of_sm_EQ : Joined<["-"], "fopenmp-cuda-number-of-sm=">, Group<f_Group>,
1695 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1696 def fopenmp_cuda_blocks_per_sm_EQ : Joined<["-"], "fopenmp-cuda-blocks-per-sm=">, Group<f_Group>,
1697 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1698 def fopenmp_cuda_teams_reduction_recs_num_EQ : Joined<["-"], "fopenmp-cuda-teams-reduction-recs-num=">, Group<f_Group>,
1699 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1700 def fopenmp_optimistic_collapse : Flag<["-"], "fopenmp-optimistic-collapse">, Group<f_Group>,
1701 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
1702 def fno_openmp_optimistic_collapse : Flag<["-"], "fno-openmp-optimistic-collapse">, Group<f_Group>,
1703 Flags<[NoArgumentUnused, HelpHidden]>;
1704 def fopenmp_cuda_parallel_target_regions : Flag<["-"], "fopenmp-cuda-parallel-target-regions">, Group<f_Group>,
1705 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>,
1706 HelpText<"Support parallel execution of target regions on Cuda-based devices.">;
1707 def fno_openmp_cuda_parallel_target_regions : Flag<["-"], "fno-openmp-cuda-parallel-target-regions">, Group<f_Group>,
1708 Flags<[NoArgumentUnused, HelpHidden]>,
1709 HelpText<"Support only serial execution of target regions on Cuda-based devices.">;
1710 def static_openmp: Flag<["-"], "static-openmp">,
1711 HelpText<"Use the static host OpenMP runtime while linking.">;
1712 def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>;
1713 def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>;
1714 def fno_escaping_block_tail_calls : Flag<["-"], "fno-escaping-block-tail-calls">, Group<f_Group>, Flags<[CC1Option]>;
1715 def fescaping_block_tail_calls : Flag<["-"], "fescaping-block-tail-calls">, Group<f_Group>;
1716 def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">;
1717 def force__flat__namespace : Flag<["-"], "force_flat_namespace">;
1718 def force__load : Separate<["-"], "force_load">;
1719 def force_addr : Joined<["-"], "fforce-addr">, Group<clang_ignored_f_Group>;
1720 def foutput_class_dir_EQ : Joined<["-"], "foutput-class-dir=">, Group<f_Group>;
1721 def fpack_struct : Flag<["-"], "fpack-struct">, Group<f_Group>;
1722 def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>;
1723 def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>,
1724 HelpText<"Specify the default maximum struct packing alignment">;
1725 def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>,
1726 HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">;
1727 def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>;
1728 def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
1729 HelpText<"Recognize and construct Pascal-style string literals">;
1730 def fpatchable_function_entry_EQ : Joined<["-"], "fpatchable-function-entry=">, Group<f_Group>, Flags<[CC1Option]>,
1731 MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">;
1732 def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
1733 HelpText<"Override the default ABI to return all structs on the stack">;
1734 def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>;
1735 def fpic : Flag<["-"], "fpic">, Group<f_Group>;
1736 def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
1737 def fpie : Flag<["-"], "fpie">, Group<f_Group>;
1738 def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
1739 defm plt : OptOutFFlag<"plt", "",
1740 "Use GOT indirection instead of PLT to make external function calls (x86 only)">;
1741 defm ropi : OptInFFlag<"ropi", "Generate read-only position independent code (ARM only)">;
1742 defm rwpi : OptInFFlag<"rwpi", "Generate read-write position independent code (ARM only)">;
1743 def fplugin_EQ : Joined<["-"], "fplugin=">, Group<f_Group>, Flags<[DriverOption]>, MetaVarName<"<dsopath>">,
1744 HelpText<"Load the named plugin (dynamic shared object)">;
1745 def fpass_plugin_EQ : Joined<["-"], "fpass-plugin=">,
1746 Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<dsopath>">,
1747 HelpText<"Load pass plugin from a dynamic shared object file (only with new pass manager).">;
1748 defm preserve_as_comments : OptOutFFlag<"preserve-as-comments", "",
1749 "Do not preserve comments in inline assembly">;
1750 def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>;
1751 def fno_profile_arcs : Flag<["-"], "fno-profile-arcs">, Group<f_Group>;
1752 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
1753 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
1754 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
1755 HelpText<"Override the default ABI to return small structs in registers">;
1756 defm rtti : OptOutFFlag<"rtti", "", "Disable generation of rtti information">;
1757 defm rtti_data : OptOutFFlag<"rtti-data", "", "Disable generation of RTTI data">;
1758 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
1759 def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
1760 HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
1761 def fchar8__t : Flag<["-"], "fchar8_t">, Group<f_Group>, Flags<[CC1Option]>,
1762 HelpText<"Enable C++ builtin type char8_t">;
1763 def fno_char8__t : Flag<["-"], "fno-char8_t">, Group<f_Group>, Flags<[CC1Option]>,
1764 HelpText<"Disable C++ builtin type char8_t">;
1765 def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>,
1766 HelpText<"Force wchar_t to be a short unsigned int">;
1767 def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>,
1768 HelpText<"Force wchar_t to be an unsigned int">;
1769 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
1770 HelpText<"Which overload candidates to show when overload resolution fails: "
1771 "best|all; defaults to all">, Values<"best,all">;
1772 defm show_column : OptOutFFlag<"show-column", "", "Do not include column number on diagnostics">;
1773 def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>;
1774 def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
1775 def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>;
1776 def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>;
1777 defm signed_char : OptOutFFlag<"signed-char", "char is signed", "char is unsigned">;
1778 def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>;
1779 def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>,
1780 HelpText<"Enable stack protectors for all functions">;
1781 def fstack_clash_protection : Flag<["-"], "fstack-clash-protection">, Group<f_Group>, Flags<[CC1Option]>,
1782 HelpText<"Enable stack clash protection">;
1783 def fno_stack_clash_protection : Flag<["-"], "fno-stack-clash-protection">, Group<f_Group>,
1784 HelpText<"Disable stack clash protection">;
1785 def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>,
1786 HelpText<"Enable stack protectors for some functions vulnerable to stack smashing. "
1787 "Compared to -fstack-protector, this uses a stronger heuristic "
1788 "that includes functions containing arrays of any size (and any type), "
1789 "as well as any calls to alloca or the taking of an address from a local variable">;
1790 def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>,
1791 HelpText<"Enable stack protectors for some functions vulnerable to stack smashing. "
1792 "This uses a loose heuristic which considers functions vulnerable "
1793 "if they contain a char (or 8bit integer) array or constant sized calls to "
1794 "alloca, which are of greater size than ssp-buffer-size (default: 8 bytes). "
1795 "All variable sized calls to alloca are considered vulnerable">;
1796 def ftrivial_auto_var_init : Joined<["-"], "ftrivial-auto-var-init=">, Group<f_Group>,
1797 Flags<[CC1Option, CoreOption]>, HelpText<"Initialize trivial automatic stack variables: uninitialized (default)"
1798 " | pattern">, Values<"uninitialized,pattern">;
1799 def enable_trivial_var_init_zero : Flag<["-"], "enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang">,
1800 Flags<[CC1Option, CoreOption]>,
1801 HelpText<"Trivial automatic variable initialization to zero is only here for benchmarks, it'll eventually be removed, and I'm OK with that because I'm only using it to benchmark">;
1802 def ftrivial_auto_var_init_stop_after : Joined<["-"], "ftrivial-auto-var-init-stop-after=">, Group<f_Group>,
1803 Flags<[CC1Option, CoreOption]>, HelpText<"Stop initializing trivial automatic stack variables after the specified number of instances">;
1804 def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>, Flags<[CoreOption]>,
1805 HelpText<"Emit full debug info for all types used by the program">;
1806 def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CoreOption]>,
1807 HelpText<"Limit debug information produced to reduce size of debug binary">;
1808 def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Flags<[CoreOption]>, Alias<fno_standalone_debug>;
1809 def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Flags<[CoreOption]>, Alias<fstandalone_debug>;
1810 def fdebug_macro : Flag<["-"], "fdebug-macro">, Group<f_Group>, Flags<[CoreOption]>,
1811 HelpText<"Emit macro debug information">;
1812 def fno_debug_macro : Flag<["-"], "fno-debug-macro">, Group<f_Group>, Flags<[CoreOption]>,
1813 HelpText<"Do not emit macro debug information">;
1814 def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,
1815 Flags<[DriverOption, CoreOption]>;
1816 def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
1817 HelpText<"Enable optimizations based on the strict definition of an enum's "
1819 def fstrict_vtable_pointers: Flag<["-"], "fstrict-vtable-pointers">,
1820 Group<f_Group>, Flags<[CC1Option]>,
1821 HelpText<"Enable optimizations based on the strict rules for overwriting "
1822 "polymorphic C++ objects">;
1823 def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>;
1824 def fsyntax_only : Flag<["-"], "fsyntax-only">,
1825 Flags<[DriverOption,CoreOption,CC1Option]>, Group<Action_Group>;
1826 def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>;
1827 def ftemplate_depth_EQ : Joined<["-"], "ftemplate-depth=">, Group<f_Group>;
1828 def ftemplate_depth_ : Joined<["-"], "ftemplate-depth-">, Group<f_Group>;
1829 def ftemplate_backtrace_limit_EQ : Joined<["-"], "ftemplate-backtrace-limit=">,
1831 def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">,
1834 def fsave_optimization_record : Flag<["-"], "fsave-optimization-record">,
1835 Group<f_Group>, HelpText<"Generate a YAML optimization record file">;
1836 def fsave_optimization_record_EQ : Joined<["-"], "fsave-optimization-record=">,
1837 Group<f_Group>, HelpText<"Generate an optimization record file in a specific format">,
1838 MetaVarName<"<format>">;
1839 def fno_save_optimization_record : Flag<["-"], "fno-save-optimization-record">,
1840 Group<f_Group>, Flags<[NoArgumentUnused]>;
1841 def foptimization_record_file_EQ : Joined<["-"], "foptimization-record-file=">,
1843 HelpText<"Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.">,
1844 MetaVarName<"<file>">;
1845 def foptimization_record_passes_EQ : Joined<["-"], "foptimization-record-passes=">,
1847 HelpText<"Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)">,
1848 MetaVarName<"<regex>">;
1850 def ftest_coverage : Flag<["-"], "ftest-coverage">, Group<f_Group>;
1851 def fno_test_coverage : Flag<["-"], "fno-test-coverage">, Group<f_Group>;
1852 def fvectorize : Flag<["-"], "fvectorize">, Group<f_Group>,
1853 HelpText<"Enable the loop vectorization passes">;
1854 def fno_vectorize : Flag<["-"], "fno-vectorize">, Group<f_Group>;
1855 def : Flag<["-"], "ftree-vectorize">, Alias<fvectorize>;
1856 def : Flag<["-"], "fno-tree-vectorize">, Alias<fno_vectorize>;
1857 def fslp_vectorize : Flag<["-"], "fslp-vectorize">, Group<f_Group>,
1858 HelpText<"Enable the superword-level parallelism vectorization passes">;
1859 def fno_slp_vectorize : Flag<["-"], "fno-slp-vectorize">, Group<f_Group>;
1860 def : Flag<["-"], "ftree-slp-vectorize">, Alias<fslp_vectorize>;
1861 def : Flag<["-"], "fno-tree-slp-vectorize">, Alias<fno_slp_vectorize>;
1862 def Wlarge_by_value_copy_def : Flag<["-"], "Wlarge-by-value-copy">,
1863 HelpText<"Warn if a function definition returns or accepts an object larger "
1864 "in bytes than a given value">, Flags<[HelpHidden]>;
1865 def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>;
1867 // These "special" warning flags are effectively processed as f_Group flags by the driver:
1868 // Just silence warnings about -Wlarger-than for now.
1869 def Wlarger_than_EQ : Joined<["-"], "Wlarger-than=">, Group<clang_ignored_f_Group>;
1870 def Wlarger_than_ : Joined<["-"], "Wlarger-than-">, Alias<Wlarger_than_EQ>;
1871 def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[DriverOption]>;
1873 def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>;
1874 def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group<f_Group>;
1875 def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>;
1876 def ftime_trace : Flag<["-"], "ftime-trace">, Group<f_Group>,
1877 HelpText<"Turn on time profiler. Generates JSON file based on output filename.">,
1879 Turn on time profiler. Generates JSON file based on output filename. Results
1880 can be analyzed with chrome://tracing or `Speedscope App
1881 <https://www.speedscope.app>`_ for flamegraph visualization.}]>,
1882 Flags<[CC1Option, CoreOption]>;
1883 def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Group<f_Group>,
1884 HelpText<"Minimum time granularity (in microseconds) traced by time profiler">,
1885 Flags<[CC1Option, CoreOption]>;
1886 def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>;
1887 def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>,
1888 HelpText<"Trap on integer overflow">;
1889 def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>,
1890 MetaVarName<"<function name>">,
1891 HelpText<"Specify the function to be called on overflow">;
1892 def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>;
1893 def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>,
1894 HelpText<"Issue call to specified function rather than a trap instruction">;
1895 def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>;
1896 def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
1897 HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;
1898 def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
1899 HelpText<"Turn off loop unroller">, Flags<[CC1Option]>;
1900 defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller">;
1901 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
1902 HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
1903 def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
1904 HelpText<"Do not process trigraph sequences">, Flags<[CC1Option]>;
1905 def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>;
1906 def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>;
1907 def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">;
1908 def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>;
1909 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
1910 def fregister_global_dtors_with_atexit : Flag<["-"], "fregister-global-dtors-with-atexit">, Group<f_Group>, Flags<[CC1Option]>,
1911 HelpText<"Use atexit or __cxa_atexit to register global destructors">;
1912 defm use_init_array : OptOutFFlag<"use-init-array", "", "Use .ctors/.dtors instead of .init_array/.fini_array">;
1913 def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
1914 def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>,
1915 HelpText<"Generate verbose assembly output">;
1916 def dA : Flag<["-"], "dA">, Alias<fverbose_asm>;
1917 def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>,
1918 HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">;
1919 def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>,
1920 HelpText<"Give inline C++ member functions hidden visibility by default">,
1922 def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>,
1923 HelpText<"Give global types 'default' visibility and global functions and "
1924 "variables 'hidden' visibility by default">;
1925 def fvisibility_global_new_delete_hidden : Flag<["-"], "fvisibility-global-new-delete-hidden">, Group<f_Group>,
1926 HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>;
1927 defm whole_program_vtables : OptInFFlag<"whole-program-vtables",
1928 "Enables whole-program vtable optimization. Requires -flto", "", "", [CoreOption]>;
1929 defm split_lto_unit : OptInFFlag<"split-lto-unit",
1930 "Enables splitting of the LTO unit", "", "", [CoreOption]>;
1931 defm force_emit_vtables : OptInFFlag<"force-emit-vtables",
1932 "Emits more virtual tables to improve devirtualization", "", "", [CoreOption]>;
1933 defm virtual_function_elimination : OptInFFlag<"virtual-function-elimination",
1934 "Enables dead virtual function elimination optimization. Requires -flto=full", "", "", [CoreOption]>;
1936 def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>,
1937 HelpText<"Treat signed integer overflow as two's complement">;
1938 def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>,
1939 HelpText<"Store string literals as writable data">;
1940 defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS">;
1941 defm function_sections : OptInFFlag<"function-sections", "Place each function in its own section">;
1942 def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>,
1943 Flags<[CC1Option, CC1AsOption]>,
1944 HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">,
1945 DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>,
1946 Values<"all,labels,none,list=">;
1947 defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section">;
1948 defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes">;
1950 defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names",
1951 "Use unique names for basic block sections (ELF Only)">;
1952 defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names",
1953 "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path">;
1954 defm unique_section_names : OptOutFFlag<"unique-section-names",
1955 "", "Don't use unique names for text and data sections">;
1957 defm strict_return : OptOutFFlag<"strict-return", "",
1958 "Don't treat control flow paths that fall off the end of a non-void function as unreachable">;
1960 def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_Group>,
1962 HelpText<"Enable matrix data type and related builtin functions">;
1965 def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
1966 HelpText<"Place debug types in their own section (ELF Only)">;
1967 def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>;
1968 defm debug_ranges_base_address : OptInFFlag<"debug-ranges-base-address",
1969 "Use DWARF base address selection entries in .debug_ranges">;
1970 def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, Group<f_Group>,
1971 HelpText<"Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF">;
1972 def fno_split_dwarf_inlining: Flag<["-"], "fno-split-dwarf-inlining">, Group<f_Group>,
1974 def fdebug_default_version: Joined<["-"], "fdebug-default-version=">, Group<f_Group>,
1975 HelpText<"Default DWARF version to use, if a -g option caused DWARF debug info to be produced">;
1976 def fdebug_prefix_map_EQ
1977 : Joined<["-"], "fdebug-prefix-map=">, Group<f_Group>,
1978 Flags<[CC1Option,CC1AsOption]>,
1979 HelpText<"remap file source paths in debug info">;
1980 def ffile_prefix_map_EQ
1981 : Joined<["-"], "ffile-prefix-map=">, Group<f_Group>,
1982 HelpText<"remap file source paths in debug info and predefined preprocessor macros">;
1983 def fmacro_prefix_map_EQ
1984 : Joined<["-"], "fmacro-prefix-map=">, Group<Preprocessor_Group>, Flags<[CC1Option]>,
1985 HelpText<"remap file source paths in predefined preprocessor macros">;
1986 defm force_dwarf_frame : OptInFFlag<"force-dwarf-frame", "Always emit a debug frame section">;
1987 def g_Flag : Flag<["-"], "g">, Group<g_Group>,
1988 HelpText<"Generate source-level debug information">;
1989 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
1990 Flags<[CoreOption]>, HelpText<"Emit debug line number tables only">;
1991 def gline_directives_only : Flag<["-"], "gline-directives-only">, Group<gN_Group>,
1992 Flags<[CoreOption]>, HelpText<"Emit debug line info directives only">;
1993 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
1994 def g0 : Flag<["-"], "g0">, Group<gN_Group>;
1995 def g1 : Flag<["-"], "g1">, Group<gN_Group>, Alias<gline_tables_only>;
1996 def g2 : Flag<["-"], "g2">, Group<gN_Group>;
1997 def g3 : Flag<["-"], "g3">, Group<gN_Group>;
1998 def ggdb : Flag<["-"], "ggdb">, Group<gTune_Group>;
1999 def ggdb0 : Flag<["-"], "ggdb0">, Group<ggdbN_Group>;
2000 def ggdb1 : Flag<["-"], "ggdb1">, Group<ggdbN_Group>;
2001 def ggdb2 : Flag<["-"], "ggdb2">, Group<ggdbN_Group>;
2002 def ggdb3 : Flag<["-"], "ggdb3">, Group<ggdbN_Group>;
2003 def glldb : Flag<["-"], "glldb">, Group<gTune_Group>;
2004 def gsce : Flag<["-"], "gsce">, Group<gTune_Group>;
2005 // Equivalent to our default dwarf version. Forces usual dwarf emission when
2006 // CodeView is enabled.
2007 def gdwarf : Flag<["-"], "gdwarf">, Group<g_Group>, Flags<[CoreOption]>,
2008 HelpText<"Generate source-level debug information with the default dwarf version">;
2009 def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>,
2010 HelpText<"Generate source-level debug information with dwarf version 2">;
2011 def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>,
2012 HelpText<"Generate source-level debug information with dwarf version 3">;
2013 def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>,
2014 HelpText<"Generate source-level debug information with dwarf version 4">;
2015 def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>,
2016 HelpText<"Generate source-level debug information with dwarf version 5">;
2018 def gcodeview : Flag<["-"], "gcodeview">,
2019 HelpText<"Generate CodeView debug information">,
2020 Flags<[CC1Option, CC1AsOption, CoreOption]>;
2021 def gcodeview_ghash : Flag<["-"], "gcodeview-ghash">,
2022 HelpText<"Emit type record hashes in a .debug$H section">,
2023 Flags<[CC1Option, CoreOption]>;
2024 def gno_codeview_ghash : Flag<["-"], "gno-codeview-ghash">, Flags<[CoreOption]>;
2025 def ginline_line_tables : Flag<["-"], "ginline-line-tables">, Flags<[CoreOption]>;
2026 def gno_inline_line_tables : Flag<["-"], "gno-inline-line-tables">,
2027 Flags<[CC1Option, CoreOption]>, HelpText<"Don't emit inline line tables">;
2029 def gfull : Flag<["-"], "gfull">, Group<g_Group>;
2030 def gused : Flag<["-"], "gused">, Group<g_Group>;
2031 def gstabs : Joined<["-"], "gstabs">, Group<g_Group>, Flags<[Unsupported]>;
2032 def gcoff : Joined<["-"], "gcoff">, Group<g_Group>, Flags<[Unsupported]>;
2033 def gxcoff : Joined<["-"], "gxcoff">, Group<g_Group>, Flags<[Unsupported]>;
2034 def gvms : Joined<["-"], "gvms">, Group<g_Group>, Flags<[Unsupported]>;
2035 def gtoggle : Flag<["-"], "gtoggle">, Group<g_flags_Group>, Flags<[Unsupported]>;
2036 def grecord_command_line : Flag<["-"], "grecord-command-line">,
2037 Group<g_flags_Group>;
2038 def gno_record_command_line : Flag<["-"], "gno-record-command-line">,
2039 Group<g_flags_Group>;
2040 def : Flag<["-"], "grecord-gcc-switches">, Alias<grecord_command_line>;
2041 def : Flag<["-"], "gno-record-gcc-switches">, Alias<gno_record_command_line>;
2042 def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>;
2043 def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>;
2044 def gcolumn_info : Flag<["-"], "gcolumn-info">, Group<g_flags_Group>, Flags<[CoreOption]>;
2045 def gno_column_info : Flag<["-"], "gno-column-info">, Group<g_flags_Group>, Flags<[CoreOption, CC1Option]>;
2046 def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>;
2047 def gsplit_dwarf_EQ : Joined<["-"], "gsplit-dwarf=">, Group<g_flags_Group>,
2048 HelpText<"Set DWARF fission mode to either 'split' or 'single'">,
2049 Values<"split,single">;
2050 def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group<g_flags_Group>, Flags<[CC1Option]>;
2051 def gno_gnu_pubnames : Flag<["-"], "gno-gnu-pubnames">, Group<g_flags_Group>;
2052 def gpubnames : Flag<["-"], "gpubnames">, Group<g_flags_Group>, Flags<[CC1Option]>;
2053 def gno_pubnames : Flag<["-"], "gno-pubnames">, Group<g_flags_Group>;
2054 def gdwarf_aranges : Flag<["-"], "gdwarf-aranges">, Group<g_flags_Group>;
2055 def gmodules : Flag <["-"], "gmodules">, Group<gN_Group>,
2056 HelpText<"Generate debug info with external references to clang modules"
2057 " or precompiled headers">;
2058 def gz : Flag<["-"], "gz">, Group<g_flags_Group>,
2059 HelpText<"DWARF debug sections compression type">;
2060 def gz_EQ : Joined<["-"], "gz=">, Group<g_flags_Group>,
2061 HelpText<"DWARF debug sections compression type">;
2062 def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>, Flags<[CC1Option]>,
2063 HelpText<"Embed source text in DWARF debug sections">;
2064 def gno_embed_source : Flag<["-"], "gno-embed-source">, Group<g_flags_Group>,
2065 Flags<[DriverOption]>,
2066 HelpText<"Restore the default behavior of not embedding source text in DWARF debug sections">;
2067 def headerpad__max__install__names : Joined<["-"], "headerpad_max_install_names">;
2068 def help : Flag<["-", "--"], "help">, Flags<[CC1Option,CC1AsOption]>,
2069 HelpText<"Display available options">;
2070 def ibuiltininc : Flag<["-"], "ibuiltininc">,
2071 HelpText<"Enable builtin #include directories even when -nostdinc is used "
2072 "before or after -ibuiltininc. "
2073 "Using -nobuiltininc after the option disables it">;
2074 def index_header_map : Flag<["-"], "index-header-map">, Flags<[CC1Option]>,
2075 HelpText<"Make the next included directory (-I or -F) an indexer header map">;
2076 def idirafter : JoinedOrSeparate<["-"], "idirafter">, Group<clang_i_Group>, Flags<[CC1Option]>,
2077 HelpText<"Add directory to AFTER include search path">;
2078 def iframework : JoinedOrSeparate<["-"], "iframework">, Group<clang_i_Group>, Flags<[CC1Option]>,
2079 HelpText<"Add directory to SYSTEM framework search path">;
2080 def iframeworkwithsysroot : JoinedOrSeparate<["-"], "iframeworkwithsysroot">,
2081 Group<clang_i_Group>,
2082 HelpText<"Add directory to SYSTEM framework search path, "
2083 "absolute paths are relative to -isysroot">,
2084 MetaVarName<"<directory>">, Flags<[CC1Option]>;
2085 def imacros : JoinedOrSeparate<["-", "--"], "imacros">, Group<clang_i_Group>, Flags<[CC1Option]>,
2086 HelpText<"Include macros from file before parsing">, MetaVarName<"<file>">;
2087 def image__base : Separate<["-"], "image_base">;
2088 def include_ : JoinedOrSeparate<["-", "--"], "include">, Group<clang_i_Group>, EnumName<"include">,
2089 MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>;
2090 def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>,
2091 HelpText<"Include precompiled header file">, MetaVarName<"<file>">;
2092 def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>,
2093 HelpText<"Whether to build a relocatable precompiled header">;
2094 def verify_pch : Flag<["-"], "verify-pch">, Group<Action_Group>, Flags<[CC1Option]>,
2095 HelpText<"Load and verify that a pre-compiled header file is not stale">;
2096 def init : Separate<["-"], "init">;
2097 def install__name : Separate<["-"], "install_name">;
2098 def iprefix : JoinedOrSeparate<["-"], "iprefix">, Group<clang_i_Group>, Flags<[CC1Option]>,
2099 HelpText<"Set the -iwithprefix/-iwithprefixbefore prefix">, MetaVarName<"<dir>">;
2100 def iquote : JoinedOrSeparate<["-"], "iquote">, Group<clang_i_Group>, Flags<[CC1Option]>,
2101 HelpText<"Add directory to QUOTE include search path">, MetaVarName<"<directory>">;
2102 def isysroot : JoinedOrSeparate<["-"], "isysroot">, Group<clang_i_Group>, Flags<[CC1Option]>,
2103 HelpText<"Set the system root directory (usually /)">, MetaVarName<"<dir>">;
2104 def isystem : JoinedOrSeparate<["-"], "isystem">, Group<clang_i_Group>,
2106 HelpText<"Add directory to SYSTEM include search path">, MetaVarName<"<directory>">;
2107 def isystem_after : JoinedOrSeparate<["-"], "isystem-after">,
2108 Group<clang_i_Group>, Flags<[DriverOption]>, MetaVarName<"<directory>">,
2109 HelpText<"Add directory to end of the SYSTEM include search path">;
2110 def iwithprefixbefore : JoinedOrSeparate<["-"], "iwithprefixbefore">, Group<clang_i_Group>,
2111 HelpText<"Set directory to include search path with prefix">, MetaVarName<"<dir>">,
2113 def iwithprefix : JoinedOrSeparate<["-"], "iwithprefix">, Group<clang_i_Group>, Flags<[CC1Option]>,
2114 HelpText<"Set directory to SYSTEM include search path with prefix">, MetaVarName<"<dir>">;
2115 def iwithsysroot : JoinedOrSeparate<["-"], "iwithsysroot">, Group<clang_i_Group>,
2116 HelpText<"Add directory to SYSTEM include search path, "
2117 "absolute paths are relative to -isysroot">, MetaVarName<"<directory>">,
2119 def ivfsoverlay : JoinedOrSeparate<["-"], "ivfsoverlay">, Group<clang_i_Group>, Flags<[CC1Option]>,
2120 HelpText<"Overlay the virtual filesystem described by file over the real file system">;
2121 def imultilib : Separate<["-"], "imultilib">, Group<gfortran_Group>;
2122 def keep__private__externs : Flag<["-"], "keep_private_externs">;
2123 def l : JoinedOrSeparate<["-"], "l">, Flags<[LinkerInput, RenderJoined]>,
2125 def lazy__framework : Separate<["-"], "lazy_framework">, Flags<[LinkerInput]>;
2126 def lazy__library : Separate<["-"], "lazy_library">, Flags<[LinkerInput]>;
2127 def mlittle_endian : Flag<["-"], "mlittle-endian">, Flags<[DriverOption]>;
2128 def EL : Flag<["-"], "EL">, Alias<mlittle_endian>;
2129 def mbig_endian : Flag<["-"], "mbig-endian">, Flags<[DriverOption]>;
2130 def EB : Flag<["-"], "EB">, Alias<mbig_endian>;
2131 def m16 : Flag<["-"], "m16">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
2132 def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
2133 def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
2134 HelpText<"Enable hexagon-qdsp6 backward compatibility">;
2135 def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
2136 def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
2137 def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
2138 def miamcu : Flag<["-"], "miamcu">, Group<m_Group>, Flags<[DriverOption, CoreOption]>,
2139 HelpText<"Use Intel MCU ABI">;
2140 def mno_iamcu : Flag<["-"], "mno-iamcu">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
2141 def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>;
2142 def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>;
2143 def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>;
2144 def malign_branch_EQ : CommaJoined<["-"], "malign-branch=">, Group<m_Group>, Flags<[DriverOption]>,
2145 HelpText<"Specify types of branches to align">;
2146 def malign_branch_boundary_EQ : Joined<["-"], "malign-branch-boundary=">, Group<m_Group>, Flags<[DriverOption]>,
2147 HelpText<"Specify the boundary's size to align branches">;
2148 def mpad_max_prefix_size_EQ : Joined<["-"], "mpad-max-prefix-size=">, Group<m_Group>, Flags<[DriverOption]>,
2149 HelpText<"Specify maximum number of prefixes to use for padding">;
2150 def mbranches_within_32B_boundaries : Flag<["-"], "mbranches-within-32B-boundaries">, Flags<[DriverOption]>, Group<m_Group>,
2151 HelpText<"Align selected branches (fused, jcc, jmp) within 32-byte boundary">;
2152 def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Group>;
2153 def mlong_calls : Flag<["-"], "mlong-calls">, Group<m_Group>,
2154 HelpText<"Generate branches with extended addressability, usually via indirect jumps.">;
2155 def mdouble_EQ : Joined<["-"], "mdouble=">, Group<m_Group>, Values<"32,64">, Flags<[CC1Option]>,
2156 HelpText<"Force double to be 32 bits or 64 bits">;
2157 def LongDouble_Group : OptionGroup<"<LongDouble group>">, Group<m_Group>,
2158 DocName<"Long double flags">,
2159 DocBrief<[{Selects the long double implementation}]>;
2160 def mlong_double_64 : Flag<["-"], "mlong-double-64">, Group<LongDouble_Group>, Flags<[CC1Option]>,
2161 HelpText<"Force long double to be 64 bits">;
2162 def mlong_double_80 : Flag<["-"], "mlong-double-80">, Group<LongDouble_Group>, Flags<[CC1Option]>,
2163 HelpText<"Force long double to be 80 bits, padded to 128 bits for storage">;
2164 def mlong_double_128 : Flag<["-"], "mlong-double-128">, Group<LongDouble_Group>, Flags<[CC1Option]>,
2165 HelpText<"Force long double to be 128 bits">;
2166 def mno_long_calls : Flag<["-"], "mno-long-calls">, Group<m_Group>,
2167 HelpText<"Restore the default behaviour of not generating long calls">;
2168 def mexecute_only : Flag<["-"], "mexecute-only">, Group<m_arm_Features_Group>,
2169 HelpText<"Disallow generation of data access to code sections (ARM only)">;
2170 def mno_execute_only : Flag<["-"], "mno-execute-only">, Group<m_arm_Features_Group>,
2171 HelpText<"Allow generation of data access to code sections (ARM only)">;
2172 def mtp_mode_EQ : Joined<["-"], "mtp=">, Group<m_arm_Features_Group>, Values<"soft,cp15,el0,el1,el2,el3">,
2173 HelpText<"Thread pointer access method (AArch32/AArch64 only)">;
2174 def mpure_code : Flag<["-"], "mpure-code">, Alias<mexecute_only>; // Alias for GCC compatibility
2175 def mno_pure_code : Flag<["-"], "mno-pure-code">, Alias<mno_execute_only>;
2176 def mtvos_version_min_EQ : Joined<["-"], "mtvos-version-min=">, Group<m_Group>;
2177 def mappletvos_version_min_EQ : Joined<["-"], "mappletvos-version-min=">, Alias<mtvos_version_min_EQ>;
2178 def mtvos_simulator_version_min_EQ : Joined<["-"], "mtvos-simulator-version-min=">;
2179 def mappletvsimulator_version_min_EQ : Joined<["-"], "mappletvsimulator-version-min=">, Alias<mtvos_simulator_version_min_EQ>;
2180 def mwatchos_version_min_EQ : Joined<["-"], "mwatchos-version-min=">, Group<m_Group>;
2181 def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">;
2182 def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias<mwatchos_simulator_version_min_EQ>;
2183 def march_EQ : Joined<["-"], "march=">, Group<m_Group>, Flags<[CoreOption]>;
2184 def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[DriverOption]>;
2185 def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>, Flags<[CC1Option]>;
2186 def mtls_size_EQ : Joined<["-"], "mtls-size=">, Group<m_Group>, Flags<[DriverOption, CC1Option]>,
2187 HelpText<"Specify bit size of immediate TLS offsets (AArch64 ELF only): "
2188 "12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)">;
2189 def mimplicit_it_EQ : Joined<["-"], "mimplicit-it=">, Group<m_Group>;
2190 def mdefault_build_attributes : Joined<["-"], "mdefault-build-attributes">, Group<m_Group>;
2191 def mno_default_build_attributes : Joined<["-"], "mno-default-build-attributes">, Group<m_Group>;
2192 def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>;
2193 def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[DriverOption]>;
2194 def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[DriverOption]>;
2195 def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[DriverOption]>;
2196 def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[DriverOption]>;
2197 def mthreads : Joined<["-"], "mthreads">, Group<m_Group>, Flags<[DriverOption]>;
2198 def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>;
2199 def mmcu_EQ : Joined<["-"], "mmcu=">, Group<m_Group>;
2200 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
2201 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
2202 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
2203 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
2204 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
2205 def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>,
2206 HelpText<"Align doubles to two words in structs (x86 only)">;
2207 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">;
2208 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
2209 def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
2210 def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>;
2211 def mhwmult_EQ : Joined<["-"], "mhwmult=">, Group<m_Group>;
2212 def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>, Flags<[CC1Option]>,
2213 HelpText<"Enable merging of globals">;
2214 def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>;
2215 def miphoneos_version_min_EQ : Joined<["-"], "miphoneos-version-min=">, Group<m_Group>;
2216 def mios_version_min_EQ : Joined<["-"], "mios-version-min=">,
2217 Alias<miphoneos_version_min_EQ>, HelpText<"Set iOS deployment target">;
2218 def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">;
2219 def miphonesimulator_version_min_EQ : Joined<["-"], "miphonesimulator-version-min=">, Alias<mios_simulator_version_min_EQ>;
2220 def mkernel : Flag<["-"], "mkernel">, Group<m_Group>;
2221 def mlinker_version_EQ : Joined<["-"], "mlinker-version=">,
2222 Flags<[DriverOption]>;
2223 def mllvm : Separate<["-"], "mllvm">, Flags<[CC1Option,CC1AsOption,CoreOption]>,
2224 HelpText<"Additional arguments to forward to LLVM's option processing">;
2225 def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">,
2226 Group<m_Group>, HelpText<"Set Mac OS X deployment target">;
2227 def mmacos_version_min_EQ : Joined<["-"], "mmacos-version-min=">,
2228 Group<m_Group>, Alias<mmacosx_version_min_EQ>;
2229 def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>,
2230 HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">;
2231 def moutline : Flag<["-"], "moutline">, Group<f_clang_Group>, Flags<[CC1Option]>,
2232 HelpText<"Enable function outlining (AArch64 only)">;
2233 def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Option]>,
2234 HelpText<"Disable function outlining (AArch64 only)">;
2235 def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>,
2236 HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">;
2237 def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>,
2238 HelpText<"Force realign the stack at entry to every function">;
2239 def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>,
2240 HelpText<"Set the stack alignment">;
2241 def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>,
2242 HelpText<"Set the stack probe size">;
2243 def mstack_arg_probe : Flag<["-"], "mstack-arg-probe">, Group<m_Group>,
2244 HelpText<"Enable stack probes">;
2245 def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>,
2246 HelpText<"Disable stack probes which are enabled by default">;
2247 def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,
2248 HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">;
2249 def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>,
2250 HelpText<"Set EABI type, e.g. 4, 5 or gnu (default depends on triple)">, Values<"default,4,5,gnu">;
2252 def mno_constant_cfstrings : Flag<["-"], "mno-constant-cfstrings">, Group<m_Group>;
2253 def mno_global_merge : Flag<["-"], "mno-global-merge">, Group<m_Group>, Flags<[CC1Option]>,
2254 HelpText<"Disable merging of globals">;
2255 def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">,
2256 Alias<fno_pascal_strings>;
2257 def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>;
2258 def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group<m_Group>, Flags<[CC1Option]>,
2259 HelpText<"Disable direct TLS access through segment registers">;
2260 def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>;
2261 def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>;
2262 def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>;
2263 def mno_stackrealign : Flag<["-"], "mno-stackrealign">, Group<m_Group>;
2265 def mretpoline : Flag<["-"], "mretpoline">, Group<m_Group>, Flags<[CoreOption,DriverOption]>;
2266 def mno_retpoline : Flag<["-"], "mno-retpoline">, Group<m_Group>, Flags<[CoreOption,DriverOption]>;
2267 def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">,
2268 Group<m_Group>, Flags<[CoreOption,CC1Option]>;
2269 def mno_speculative_load_hardening : Flag<["-"], "mno-speculative-load-hardening">,
2270 Group<m_Group>, Flags<[CoreOption]>;
2271 def mlvi_hardening : Flag<["-"], "mlvi-hardening">, Group<m_Group>, Flags<[CoreOption,DriverOption]>,
2272 HelpText<"Enable all mitigations for Load Value Injection (LVI)">;
2273 def mno_lvi_hardening : Flag<["-"], "mno-lvi-hardening">, Group<m_Group>, Flags<[CoreOption,DriverOption]>,
2274 HelpText<"Disable mitigations for Load Value Injection (LVI)">;
2275 def mlvi_cfi : Flag<["-"], "mlvi-cfi">, Group<m_Group>, Flags<[CoreOption,DriverOption]>,
2276 HelpText<"Enable only control-flow mitigations for Load Value Injection (LVI)">;
2277 def mno_lvi_cfi : Flag<["-"], "mno-lvi-cfi">, Group<m_Group>, Flags<[CoreOption,DriverOption]>,
2278 HelpText<"Disable control-flow mitigations for Load Value Injection (LVI)">;
2279 def m_seses : Flag<["-"], "mseses">, Group<m_Group>, Flags<[CoreOption, DriverOption]>,
2280 HelpText<"Enable speculative execution side effect suppression (SESES). "
2281 "Includes LVI control flow integrity mitigations">;
2282 def mno_seses : Flag<["-"], "mno-seses">, Group<m_Group>, Flags<[CoreOption, DriverOption]>,
2283 HelpText<"Disable speculative execution side effect suppression (SESES)">;
2285 def mrelax : Flag<["-"], "mrelax">, Group<m_riscv_Features_Group>,
2286 HelpText<"Enable linker relaxation">;
2287 def mno_relax : Flag<["-"], "mno-relax">, Group<m_riscv_Features_Group>,
2288 HelpText<"Disable linker relaxation">;
2289 def msmall_data_limit_EQ : Joined<["-"], "msmall-data-limit=">, Group<m_Group>,
2291 HelpText<"Put global and static data smaller than the limit into a special section">;
2292 def msave_restore : Flag<["-"], "msave-restore">, Group<m_riscv_Features_Group>,
2293 HelpText<"Enable using library calls for save and restore">;
2294 def mno_save_restore : Flag<["-"], "mno-save-restore">, Group<m_riscv_Features_Group>,
2295 HelpText<"Disable using library calls for save and restore">;
2296 def mcmodel_EQ_medlow : Flag<["-"], "mcmodel=medlow">, Group<m_riscv_Features_Group>,
2297 Flags<[CC1Option]>, Alias<mcmodel_EQ>, AliasArgs<["small"]>,
2298 HelpText<"Equivalent to -mcmodel=small, compatible with RISC-V gcc.">;
2299 def mcmodel_EQ_medany : Flag<["-"], "mcmodel=medany">, Group<m_riscv_Features_Group>,
2300 Flags<[CC1Option]>, Alias<mcmodel_EQ>, AliasArgs<["medium"]>,
2301 HelpText<"Equivalent to -mcmodel=medium, compatible with RISC-V gcc.">;
2302 def menable_experimental_extensions : Flag<["-"], "menable-experimental-extensions">, Group<m_Group>,
2303 HelpText<"Enable use of experimental RISC-V extensions.">;
2305 def munaligned_access : Flag<["-"], "munaligned-access">, Group<m_arm_Features_Group>,
2306 HelpText<"Allow memory accesses to be unaligned (AArch32/AArch64 only)">;
2307 def mno_unaligned_access : Flag<["-"], "mno-unaligned-access">, Group<m_arm_Features_Group>,
2308 HelpText<"Force all memory accesses to be aligned (AArch32/AArch64 only)">;
2309 def mstrict_align : Flag<["-"], "mstrict-align">, Alias<mno_unaligned_access>, Flags<[CC1Option,HelpHidden]>,
2310 HelpText<"Force all memory accesses to be aligned (same as mno-unaligned-access)">;
2311 def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_arm_Features_Group>;
2312 def mrestrict_it: Flag<["-"], "mrestrict-it">, Group<m_arm_Features_Group>,
2313 HelpText<"Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.">;
2314 def mno_restrict_it: Flag<["-"], "mno-restrict-it">, Group<m_arm_Features_Group>,
2315 HelpText<"Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode">;
2316 def marm : Flag<["-"], "marm">, Alias<mno_thumb>;
2317 def ffixed_r9 : Flag<["-"], "ffixed-r9">, Group<m_arm_Features_Group>,
2318 HelpText<"Reserve the r9 register (ARM only)">;
2319 def mno_movt : Flag<["-"], "mno-movt">, Group<m_arm_Features_Group>,
2320 HelpText<"Disallow use of movt/movw pairs (ARM only)">;
2321 def mcrc : Flag<["-"], "mcrc">, Group<m_Group>,
2322 HelpText<"Allow use of CRC instructions (ARM/Mips only)">;
2323 def mnocrc : Flag<["-"], "mnocrc">, Group<m_arm_Features_Group>,
2324 HelpText<"Disallow use of CRC instructions (ARM only)">;
2325 def mno_neg_immediates: Flag<["-"], "mno-neg-immediates">, Group<m_arm_Features_Group>,
2326 HelpText<"Disallow converting instructions with negative immediates to their negation or inversion.">;
2327 def mcmse : Flag<["-"], "mcmse">, Group<m_arm_Features_Group>,
2328 Flags<[DriverOption,CC1Option]>,
2329 HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">;
2330 def ForceAAPCSBitfieldLoad : Flag<["-"], "fAAPCSBitfieldLoad">, Group<m_arm_Features_Group>,
2331 Flags<[DriverOption,CC1Option]>,
2332 HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">;
2334 def mgeneral_regs_only : Flag<["-"], "mgeneral-regs-only">, Group<m_aarch64_Features_Group>,
2335 HelpText<"Generate code which only uses the general purpose registers (AArch64 only)">;
2336 def mfix_cortex_a53_835769 : Flag<["-"], "mfix-cortex-a53-835769">,
2337 Group<m_aarch64_Features_Group>,
2338 HelpText<"Workaround Cortex-A53 erratum 835769 (AArch64 only)">;
2339 def mno_fix_cortex_a53_835769 : Flag<["-"], "mno-fix-cortex-a53-835769">,
2340 Group<m_aarch64_Features_Group>,
2341 HelpText<"Don't workaround Cortex-A53 erratum 835769 (AArch64 only)">;
2342 foreach i = {1-31} in
2343 def ffixed_x#i : Flag<["-"], "ffixed-x"#i>, Group<m_Group>,
2344 HelpText<"Reserve the x"#i#" register (AArch64/RISC-V only)">;
2346 foreach i = {8-15,18} in
2347 def fcall_saved_x#i : Flag<["-"], "fcall-saved-x"#i>, Group<m_aarch64_Features_Group>,
2348 HelpText<"Make the x"#i#" register call-saved (AArch64 only)">;
2350 def msign_return_address_EQ : Joined<["-"], "msign-return-address=">,
2351 Flags<[CC1Option]>, Group<m_Group>, Values<"none,all,non-leaf">,
2352 HelpText<"Select return address signing scope">;
2353 def mbranch_protection_EQ : Joined<["-"], "mbranch-protection=">,
2354 HelpText<"Enforce targets of indirect branches and function returns">;
2356 def mharden_sls_EQ : Joined<["-"], "mharden-sls=">,
2357 HelpText<"Select straight-line speculation hardening scope">;
2359 def msimd128 : Flag<["-"], "msimd128">, Group<m_wasm_Features_Group>;
2360 def munimplemented_simd128 : Flag<["-"], "munimplemented-simd128">, Group<m_wasm_Features_Group>;
2361 def mno_unimplemented_simd128 : Flag<["-"], "mno-unimplemented-simd128">, Group<m_wasm_Features_Group>;
2362 def mno_simd128 : Flag<["-"], "mno-simd128">, Group<m_wasm_Features_Group>;
2363 def mnontrapping_fptoint : Flag<["-"], "mnontrapping-fptoint">, Group<m_wasm_Features_Group>;
2364 def mno_nontrapping_fptoint : Flag<["-"], "mno-nontrapping-fptoint">, Group<m_wasm_Features_Group>;
2365 def msign_ext : Flag<["-"], "msign-ext">, Group<m_wasm_Features_Group>;
2366 def mno_sign_ext : Flag<["-"], "mno-sign-ext">, Group<m_wasm_Features_Group>;
2367 def mexception_handing : Flag<["-"], "mexception-handling">, Group<m_wasm_Features_Group>;
2368 def mno_exception_handing : Flag<["-"], "mno-exception-handling">, Group<m_wasm_Features_Group>;
2369 def matomics : Flag<["-"], "matomics">, Group<m_wasm_Features_Group>;
2370 def mno_atomics : Flag<["-"], "mno-atomics">, Group<m_wasm_Features_Group>;
2371 def mbulk_memory : Flag<["-"], "mbulk-memory">, Group<m_wasm_Features_Group>;
2372 def mno_bulk_memory : Flag<["-"], "mno-bulk-memory">, Group<m_wasm_Features_Group>;
2373 def mmutable_globals : Flag<["-"], "mmutable-globals">, Group<m_wasm_Features_Group>;
2374 def mno_mutable_globals : Flag<["-"], "mno-mutable-globals">, Group<m_wasm_Features_Group>;
2375 def mmultivalue : Flag<["-"], "mmultivalue">, Group<m_wasm_Features_Group>;
2376 def mno_multivalue : Flag<["-"], "mno-multivalue">, Group<m_wasm_Features_Group>;
2377 def mtail_call : Flag<["-"], "mtail-call">, Group<m_wasm_Features_Group>;
2378 def mno_tail_call : Flag<["-"], "mno-tail-call">, Group<m_wasm_Features_Group>;
2379 def mreference_types : Flag<["-"], "mreference-types">, Group<m_wasm_Features_Group>;
2380 def mno_reference_types : Flag<["-"], "mno-reference-types">, Group<m_wasm_Features_Group>;
2381 def mexec_model_EQ : Joined<["-"], "mexec-model=">, Group<m_wasm_Features_Driver_Group>,
2382 Values<"command,reactor">,
2383 HelpText<"Execution model (WebAssembly only)">;
2385 def mamdgpu_debugger_abi : Joined<["-"], "mamdgpu-debugger-abi=">,
2386 Flags<[HelpHidden]>,
2388 HelpText<"Generate additional code for specified <version> of debugger ABI (AMDGPU only)">,
2389 MetaVarName<"<version>">;
2391 def mcode_object_v3 : Flag<["-"], "mcode-object-v3">, Group<m_amdgpu_Features_Group>,
2392 HelpText<"Enable code object v3 (AMDGPU only)">;
2393 def mno_code_object_v3 : Flag<["-"], "mno-code-object-v3">, Group<m_amdgpu_Features_Group>,
2394 HelpText<"Disable code object v3 (AMDGPU only)">;
2395 def mxnack : Flag<["-"], "mxnack">, Group<m_amdgpu_Features_Group>,
2396 HelpText<"Enable XNACK (AMDGPU only)">;
2397 def mno_xnack : Flag<["-"], "mno-xnack">, Group<m_amdgpu_Features_Group>,
2398 HelpText<"Disable XNACK (AMDGPU only)">;
2399 def msram_ecc : Flag<["-"], "msram-ecc">, Group<m_amdgpu_Features_Group>,
2400 HelpText<"Enable SRAM ECC (AMDGPU only)">;
2401 def mno_sram_ecc : Flag<["-"], "mno-sram-ecc">, Group<m_amdgpu_Features_Group>,
2402 HelpText<"Disable SRAM ECC (AMDGPU only)">;
2404 def mcumode : Flag<["-"], "mcumode">, Group<m_amdgpu_Features_Group>,
2405 HelpText<"CU wavefront execution mode is used (AMDGPU only)">;
2406 def mno_cumode : Flag<["-"], "mno-cumode">, Group<m_amdgpu_Features_Group>,
2407 HelpText<"WGP wavefront execution mode is used (AMDGPU only)">;
2409 def mwavefrontsize64 : Flag<["-"], "mwavefrontsize64">,
2410 Group<m_Group>, HelpText<"Wavefront size 64 is used">;
2411 def mno_wavefrontsize64 : Flag<["-"], "mno-wavefrontsize64">,
2412 Group<m_Group>, HelpText<"Wavefront size 32 is used">;
2414 def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[DriverOption]>;
2415 def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[DriverOption]>;
2416 def maltivec : Flag<["-"], "maltivec">, Group<m_ppc_Features_Group>;
2417 def mno_altivec : Flag<["-"], "mno-altivec">, Group<m_ppc_Features_Group>;
2418 def mpcrel: Flag<["-"], "mpcrel">, Group<m_ppc_Features_Group>;
2419 def mno_pcrel: Flag<["-"], "mno-pcrel">, Group<m_ppc_Features_Group>;
2420 def mspe : Flag<["-"], "mspe">, Group<m_ppc_Features_Group>;
2421 def mno_spe : Flag<["-"], "mno-spe">, Group<m_ppc_Features_Group>;
2422 def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>;
2423 def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>;
2424 def msecure_plt : Flag<["-"], "msecure-plt">, Group<m_ppc_Features_Group>;
2425 def mpower8_vector : Flag<["-"], "mpower8-vector">,
2426 Group<m_ppc_Features_Group>;
2427 def mno_power8_vector : Flag<["-"], "mno-power8-vector">,
2428 Group<m_ppc_Features_Group>;
2429 def mpower9_vector : Flag<["-"], "mpower9-vector">,
2430 Group<m_ppc_Features_Group>;
2431 def mno_power9_vector : Flag<["-"], "mno-power9-vector">,
2432 Group<m_ppc_Features_Group>;
2433 def mpower10_vector : Flag<["-"], "mpower10-vector">,
2434 Group<m_ppc_Features_Group>;
2435 def mno_power10_vector : Flag<["-"], "mno-power10-vector">,
2436 Group<m_ppc_Features_Group>;
2437 def mpower8_crypto : Flag<["-"], "mcrypto">,
2438 Group<m_ppc_Features_Group>;
2439 def mnopower8_crypto : Flag<["-"], "mno-crypto">,
2440 Group<m_ppc_Features_Group>;
2441 def mdirect_move : Flag<["-"], "mdirect-move">,
2442 Group<m_ppc_Features_Group>;
2443 def mnodirect_move : Flag<["-"], "mno-direct-move">,
2444 Group<m_ppc_Features_Group>;
2445 def mhtm : Flag<["-"], "mhtm">, Group<m_ppc_Features_Group>;
2446 def mno_htm : Flag<["-"], "mno-htm">, Group<m_ppc_Features_Group>;
2447 def mfprnd : Flag<["-"], "mfprnd">, Group<m_ppc_Features_Group>;
2448 def mno_fprnd : Flag<["-"], "mno-fprnd">, Group<m_ppc_Features_Group>;
2449 def mcmpb : Flag<["-"], "mcmpb">, Group<m_ppc_Features_Group>;
2450 def mno_cmpb : Flag<["-"], "mno-cmpb">, Group<m_ppc_Features_Group>;
2451 def misel : Flag<["-"], "misel">, Group<m_ppc_Features_Group>;
2452 def mno_isel : Flag<["-"], "mno-isel">, Group<m_ppc_Features_Group>;
2453 def mmfocrf : Flag<["-"], "mmfocrf">, Group<m_ppc_Features_Group>;
2454 def mmfcrf : Flag<["-"], "mmfcrf">, Alias<mmfocrf>;
2455 def mno_mfocrf : Flag<["-"], "mno-mfocrf">, Group<m_ppc_Features_Group>;
2456 def mno_mfcrf : Flag<["-"], "mno-mfcrf">, Alias<mno_mfocrf>;
2457 def mpopcntd : Flag<["-"], "mpopcntd">, Group<m_ppc_Features_Group>;
2458 def mno_popcntd : Flag<["-"], "mno-popcntd">, Group<m_ppc_Features_Group>;
2459 def mqpx : Flag<["-"], "mqpx">, Group<m_ppc_Features_Group>;
2460 def mno_qpx : Flag<["-"], "mno-qpx">, Group<m_ppc_Features_Group>;
2461 def mcrbits : Flag<["-"], "mcrbits">, Group<m_ppc_Features_Group>;
2462 def mno_crbits : Flag<["-"], "mno-crbits">, Group<m_ppc_Features_Group>;
2463 def minvariant_function_descriptors :
2464 Flag<["-"], "minvariant-function-descriptors">, Group<m_ppc_Features_Group>;
2465 def mno_invariant_function_descriptors :
2466 Flag<["-"], "mno-invariant-function-descriptors">,
2467 Group<m_ppc_Features_Group>;
2468 def mfloat128: Flag<["-"], "mfloat128">,
2469 Group<m_ppc_Features_Group>;
2470 def mno_float128 : Flag<["-"], "mno-float128">,
2471 Group<m_ppc_Features_Group>;
2472 def mlongcall: Flag<["-"], "mlongcall">,
2473 Group<m_ppc_Features_Group>;
2474 def mno_longcall : Flag<["-"], "mno-longcall">,
2475 Group<m_ppc_Features_Group>;
2476 def maix_struct_return : Flag<["-"], "maix-struct-return">,
2477 Group<m_Group>, Flags<[CC1Option]>,
2478 HelpText<"Return all structs in memory (PPC32 only)">;
2479 def msvr4_struct_return : Flag<["-"], "msvr4-struct-return">,
2480 Group<m_Group>, Flags<[CC1Option]>,
2481 HelpText<"Return small structs in registers (PPC32 only)">;
2483 def mvx : Flag<["-"], "mvx">, Group<m_Group>;
2484 def mno_vx : Flag<["-"], "mno-vx">, Group<m_Group>;
2486 defm zvector : OptInFFlag<"zvector", "Enable System z vector language extension">;
2487 def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>;
2488 def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>;
2490 def mbackchain : Flag<["-"], "mbackchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
2491 HelpText<"Link stack frames through backchain on System Z">;
2492 def mno_backchain : Flag<["-"], "mno-backchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>;
2494 def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>;
2495 def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>;
2496 def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>,
2497 HelpText<"Omit frame pointer setup for leaf functions">;
2498 def moslib_EQ : Joined<["-"], "moslib=">, Group<m_Group>;
2499 def mpascal_strings : Flag<["-"], "mpascal-strings">, Alias<fpascal_strings>;
2500 def mred_zone : Flag<["-"], "mred-zone">, Group<m_Group>;
2501 def mtls_direct_seg_refs : Flag<["-"], "mtls-direct-seg-refs">, Group<m_Group>,
2502 HelpText<"Enable direct TLS access through segment registers (default)">;
2503 def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>;
2504 def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>,
2505 HelpText<"(integrated-as) Relax all machine instructions">;
2506 def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group<m_Group>,
2507 Flags<[CC1Option,CC1AsOption]>,
2508 HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">;
2509 def mno_incremental_linker_compatible : Flag<["-"], "mno-incremental-linker-compatible">, Group<m_Group>,
2510 HelpText<"(integrated-as) Emit an object file which cannot be used with an incremental linker">;
2511 def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>,
2512 HelpText<"Make StdCall calling convention the default">;
2513 def msmall_data_threshold_EQ : Joined <["-"], "msmall-data-threshold=">,
2514 Group<m_Group>, Alias<G>;
2515 def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>,
2516 HelpText<"Use software floating point">;
2517 def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>,
2518 HelpText<"Don't generate implicit floating point instructions">;
2519 def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>;
2520 def mrecip : Flag<["-"], "mrecip">, Group<m_Group>;
2521 def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>;
2522 def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>,
2523 HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">;
2524 def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>,
2526 HelpText<"Use copy relocations support for PIE builds">;
2527 def mno_pie_copy_relocations : Flag<["-"], "mno-pie-copy-relocations">, Group<m_Group>;
2528 def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86/SystemZ only)">,
2529 Flags<[CC1Option]>, Group<m_Group>;
2530 def mnop_mcount : Flag<["-"], "mnop-mcount">, HelpText<"Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.">,
2531 Flags<[CC1Option]>, Group<m_Group>;
2532 def mrecord_mcount : Flag<["-"], "mrecord-mcount">, HelpText<"Generate a __mcount_loc section entry for each __fentry__ call.">,
2533 Flags<[CC1Option]>, Group<m_Group>;
2534 def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">,
2535 Flags<[CC1Option]>, Group<m_Group>;
2536 def mno_packed_stack : Flag<["-"], "mno-packed-stack">, Flags<[CC1Option]>, Group<m_Group>;
2537 def mips16 : Flag<["-"], "mips16">, Group<m_mips_Features_Group>;
2538 def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_mips_Features_Group>;
2539 def mmicromips : Flag<["-"], "mmicromips">, Group<m_mips_Features_Group>;
2540 def mno_micromips : Flag<["-"], "mno-micromips">, Group<m_mips_Features_Group>;
2541 def mxgot : Flag<["-"], "mxgot">, Group<m_mips_Features_Group>;
2542 def mno_xgot : Flag<["-"], "mno-xgot">, Group<m_mips_Features_Group>;
2543 def mldc1_sdc1 : Flag<["-"], "mldc1-sdc1">, Group<m_mips_Features_Group>;
2544 def mno_ldc1_sdc1 : Flag<["-"], "mno-ldc1-sdc1">, Group<m_mips_Features_Group>;
2545 def mcheck_zero_division : Flag<["-"], "mcheck-zero-division">,
2546 Group<m_mips_Features_Group>;
2547 def mno_check_zero_division : Flag<["-"], "mno-check-zero-division">,
2548 Group<m_mips_Features_Group>;
2549 def mcompact_branches_EQ : Joined<["-"], "mcompact-branches=">,
2550 Group<m_mips_Features_Group>;
2551 def mbranch_likely : Flag<["-"], "mbranch-likely">, Group<m_Group>,
2553 def mno_branch_likely : Flag<["-"], "mno-branch-likely">, Group<m_Group>,
2555 def mindirect_jump_EQ : Joined<["-"], "mindirect-jump=">,
2556 Group<m_mips_Features_Group>,
2557 HelpText<"Change indirect jump instructions to inhibit speculation">;
2558 def mdsp : Flag<["-"], "mdsp">, Group<m_mips_Features_Group>;
2559 def mno_dsp : Flag<["-"], "mno-dsp">, Group<m_mips_Features_Group>;
2560 def mdspr2 : Flag<["-"], "mdspr2">, Group<m_mips_Features_Group>;
2561 def mno_dspr2 : Flag<["-"], "mno-dspr2">, Group<m_mips_Features_Group>;
2562 def msingle_float : Flag<["-"], "msingle-float">, Group<m_mips_Features_Group>;
2563 def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_mips_Features_Group>;
2564 def mmadd4 : Flag<["-"], "mmadd4">, Group<m_mips_Features_Group>,
2565 HelpText<"Enable the generation of 4-operand madd.s, madd.d and related instructions.">;
2566 def mno_madd4 : Flag<["-"], "mno-madd4">, Group<m_mips_Features_Group>,
2567 HelpText<"Disable the generation of 4-operand madd.s, madd.d and related instructions.">;
2568 def mmsa : Flag<["-"], "mmsa">, Group<m_mips_Features_Group>,
2569 HelpText<"Enable MSA ASE (MIPS only)">;
2570 def mno_msa : Flag<["-"], "mno-msa">, Group<m_mips_Features_Group>,
2571 HelpText<"Disable MSA ASE (MIPS only)">;
2572 def mmt : Flag<["-"], "mmt">, Group<m_mips_Features_Group>,
2573 HelpText<"Enable MT ASE (MIPS only)">;
2574 def mno_mt : Flag<["-"], "mno-mt">, Group<m_mips_Features_Group>,
2575 HelpText<"Disable MT ASE (MIPS only)">;
2576 def mfp64 : Flag<["-"], "mfp64">, Group<m_mips_Features_Group>,
2577 HelpText<"Use 64-bit floating point registers (MIPS only)">;
2578 def mfp32 : Flag<["-"], "mfp32">, Group<m_mips_Features_Group>,
2579 HelpText<"Use 32-bit floating point registers (MIPS only)">;
2580 def mgpopt : Flag<["-"], "mgpopt">, Group<m_mips_Features_Group>,
2581 HelpText<"Use GP relative accesses for symbols known to be in a small"
2582 " data section (MIPS)">;
2583 def mno_gpopt : Flag<["-"], "mno-gpopt">, Group<m_mips_Features_Group>,
2584 HelpText<"Do not use GP relative accesses for symbols known to be in a small"
2585 " data section (MIPS)">;
2586 def mlocal_sdata : Flag<["-"], "mlocal-sdata">,
2587 Group<m_mips_Features_Group>,
2588 HelpText<"Extend the -G behaviour to object local data (MIPS)">;
2589 def mno_local_sdata : Flag<["-"], "mno-local-sdata">,
2590 Group<m_mips_Features_Group>,
2591 HelpText<"Do not extend the -G behaviour to object local data (MIPS)">;
2592 def mextern_sdata : Flag<["-"], "mextern-sdata">,
2593 Group<m_mips_Features_Group>,
2594 HelpText<"Assume that externally defined data is in the small data if it"
2595 " meets the -G <size> threshold (MIPS)">;
2596 def mno_extern_sdata : Flag<["-"], "mno-extern-sdata">,
2597 Group<m_mips_Features_Group>,
2598 HelpText<"Do not assume that externally defined data is in the small data if"
2599 " it meets the -G <size> threshold (MIPS)">;
2600 def membedded_data : Flag<["-"], "membedded-data">,
2601 Group<m_mips_Features_Group>,
2602 HelpText<"Place constants in the .rodata section instead of the .sdata "
2603 "section even if they meet the -G <size> threshold (MIPS)">;
2604 def mno_embedded_data : Flag<["-"], "mno-embedded-data">,
2605 Group<m_mips_Features_Group>,
2606 HelpText<"Do not place constants in the .rodata section instead of the "
2607 ".sdata if they meet the -G <size> threshold (MIPS)">;
2608 def mnan_EQ : Joined<["-"], "mnan=">, Group<m_mips_Features_Group>;
2609 def mabs_EQ : Joined<["-"], "mabs=">, Group<m_mips_Features_Group>;
2610 def mabicalls : Flag<["-"], "mabicalls">, Group<m_mips_Features_Group>,
2611 HelpText<"Enable SVR4-style position-independent code (Mips only)">;
2612 def mno_abicalls : Flag<["-"], "mno-abicalls">, Group<m_mips_Features_Group>,
2613 HelpText<"Disable SVR4-style position-independent code (Mips only)">;
2614 def mno_crc : Flag<["-"], "mno-crc">, Group<m_mips_Features_Group>,
2615 HelpText<"Disallow use of CRC instructions (Mips only)">;
2616 def mvirt : Flag<["-"], "mvirt">, Group<m_mips_Features_Group>;
2617 def mno_virt : Flag<["-"], "mno-virt">, Group<m_mips_Features_Group>;
2618 def mginv : Flag<["-"], "mginv">, Group<m_mips_Features_Group>;
2619 def mno_ginv : Flag<["-"], "mno-ginv">, Group<m_mips_Features_Group>;
2620 def mips1 : Flag<["-"], "mips1">,
2621 Alias<march_EQ>, AliasArgs<["mips1"]>, Group<m_mips_Features_Group>,
2622 HelpText<"Equivalent to -march=mips1">, Flags<[HelpHidden]>;
2623 def mips2 : Flag<["-"], "mips2">,
2624 Alias<march_EQ>, AliasArgs<["mips2"]>, Group<m_mips_Features_Group>,
2625 HelpText<"Equivalent to -march=mips2">, Flags<[HelpHidden]>;
2626 def mips3 : Flag<["-"], "mips3">,
2627 Alias<march_EQ>, AliasArgs<["mips3"]>, Group<m_mips_Features_Group>,
2628 HelpText<"Equivalent to -march=mips3">, Flags<[HelpHidden]>;
2629 def mips4 : Flag<["-"], "mips4">,
2630 Alias<march_EQ>, AliasArgs<["mips4"]>, Group<m_mips_Features_Group>,
2631 HelpText<"Equivalent to -march=mips4">, Flags<[HelpHidden]>;
2632 def mips5 : Flag<["-"], "mips5">,
2633 Alias<march_EQ>, AliasArgs<["mips5"]>, Group<m_mips_Features_Group>,
2634 HelpText<"Equivalent to -march=mips5">, Flags<[HelpHidden]>;
2635 def mips32 : Flag<["-"], "mips32">,
2636 Alias<march_EQ>, AliasArgs<["mips32"]>, Group<m_mips_Features_Group>,
2637 HelpText<"Equivalent to -march=mips32">, Flags<[HelpHidden]>;
2638 def mips32r2 : Flag<["-"], "mips32r2">,
2639 Alias<march_EQ>, AliasArgs<["mips32r2"]>, Group<m_mips_Features_Group>,
2640 HelpText<"Equivalent to -march=mips32r2">, Flags<[HelpHidden]>;
2641 def mips32r3 : Flag<["-"], "mips32r3">,
2642 Alias<march_EQ>, AliasArgs<["mips32r3"]>, Group<m_mips_Features_Group>,
2643 HelpText<"Equivalent to -march=mips32r3">, Flags<[HelpHidden]>;
2644 def mips32r5 : Flag<["-"], "mips32r5">,
2645 Alias<march_EQ>, AliasArgs<["mips32r5"]>, Group<m_mips_Features_Group>,
2646 HelpText<"Equivalent to -march=mips32r5">, Flags<[HelpHidden]>;
2647 def mips32r6 : Flag<["-"], "mips32r6">,
2648 Alias<march_EQ>, AliasArgs<["mips32r6"]>, Group<m_mips_Features_Group>,
2649 HelpText<"Equivalent to -march=mips32r6">, Flags<[HelpHidden]>;
2650 def mips64 : Flag<["-"], "mips64">,
2651 Alias<march_EQ>, AliasArgs<["mips64"]>, Group<m_mips_Features_Group>,
2652 HelpText<"Equivalent to -march=mips64">, Flags<[HelpHidden]>;
2653 def mips64r2 : Flag<["-"], "mips64r2">,
2654 Alias<march_EQ>, AliasArgs<["mips64r2"]>, Group<m_mips_Features_Group>,
2655 HelpText<"Equivalent to -march=mips64r2">, Flags<[HelpHidden]>;
2656 def mips64r3 : Flag<["-"], "mips64r3">,
2657 Alias<march_EQ>, AliasArgs<["mips64r3"]>, Group<m_mips_Features_Group>,
2658 HelpText<"Equivalent to -march=mips64r3">, Flags<[HelpHidden]>;
2659 def mips64r5 : Flag<["-"], "mips64r5">,
2660 Alias<march_EQ>, AliasArgs<["mips64r5"]>, Group<m_mips_Features_Group>,
2661 HelpText<"Equivalent to -march=mips64r5">, Flags<[HelpHidden]>;
2662 def mips64r6 : Flag<["-"], "mips64r6">,
2663 Alias<march_EQ>, AliasArgs<["mips64r6"]>, Group<m_mips_Features_Group>,
2664 HelpText<"Equivalent to -march=mips64r6">, Flags<[HelpHidden]>;
2665 def mfpxx : Flag<["-"], "mfpxx">, Group<m_mips_Features_Group>,
2666 HelpText<"Avoid FPU mode dependent operations when used with the O32 ABI">,
2667 Flags<[HelpHidden]>;
2668 def modd_spreg : Flag<["-"], "modd-spreg">, Group<m_mips_Features_Group>,
2669 HelpText<"Enable odd single-precision floating point registers">,
2670 Flags<[HelpHidden]>;
2671 def mno_odd_spreg : Flag<["-"], "mno-odd-spreg">, Group<m_mips_Features_Group>,
2672 HelpText<"Disable odd single-precision floating point registers">,
2673 Flags<[HelpHidden]>;
2674 def mrelax_pic_calls : Flag<["-"], "mrelax-pic-calls">,
2675 Group<m_mips_Features_Group>,
2676 HelpText<"Produce relaxation hints for linkers to try optimizing PIC "
2677 "call sequences into direct calls (MIPS only)">, Flags<[HelpHidden]>;
2678 def mno_relax_pic_calls : Flag<["-"], "mno-relax-pic-calls">,
2679 Group<m_mips_Features_Group>,
2680 HelpText<"Do not produce relaxation hints for linkers to try optimizing PIC "
2681 "call sequences into direct calls (MIPS only)">, Flags<[HelpHidden]>;
2682 def mglibc : Flag<["-"], "mglibc">, Group<m_libc_Group>, Flags<[HelpHidden]>;
2683 def muclibc : Flag<["-"], "muclibc">, Group<m_libc_Group>, Flags<[HelpHidden]>;
2684 def module_file_info : Flag<["-"], "module-file-info">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
2685 HelpText<"Provide information about a particular module file">;
2686 def mthumb : Flag<["-"], "mthumb">, Group<m_Group>;
2687 def mtune_EQ : Joined<["-"], "mtune=">, Group<m_Group>,
2688 HelpText<"Accepted for compatibility with GCC. Currently has no effect.">;
2689 def multi__module : Flag<["-"], "multi_module">;
2690 def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
2691 def multiply__defined : Separate<["-"], "multiply_defined">;
2692 def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
2693 def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
2694 HelpText<"Use relative instead of canonical paths">;
2695 def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
2696 def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
2697 def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
2698 def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
2699 def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>,
2700 HelpText<"Disable builtin #include directories">;
2701 def nogpuinc : Flag<["-"], "nogpuinc">;
2702 def : Flag<["-"], "nocudainc">, Alias<nogpuinc>;
2703 def nogpulib : Flag<["-"], "nogpulib">,
2704 HelpText<"Do not link device library for CUDA/HIP device compilation">;
2705 def : Flag<["-"], "nocudalib">, Alias<nogpulib>;
2706 def nodefaultlibs : Flag<["-"], "nodefaultlibs">;
2707 def nofixprebinding : Flag<["-"], "nofixprebinding">;
2708 def nolibc : Flag<["-"], "nolibc">;
2709 def nomultidefs : Flag<["-"], "nomultidefs">;
2710 def nopie : Flag<["-"], "nopie">;
2711 def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
2712 def noprebind : Flag<["-"], "noprebind">;
2713 def noprofilelib : Flag<["-"], "noprofilelib">;
2714 def noseglinkedit : Flag<["-"], "noseglinkedit">;
2715 def nostartfiles : Flag<["-"], "nostartfiles">;
2716 def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
2717 def nostdlibinc : Flag<["-"], "nostdlibinc">;
2718 def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
2719 HelpText<"Disable standard #include directories for the C++ standard library">;
2720 def nostdlib : Flag<["-"], "nostdlib">;
2721 def nostdlibxx : Flag<["-"], "nostdlib++">;
2722 def object : Flag<["-"], "object">;
2723 def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
2724 HelpText<"Write output to <file>">, MetaVarName<"<file>">;
2725 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
2726 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
2727 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>;
2728 def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>;
2729 def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
2730 def pipe : Flag<["-", "--"], "pipe">,
2731 HelpText<"Use pipes between commands, when possible">;
2732 def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
2733 def prebind : Flag<["-"], "prebind">;
2734 def preload : Flag<["-"], "preload">;
2735 def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
2736 HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;
2737 def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>,
2738 HelpText<"Enable Objective-C Ivar layout bitmap print trace">;
2739 def print_libgcc_file_name : Flag<["-", "--"], "print-libgcc-file-name">,
2740 HelpText<"Print the library path for the currently used compiler runtime "
2741 "library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")">;
2742 def print_multi_directory : Flag<["-", "--"], "print-multi-directory">;
2743 def print_multi_lib : Flag<["-", "--"], "print-multi-lib">;
2744 def print_multi_os_directory : Flag<["-", "--"], "print-multi-os-directory">,
2745 Flags<[Unsupported]>;
2746 def print_target_triple : Flag<["-", "--"], "print-target-triple">,
2747 HelpText<"Print the normalized target triple">;
2748 def print_effective_triple : Flag<["-", "--"], "print-effective-triple">,
2749 HelpText<"Print the effective target triple">;
2750 def print_prog_name_EQ : Joined<["-", "--"], "print-prog-name=">,
2751 HelpText<"Print the full program path of <name>">, MetaVarName<"<name>">;
2752 def print_resource_dir : Flag<["-", "--"], "print-resource-dir">,
2753 HelpText<"Print the resource directory pathname">;
2754 def print_search_dirs : Flag<["-", "--"], "print-search-dirs">,
2755 HelpText<"Print the paths used for finding libraries and programs">;
2756 def print_targets : Flag<["-", "--"], "print-targets">,
2757 HelpText<"Print the registered targets">;
2758 def private__bundle : Flag<["-"], "private_bundle">;
2759 def pthreads : Flag<["-"], "pthreads">;
2760 def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>,
2761 HelpText<"Support POSIX threads in generated code">;
2762 def no_pthread : Flag<["-"], "no-pthread">, Flags<[CC1Option]>;
2763 def p : Flag<["-"], "p">;
2764 def pie : Flag<["-"], "pie">;
2765 def static_pie : Flag<["-"], "static-pie">;
2766 def read__only__relocs : Separate<["-"], "read_only_relocs">;
2767 def remap : Flag<["-"], "remap">;
2768 def rewrite_objc : Flag<["-"], "rewrite-objc">, Flags<[DriverOption,CC1Option]>,
2769 HelpText<"Rewrite Objective-C source to C++">, Group<Action_Group>;
2770 def rewrite_legacy_objc : Flag<["-"], "rewrite-legacy-objc">, Flags<[DriverOption]>,
2771 HelpText<"Rewrite Legacy Objective-C source to C++">;
2772 def rdynamic : Flag<["-"], "rdynamic">;
2773 def resource_dir : Separate<["-"], "resource-dir">,
2774 Flags<[DriverOption, CC1Option, CoreOption, HelpHidden]>,
2775 HelpText<"The directory which holds the compiler resource files">;
2776 def resource_dir_EQ : Joined<["-"], "resource-dir=">, Flags<[DriverOption, CoreOption]>,
2777 Alias<resource_dir>;
2778 def rpath : Separate<["-"], "rpath">, Flags<[LinkerInput]>, Group<Link_Group>;
2779 def rtlib_EQ : Joined<["-", "--"], "rtlib=">,
2780 HelpText<"Compiler runtime library to use">;
2781 def frtlib_add_rpath: Flag<["-"], "frtlib-add-rpath">, Flags<[NoArgumentUnused]>,
2782 HelpText<"Add -rpath with architecture-specific resource directory to the linker flags">;
2783 def fno_rtlib_add_rpath: Flag<["-"], "fno-rtlib-add-rpath">, Flags<[NoArgumentUnused]>,
2784 HelpText<"Do not add -rpath with architecture-specific resource directory to the linker flags">;
2785 def r : Flag<["-"], "r">, Flags<[LinkerInput,NoArgumentUnused]>,
2787 def save_temps_EQ : Joined<["-", "--"], "save-temps=">, Flags<[CC1Option, DriverOption]>,
2788 HelpText<"Save intermediate compilation results.">;
2789 def save_temps : Flag<["-", "--"], "save-temps">, Flags<[DriverOption]>,
2790 Alias<save_temps_EQ>, AliasArgs<["cwd"]>,
2791 HelpText<"Save intermediate compilation results">;
2792 def save_stats_EQ : Joined<["-", "--"], "save-stats=">, Flags<[DriverOption]>,
2793 HelpText<"Save llvm statistics.">;
2794 def save_stats : Flag<["-", "--"], "save-stats">, Flags<[DriverOption]>,
2795 Alias<save_stats_EQ>, AliasArgs<["cwd"]>,
2796 HelpText<"Save llvm statistics.">;
2797 def via_file_asm : Flag<["-", "--"], "via-file-asm">, InternalDebugOpt,
2798 HelpText<"Write assembly to file for input to assemble jobs">;
2799 def sectalign : MultiArg<["-"], "sectalign", 3>;
2800 def sectcreate : MultiArg<["-"], "sectcreate", 3>;
2801 def sectobjectsymbols : MultiArg<["-"], "sectobjectsymbols", 2>;
2802 def sectorder : MultiArg<["-"], "sectorder", 3>;
2803 def seg1addr : JoinedOrSeparate<["-"], "seg1addr">;
2804 def seg__addr__table__filename : Separate<["-"], "seg_addr_table_filename">;
2805 def seg__addr__table : Separate<["-"], "seg_addr_table">;
2806 def segaddr : MultiArg<["-"], "segaddr", 2>;
2807 def segcreate : MultiArg<["-"], "segcreate", 3>;
2808 def seglinkedit : Flag<["-"], "seglinkedit">;
2809 def segprot : MultiArg<["-"], "segprot", 3>;
2810 def segs__read__only__addr : Separate<["-"], "segs_read_only_addr">;
2811 def segs__read__write__addr : Separate<["-"], "segs_read_write_addr">;
2812 def segs__read__ : Joined<["-"], "segs_read_">;
2813 def shared_libgcc : Flag<["-"], "shared-libgcc">;
2814 def shared : Flag<["-", "--"], "shared">;
2815 def single__module : Flag<["-"], "single_module">;
2816 def specs_EQ : Joined<["-", "--"], "specs=">;
2817 def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
2818 def static_libgcc : Flag<["-"], "static-libgcc">;
2819 def static_libstdcxx : Flag<["-"], "static-libstdc++">;
2820 def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
2821 def std_default_EQ : Joined<["-"], "std-default=">;
2822 def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
2823 Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
2825 const char *Values =
2826 #define LANGSTANDARD(id, name, lang, desc, features) name ","
2827 #define LANGSTANDARD_ALIAS(id, alias) alias ","
2828 #include "clang/Basic/LangStandards.def"
2831 def stdlib_EQ : Joined<["-", "--"], "stdlib=">, Flags<[CC1Option]>,
2832 HelpText<"C++ standard library to use">, Values<"libc++,libstdc++,platform">;
2833 def stdlibxx_isystem : JoinedOrSeparate<["-"], "stdlib++-isystem">,
2834 Group<clang_i_Group>,
2835 HelpText<"Use directory as the C++ standard library include path">,
2836 Flags<[DriverOption]>, MetaVarName<"<directory>">;
2837 def unwindlib_EQ : Joined<["-", "--"], "unwindlib=">, Flags<[CC1Option]>,
2838 HelpText<"Unwind library to use">, Values<"libgcc,unwindlib,platform">;
2839 def sub__library : JoinedOrSeparate<["-"], "sub_library">;
2840 def sub__umbrella : JoinedOrSeparate<["-"], "sub_umbrella">;
2841 def system_header_prefix : Joined<["--"], "system-header-prefix=">,
2842 Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
2843 HelpText<"Treat all #include paths starting with <prefix> as including a "
2845 def : Separate<["--"], "system-header-prefix">, Alias<system_header_prefix>;
2846 def no_system_header_prefix : Joined<["--"], "no-system-header-prefix=">,
2847 Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
2848 HelpText<"Treat all #include paths starting with <prefix> as not including a "
2850 def : Separate<["--"], "no-system-header-prefix">, Alias<no_system_header_prefix>;
2851 def s : Flag<["-"], "s">, Group<Link_Group>;
2852 def target : Joined<["--"], "target=">, Flags<[DriverOption, CoreOption]>,
2853 HelpText<"Generate code for the given target">;
2854 def print_supported_cpus : Flag<["-", "--"], "print-supported-cpus">,
2855 Group<CompileOnly_Group>, Flags<[CC1Option, CoreOption]>,
2856 HelpText<"Print supported cpu models for the given target (if target is not specified,"
2857 " it will print the supported cpus for the default target)">;
2858 def mcpu_EQ_QUESTION : Flag<["-"], "mcpu=?">, Alias<print_supported_cpus>;
2859 def mtune_EQ_QUESTION : Flag<["-"], "mtune=?">, Alias<print_supported_cpus>;
2860 def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[DriverOption]>,
2861 HelpText<"Use the gcc toolchain at the given directory">;
2862 def time : Flag<["-"], "time">,
2863 HelpText<"Time individual commands">;
2864 def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>,
2865 HelpText<"Enable some traditional CPP emulation">;
2866 def traditional : Flag<["-", "--"], "traditional">;
2867 def trigraphs : Flag<["-", "--"], "trigraphs">, Alias<ftrigraphs>,
2868 HelpText<"Process trigraph sequences">;
2869 def twolevel__namespace__hints : Flag<["-"], "twolevel_namespace_hints">;
2870 def twolevel__namespace : Flag<["-"], "twolevel_namespace">;
2871 def t : Flag<["-"], "t">, Group<Link_Group>;
2872 def umbrella : Separate<["-"], "umbrella">;
2873 def undefined : JoinedOrSeparate<["-"], "undefined">, Group<u_Group>;
2874 def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>,
2875 HelpText<"undef all system defines">;
2876 def unexported__symbols__list : Separate<["-"], "unexported_symbols_list">;
2877 def u : JoinedOrSeparate<["-"], "u">, Group<u_Group>;
2878 def v : Flag<["-"], "v">, Flags<[CC1Option, CoreOption]>,
2879 HelpText<"Show commands to run and use verbose output">;
2880 def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[DriverOption]>,
2881 HelpText<"Verify the binary representation of debug output">;
2882 def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>;
2883 def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>;
2884 def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>;
2885 def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">;
2886 def whatsloaded : Flag<["-"], "whatsloaded">;
2887 def whyload : Flag<["-"], "whyload">;
2888 def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>;
2889 def x : JoinedOrSeparate<["-"], "x">, Flags<[DriverOption,CC1Option]>,
2890 HelpText<"Treat subsequent input files as having type <language>">,
2891 MetaVarName<"<language>">;
2892 def y : Joined<["-"], "y">;
2894 defm integrated_as : OptOutFFlag<"integrated-as", "Enable the integrated assembler", "Disable the integrated assembler">;
2896 def fintegrated_cc1 : Flag<["-"], "fintegrated-cc1">,
2897 Flags<[CoreOption, DriverOption]>, Group<f_Group>,
2898 HelpText<"Run cc1 in-process">;
2899 def fno_integrated_cc1 : Flag<["-"], "fno-integrated-cc1">,
2900 Flags<[CoreOption, DriverOption]>, Group<f_Group>,
2901 HelpText<"Spawn a separate process for each cc1">;
2903 def : Flag<["-"], "integrated-as">, Alias<fintegrated_as>, Flags<[DriverOption]>;
2904 def : Flag<["-"], "no-integrated-as">, Alias<fno_integrated_as>,
2905 Flags<[CC1Option, DriverOption]>;
2907 def working_directory : JoinedOrSeparate<["-"], "working-directory">, Flags<[CC1Option]>,
2908 HelpText<"Resolve file paths relative to the specified directory">;
2909 def working_directory_EQ : Joined<["-"], "working-directory=">, Flags<[CC1Option]>,
2910 Alias<working_directory>;
2912 // Double dash options, which are usually an alias for one of the previous
2915 def _mhwdiv_EQ : Joined<["--"], "mhwdiv=">, Alias<mhwdiv_EQ>;
2916 def _mhwdiv : Separate<["--"], "mhwdiv">, Alias<mhwdiv_EQ>;
2917 def _CLASSPATH_EQ : Joined<["--"], "CLASSPATH=">, Alias<fclasspath_EQ>;
2918 def _CLASSPATH : Separate<["--"], "CLASSPATH">, Alias<fclasspath_EQ>;
2919 def _all_warnings : Flag<["--"], "all-warnings">, Alias<Wall>;
2920 def _analyzer_no_default_checks : Flag<["--"], "analyzer-no-default-checks">, Flags<[DriverOption]>;
2921 def _analyzer_output : JoinedOrSeparate<["--"], "analyzer-output">, Flags<[DriverOption]>,
2922 HelpText<"Static analyzer report output format (html|plist|plist-multi-file|plist-html|sarif|text).">;
2923 def _analyze : Flag<["--"], "analyze">, Flags<[DriverOption, CoreOption]>,
2924 HelpText<"Run the static analyzer">;
2925 def _assemble : Flag<["--"], "assemble">, Alias<S>;
2926 def _assert_EQ : Joined<["--"], "assert=">, Alias<A>;
2927 def _assert : Separate<["--"], "assert">, Alias<A>;
2928 def _bootclasspath_EQ : Joined<["--"], "bootclasspath=">, Alias<fbootclasspath_EQ>;
2929 def _bootclasspath : Separate<["--"], "bootclasspath">, Alias<fbootclasspath_EQ>;
2930 def _classpath_EQ : Joined<["--"], "classpath=">, Alias<fclasspath_EQ>;
2931 def _classpath : Separate<["--"], "classpath">, Alias<fclasspath_EQ>;
2932 def _comments_in_macros : Flag<["--"], "comments-in-macros">, Alias<CC>;
2933 def _comments : Flag<["--"], "comments">, Alias<C>;
2934 def _compile : Flag<["--"], "compile">, Alias<c>;
2935 def _constant_cfstrings : Flag<["--"], "constant-cfstrings">;
2936 def _debug_EQ : Joined<["--"], "debug=">, Alias<g_Flag>;
2937 def _debug : Flag<["--"], "debug">, Alias<g_Flag>;
2938 def _define_macro_EQ : Joined<["--"], "define-macro=">, Alias<D>;
2939 def _define_macro : Separate<["--"], "define-macro">, Alias<D>;
2940 def _dependencies : Flag<["--"], "dependencies">, Alias<M>;
2941 def _dyld_prefix_EQ : Joined<["--"], "dyld-prefix=">;
2942 def _dyld_prefix : Separate<["--"], "dyld-prefix">, Alias<_dyld_prefix_EQ>;
2943 def _encoding_EQ : Joined<["--"], "encoding=">, Alias<fencoding_EQ>;
2944 def _encoding : Separate<["--"], "encoding">, Alias<fencoding_EQ>;
2945 def _entry : Flag<["--"], "entry">, Alias<e>;
2946 def _extdirs_EQ : Joined<["--"], "extdirs=">, Alias<fextdirs_EQ>;
2947 def _extdirs : Separate<["--"], "extdirs">, Alias<fextdirs_EQ>;
2948 def _extra_warnings : Flag<["--"], "extra-warnings">, Alias<W_Joined>;
2949 def _for_linker_EQ : Joined<["--"], "for-linker=">, Alias<Xlinker>;
2950 def _for_linker : Separate<["--"], "for-linker">, Alias<Xlinker>;
2951 def _force_link_EQ : Joined<["--"], "force-link=">, Alias<u>;
2952 def _force_link : Separate<["--"], "force-link">, Alias<u>;
2953 def _help_hidden : Flag<["--"], "help-hidden">,
2954 HelpText<"Display help for hidden options">;
2955 def _imacros_EQ : Joined<["--"], "imacros=">, Alias<imacros>;
2956 def _include_barrier : Flag<["--"], "include-barrier">, Alias<I_>;
2957 def _include_directory_after_EQ : Joined<["--"], "include-directory-after=">, Alias<idirafter>;
2958 def _include_directory_after : Separate<["--"], "include-directory-after">, Alias<idirafter>;
2959 def _include_directory_EQ : Joined<["--"], "include-directory=">, Alias<I>;
2960 def _include_directory : Separate<["--"], "include-directory">, Alias<I>;
2961 def _include_prefix_EQ : Joined<["--"], "include-prefix=">, Alias<iprefix>;
2962 def _include_prefix : Separate<["--"], "include-prefix">, Alias<iprefix>;
2963 def _include_with_prefix_after_EQ : Joined<["--"], "include-with-prefix-after=">, Alias<iwithprefix>;
2964 def _include_with_prefix_after : Separate<["--"], "include-with-prefix-after">, Alias<iwithprefix>;
2965 def _include_with_prefix_before_EQ : Joined<["--"], "include-with-prefix-before=">, Alias<iwithprefixbefore>;
2966 def _include_with_prefix_before : Separate<["--"], "include-with-prefix-before">, Alias<iwithprefixbefore>;
2967 def _include_with_prefix_EQ : Joined<["--"], "include-with-prefix=">, Alias<iwithprefix>;
2968 def _include_with_prefix : Separate<["--"], "include-with-prefix">, Alias<iwithprefix>;
2969 def _include_EQ : Joined<["--"], "include=">, Alias<include_>;
2970 def _language_EQ : Joined<["--"], "language=">, Alias<x>;
2971 def _language : Separate<["--"], "language">, Alias<x>;
2972 def _library_directory_EQ : Joined<["--"], "library-directory=">, Alias<L>;
2973 def _library_directory : Separate<["--"], "library-directory">, Alias<L>;
2974 def _no_line_commands : Flag<["--"], "no-line-commands">, Alias<P>;
2975 def _no_standard_includes : Flag<["--"], "no-standard-includes">, Alias<nostdinc>;
2976 def _no_standard_libraries : Flag<["--"], "no-standard-libraries">, Alias<nostdlib>;
2977 def _no_undefined : Flag<["--"], "no-undefined">, Flags<[LinkerInput]>;
2978 def _no_warnings : Flag<["--"], "no-warnings">, Alias<w>;
2979 def _optimize_EQ : Joined<["--"], "optimize=">, Alias<O>;
2980 def _optimize : Flag<["--"], "optimize">, Alias<O>;
2981 def _output_class_directory_EQ : Joined<["--"], "output-class-directory=">, Alias<foutput_class_dir_EQ>;
2982 def _output_class_directory : Separate<["--"], "output-class-directory">, Alias<foutput_class_dir_EQ>;
2983 def _output_EQ : Joined<["--"], "output=">, Alias<o>;
2984 def _output : Separate<["--"], "output">, Alias<o>;
2985 def _param : Separate<["--"], "param">, Group<CompileOnly_Group>;
2986 def _param_EQ : Joined<["--"], "param=">, Alias<_param>;
2987 def _precompile : Flag<["--"], "precompile">, Flags<[DriverOption]>,
2988 Group<Action_Group>, HelpText<"Only precompile the input">;
2989 def _prefix_EQ : Joined<["--"], "prefix=">, Alias<B>;
2990 def _prefix : Separate<["--"], "prefix">, Alias<B>;
2991 def _preprocess : Flag<["--"], "preprocess">, Alias<E>;
2992 def _print_diagnostic_categories : Flag<["--"], "print-diagnostic-categories">;
2993 def _print_file_name : Separate<["--"], "print-file-name">, Alias<print_file_name_EQ>;
2994 def _print_missing_file_dependencies : Flag<["--"], "print-missing-file-dependencies">, Alias<MG>;
2995 def _print_prog_name : Separate<["--"], "print-prog-name">, Alias<print_prog_name_EQ>;
2996 def _profile_blocks : Flag<["--"], "profile-blocks">, Alias<a>;
2997 def _profile : Flag<["--"], "profile">, Alias<p>;
2998 def _resource_EQ : Joined<["--"], "resource=">, Alias<fcompile_resource_EQ>;
2999 def _resource : Separate<["--"], "resource">, Alias<fcompile_resource_EQ>;
3000 def _rtlib : Separate<["--"], "rtlib">, Alias<rtlib_EQ>;
3001 def _serialize_diags : Separate<["-", "--"], "serialize-diagnostics">, Flags<[DriverOption]>,
3002 HelpText<"Serialize compiler diagnostics to a file">;
3003 // We give --version different semantics from -version.
3004 def _version : Flag<["--"], "version">, Flags<[CoreOption, CC1Option]>,
3005 HelpText<"Print version information">;
3006 def _signed_char : Flag<["--"], "signed-char">, Alias<fsigned_char>;
3007 def _std : Separate<["--"], "std">, Alias<std_EQ>;
3008 def _stdlib : Separate<["--"], "stdlib">, Alias<stdlib_EQ>;
3009 def _sysroot_EQ : Joined<["--"], "sysroot=">;
3010 def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>;
3011 def _target_help : Flag<["--"], "target-help">;
3012 def _trace_includes : Flag<["--"], "trace-includes">, Alias<H>;
3013 def _undefine_macro_EQ : Joined<["--"], "undefine-macro=">, Alias<U>;
3014 def _undefine_macro : Separate<["--"], "undefine-macro">, Alias<U>;
3015 def _unsigned_char : Flag<["--"], "unsigned-char">, Alias<funsigned_char>;
3016 def _user_dependencies : Flag<["--"], "user-dependencies">, Alias<MM>;
3017 def _verbose : Flag<["--"], "verbose">, Alias<v>;
3018 def _warn__EQ : Joined<["--"], "warn-=">, Alias<W_Joined>;
3019 def _warn_ : Joined<["--"], "warn-">, Alias<W_Joined>;
3020 def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>;
3021 def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>;
3022 def _ : Joined<["--"], "">, Flags<[Unsupported]>;
3024 // Hexagon feature flags.
3025 def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">,
3026 Group<m_hexagon_Features_Group>;
3027 def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<mcpu_EQ>,
3028 AliasArgs<["hexagonv5"]>;
3029 def mv55 : Flag<["-"], "mv55">, Group<m_hexagon_Features_Group>,
3030 Alias<mcpu_EQ>, AliasArgs<["hexagonv55"]>;
3031 def mv60 : Flag<["-"], "mv60">, Group<m_hexagon_Features_Group>,
3032 Alias<mcpu_EQ>, AliasArgs<["hexagonv60"]>;
3033 def mv62 : Flag<["-"], "mv62">, Group<m_hexagon_Features_Group>,
3034 Alias<mcpu_EQ>, AliasArgs<["hexagonv62"]>;
3035 def mv65 : Flag<["-"], "mv65">, Group<m_hexagon_Features_Group>,
3036 Alias<mcpu_EQ>, AliasArgs<["hexagonv65"]>;
3037 def mv66 : Flag<["-"], "mv66">, Group<m_hexagon_Features_Group>,
3038 Alias<mcpu_EQ>, AliasArgs<["hexagonv66"]>;
3039 def mv67 : Flag<["-"], "mv67">, Group<m_hexagon_Features_Group>,
3040 Alias<mcpu_EQ>, AliasArgs<["hexagonv67"]>;
3041 def mv67t : Flag<["-"], "mv67t">, Group<m_hexagon_Features_Group>,
3042 Alias<mcpu_EQ>, AliasArgs<["hexagonv67t"]>;
3043 def mhexagon_hvx : Flag<["-"], "mhvx">, Group<m_hexagon_Features_HVX_Group>,
3044 HelpText<"Enable Hexagon Vector eXtensions">;
3045 def mhexagon_hvx_EQ : Joined<["-"], "mhvx=">,
3046 Group<m_hexagon_Features_HVX_Group>,
3047 HelpText<"Enable Hexagon Vector eXtensions">;
3048 def mno_hexagon_hvx : Flag<["-"], "mno-hvx">,
3049 Group<m_hexagon_Features_HVX_Group>,
3050 HelpText<"Disable Hexagon Vector eXtensions">;
3051 def mhexagon_hvx_length_EQ : Joined<["-"], "mhvx-length=">,
3052 Group<m_hexagon_Features_HVX_Group>, HelpText<"Set Hexagon Vector Length">,
3054 def ffixed_r19: Flag<["-"], "ffixed-r19">,
3055 HelpText<"Reserve register r19 (Hexagon only)">;
3056 def mmemops : Flag<["-"], "mmemops">, Group<m_hexagon_Features_Group>,
3057 Flags<[CC1Option]>, HelpText<"Enable generation of memop instructions">;
3058 def mno_memops : Flag<["-"], "mno-memops">, Group<m_hexagon_Features_Group>,
3059 Flags<[CC1Option]>, HelpText<"Disable generation of memop instructions">;
3060 def mpackets : Flag<["-"], "mpackets">, Group<m_hexagon_Features_Group>,
3061 Flags<[CC1Option]>, HelpText<"Enable generation of instruction packets">;
3062 def mno_packets : Flag<["-"], "mno-packets">, Group<m_hexagon_Features_Group>,
3063 Flags<[CC1Option]>, HelpText<"Disable generation of instruction packets">;
3064 def mnvj : Flag<["-"], "mnvj">, Group<m_hexagon_Features_Group>,
3065 Flags<[CC1Option]>, HelpText<"Enable generation of new-value jumps">;
3066 def mno_nvj : Flag<["-"], "mno-nvj">, Group<m_hexagon_Features_Group>,
3067 Flags<[CC1Option]>, HelpText<"Disable generation of new-value jumps">;
3068 def mnvs : Flag<["-"], "mnvs">, Group<m_hexagon_Features_Group>,
3069 Flags<[CC1Option]>, HelpText<"Enable generation of new-value stores">;
3070 def mno_nvs : Flag<["-"], "mno-nvs">, Group<m_hexagon_Features_Group>,
3071 Flags<[CC1Option]>, HelpText<"Disable generation of new-value stores">;
3074 // X86 feature flags
3075 def mx87 : Flag<["-"], "mx87">, Group<m_x86_Features_Group>;
3076 def mno_x87 : Flag<["-"], "mno-x87">, Group<m_x86_Features_Group>;
3077 def m80387 : Flag<["-"], "m80387">, Alias<mx87>;
3078 def mno_80387 : Flag<["-"], "mno-80387">, Alias<mno_x87>;
3079 def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>;
3080 def mno_mmx : Flag<["-"], "mno-mmx">, Group<m_x86_Features_Group>;
3081 def m3dnow : Flag<["-"], "m3dnow">, Group<m_x86_Features_Group>;
3082 def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>;
3083 def m3dnowa : Flag<["-"], "m3dnowa">, Group<m_x86_Features_Group>;
3084 def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>;
3085 def mamx_bf16 : Flag<["-"], "mamx-bf16">, Group<m_x86_Features_Group>;
3086 def mno_amx_bf16 : Flag<["-"], "mno-amx-bf16">, Group<m_x86_Features_Group>;
3087 def mtamx_int8 : Flag<["-"], "mamx-int8">, Group<m_x86_Features_Group>;
3088 def mno_amx_int8 : Flag<["-"], "mno-amx-int8">, Group<m_x86_Features_Group>;
3089 def mamx_tile : Flag<["-"], "mamx-tile">, Group<m_x86_Features_Group>;
3090 def mno_amx_tile : Flag<["-"], "mno-amx-tile">, Group<m_x86_Features_Group>;
3091 def msse : Flag<["-"], "msse">, Group<m_x86_Features_Group>;
3092 def mno_sse : Flag<["-"], "mno-sse">, Group<m_x86_Features_Group>;
3093 def msse2 : Flag<["-"], "msse2">, Group<m_x86_Features_Group>;
3094 def mno_sse2 : Flag<["-"], "mno-sse2">, Group<m_x86_Features_Group>;
3095 def msse3 : Flag<["-"], "msse3">, Group<m_x86_Features_Group>;
3096 def mno_sse3 : Flag<["-"], "mno-sse3">, Group<m_x86_Features_Group>;
3097 def mssse3 : Flag<["-"], "mssse3">, Group<m_x86_Features_Group>;
3098 def mno_ssse3 : Flag<["-"], "mno-ssse3">, Group<m_x86_Features_Group>;
3099 def msse4_1 : Flag<["-"], "msse4.1">, Group<m_x86_Features_Group>;
3100 def mno_sse4_1 : Flag<["-"], "mno-sse4.1">, Group<m_x86_Features_Group>;
3101 def msse4_2 : Flag<["-"], "msse4.2">, Group<m_x86_Features_Group>;
3102 def mno_sse4_2 : Flag<["-"], "mno-sse4.2">, Group<m_x86_Features_Group>;
3103 def msse4 : Flag<["-"], "msse4">, Alias<msse4_2>;
3104 // -mno-sse4 turns off sse4.1 which has the effect of turning off everything
3105 // later than 4.1. -msse4 turns on 4.2 which has the effect of turning on
3106 // everything earlier than 4.2.
3107 def mno_sse4 : Flag<["-"], "mno-sse4">, Alias<mno_sse4_1>;
3108 def msse4a : Flag<["-"], "msse4a">, Group<m_x86_Features_Group>;
3109 def mno_sse4a : Flag<["-"], "mno-sse4a">, Group<m_x86_Features_Group>;
3110 def mavx : Flag<["-"], "mavx">, Group<m_x86_Features_Group>;
3111 def mno_avx : Flag<["-"], "mno-avx">, Group<m_x86_Features_Group>;
3112 def mavx2 : Flag<["-"], "mavx2">, Group<m_x86_Features_Group>;
3113 def mno_avx2 : Flag<["-"], "mno-avx2">, Group<m_x86_Features_Group>;
3114 def mavx512f : Flag<["-"], "mavx512f">, Group<m_x86_Features_Group>;
3115 def mno_avx512f : Flag<["-"], "mno-avx512f">, Group<m_x86_Features_Group>;
3116 def mavx512bf16 : Flag<["-"], "mavx512bf16">, Group<m_x86_Features_Group>;
3117 def mno_avx512bf16 : Flag<["-"], "mno-avx512bf16">, Group<m_x86_Features_Group>;
3118 def mavx512bitalg : Flag<["-"], "mavx512bitalg">, Group<m_x86_Features_Group>;
3119 def mno_avx512bitalg : Flag<["-"], "mno-avx512bitalg">, Group<m_x86_Features_Group>;
3120 def mavx512bw : Flag<["-"], "mavx512bw">, Group<m_x86_Features_Group>;
3121 def mno_avx512bw : Flag<["-"], "mno-avx512bw">, Group<m_x86_Features_Group>;
3122 def mavx512cd : Flag<["-"], "mavx512cd">, Group<m_x86_Features_Group>;
3123 def mno_avx512cd : Flag<["-"], "mno-avx512cd">, Group<m_x86_Features_Group>;
3124 def mavx512dq : Flag<["-"], "mavx512dq">, Group<m_x86_Features_Group>;
3125 def mno_avx512dq : Flag<["-"], "mno-avx512dq">, Group<m_x86_Features_Group>;
3126 def mavx512er : Flag<["-"], "mavx512er">, Group<m_x86_Features_Group>;
3127 def mno_avx512er : Flag<["-"], "mno-avx512er">, Group<m_x86_Features_Group>;
3128 def mavx512ifma : Flag<["-"], "mavx512ifma">, Group<m_x86_Features_Group>;
3129 def mno_avx512ifma : Flag<["-"], "mno-avx512ifma">, Group<m_x86_Features_Group>;
3130 def mavx512pf : Flag<["-"], "mavx512pf">, Group<m_x86_Features_Group>;
3131 def mno_avx512pf : Flag<["-"], "mno-avx512pf">, Group<m_x86_Features_Group>;
3132 def mavx512vbmi : Flag<["-"], "mavx512vbmi">, Group<m_x86_Features_Group>;
3133 def mno_avx512vbmi : Flag<["-"], "mno-avx512vbmi">, Group<m_x86_Features_Group>;
3134 def mavx512vbmi2 : Flag<["-"], "mavx512vbmi2">, Group<m_x86_Features_Group>;
3135 def mno_avx512vbmi2 : Flag<["-"], "mno-avx512vbmi2">, Group<m_x86_Features_Group>;
3136 def mavx512vl : Flag<["-"], "mavx512vl">, Group<m_x86_Features_Group>;
3137 def mno_avx512vl : Flag<["-"], "mno-avx512vl">, Group<m_x86_Features_Group>;
3138 def mavx512vnni : Flag<["-"], "mavx512vnni">, Group<m_x86_Features_Group>;
3139 def mno_avx512vnni : Flag<["-"], "mno-avx512vnni">, Group<m_x86_Features_Group>;
3140 def mavx512vpopcntdq : Flag<["-"], "mavx512vpopcntdq">, Group<m_x86_Features_Group>;
3141 def mno_avx512vpopcntdq : Flag<["-"], "mno-avx512vpopcntdq">, Group<m_x86_Features_Group>;
3142 def mavx512vp2intersect : Flag<["-"], "mavx512vp2intersect">, Group<m_x86_Features_Group>;
3143 def mno_avx512vp2intersect : Flag<["-"], "mno-avx512vp2intersect">, Group<m_x86_Features_Group>;
3144 def madx : Flag<["-"], "madx">, Group<m_x86_Features_Group>;
3145 def mno_adx : Flag<["-"], "mno-adx">, Group<m_x86_Features_Group>;
3146 def maes : Flag<["-"], "maes">, Group<m_x86_Features_Group>;
3147 def mno_aes : Flag<["-"], "mno-aes">, Group<m_x86_Features_Group>;
3148 def mbmi : Flag<["-"], "mbmi">, Group<m_x86_Features_Group>;
3149 def mno_bmi : Flag<["-"], "mno-bmi">, Group<m_x86_Features_Group>;
3150 def mbmi2 : Flag<["-"], "mbmi2">, Group<m_x86_Features_Group>;
3151 def mno_bmi2 : Flag<["-"], "mno-bmi2">, Group<m_x86_Features_Group>;
3152 def mcldemote : Flag<["-"], "mcldemote">, Group<m_x86_Features_Group>;
3153 def mno_cldemote : Flag<["-"], "mno-cldemote">, Group<m_x86_Features_Group>;
3154 def mclflushopt : Flag<["-"], "mclflushopt">, Group<m_x86_Features_Group>;
3155 def mno_clflushopt : Flag<["-"], "mno-clflushopt">, Group<m_x86_Features_Group>;
3156 def mclwb : Flag<["-"], "mclwb">, Group<m_x86_Features_Group>;
3157 def mno_clwb : Flag<["-"], "mno-clwb">, Group<m_x86_Features_Group>;
3158 def mwbnoinvd : Flag<["-"], "mwbnoinvd">, Group<m_x86_Features_Group>;
3159 def mno_wbnoinvd : Flag<["-"], "mno-wbnoinvd">, Group<m_x86_Features_Group>;
3160 def mclzero : Flag<["-"], "mclzero">, Group<m_x86_Features_Group>;
3161 def mno_clzero : Flag<["-"], "mno-clzero">, Group<m_x86_Features_Group>;
3162 def mcx16 : Flag<["-"], "mcx16">, Group<m_x86_Features_Group>;
3163 def mno_cx16 : Flag<["-"], "mno-cx16">, Group<m_x86_Features_Group>;
3164 def menqcmd : Flag<["-"], "menqcmd">, Group<m_x86_Features_Group>;
3165 def mno_enqcmd : Flag<["-"], "mno-enqcmd">, Group<m_x86_Features_Group>;
3166 def mf16c : Flag<["-"], "mf16c">, Group<m_x86_Features_Group>;
3167 def mno_f16c : Flag<["-"], "mno-f16c">, Group<m_x86_Features_Group>;
3168 def mfma : Flag<["-"], "mfma">, Group<m_x86_Features_Group>;
3169 def mno_fma : Flag<["-"], "mno-fma">, Group<m_x86_Features_Group>;
3170 def mfma4 : Flag<["-"], "mfma4">, Group<m_x86_Features_Group>;
3171 def mno_fma4 : Flag<["-"], "mno-fma4">, Group<m_x86_Features_Group>;
3172 def mfsgsbase : Flag<["-"], "mfsgsbase">, Group<m_x86_Features_Group>;
3173 def mno_fsgsbase : Flag<["-"], "mno-fsgsbase">, Group<m_x86_Features_Group>;
3174 def mfxsr : Flag<["-"], "mfxsr">, Group<m_x86_Features_Group>;
3175 def mno_fxsr : Flag<["-"], "mno-fxsr">, Group<m_x86_Features_Group>;
3176 def minvpcid : Flag<["-"], "minvpcid">, Group<m_x86_Features_Group>;
3177 def mno_invpcid : Flag<["-"], "mno-invpcid">, Group<m_x86_Features_Group>;
3178 def mgfni : Flag<["-"], "mgfni">, Group<m_x86_Features_Group>;
3179 def mno_gfni : Flag<["-"], "mno-gfni">, Group<m_x86_Features_Group>;
3180 def mlwp : Flag<["-"], "mlwp">, Group<m_x86_Features_Group>;
3181 def mno_lwp : Flag<["-"], "mno-lwp">, Group<m_x86_Features_Group>;
3182 def mlzcnt : Flag<["-"], "mlzcnt">, Group<m_x86_Features_Group>;
3183 def mno_lzcnt : Flag<["-"], "mno-lzcnt">, Group<m_x86_Features_Group>;
3184 def mmovbe : Flag<["-"], "mmovbe">, Group<m_x86_Features_Group>;
3185 def mno_movbe : Flag<["-"], "mno-movbe">, Group<m_x86_Features_Group>;
3186 def mmovdiri : Flag<["-"], "mmovdiri">, Group<m_x86_Features_Group>;
3187 def mno_movdiri : Flag<["-"], "mno-movdiri">, Group<m_x86_Features_Group>;
3188 def mmovdir64b : Flag<["-"], "mmovdir64b">, Group<m_x86_Features_Group>;
3189 def mno_movdir64b : Flag<["-"], "mno-movdir64b">, Group<m_x86_Features_Group>;
3190 def mmwaitx : Flag<["-"], "mmwaitx">, Group<m_x86_Features_Group>;
3191 def mno_mwaitx : Flag<["-"], "mno-mwaitx">, Group<m_x86_Features_Group>;
3192 def mpku : Flag<["-"], "mpku">, Group<m_x86_Features_Group>;
3193 def mno_pku : Flag<["-"], "mno-pku">, Group<m_x86_Features_Group>;
3194 def mpclmul : Flag<["-"], "mpclmul">, Group<m_x86_Features_Group>;
3195 def mno_pclmul : Flag<["-"], "mno-pclmul">, Group<m_x86_Features_Group>;
3196 def mpconfig : Flag<["-"], "mpconfig">, Group<m_x86_Features_Group>;
3197 def mno_pconfig : Flag<["-"], "mno-pconfig">, Group<m_x86_Features_Group>;
3198 def mpopcnt : Flag<["-"], "mpopcnt">, Group<m_x86_Features_Group>;
3199 def mno_popcnt : Flag<["-"], "mno-popcnt">, Group<m_x86_Features_Group>;
3200 def mprefetchwt1 : Flag<["-"], "mprefetchwt1">, Group<m_x86_Features_Group>;
3201 def mno_prefetchwt1 : Flag<["-"], "mno-prefetchwt1">, Group<m_x86_Features_Group>;
3202 def mprfchw : Flag<["-"], "mprfchw">, Group<m_x86_Features_Group>;
3203 def mno_prfchw : Flag<["-"], "mno-prfchw">, Group<m_x86_Features_Group>;
3204 def mptwrite : Flag<["-"], "mptwrite">, Group<m_x86_Features_Group>;
3205 def mno_ptwrite : Flag<["-"], "mno-ptwrite">, Group<m_x86_Features_Group>;
3206 def mrdpid : Flag<["-"], "mrdpid">, Group<m_x86_Features_Group>;
3207 def mno_rdpid : Flag<["-"], "mno-rdpid">, Group<m_x86_Features_Group>;
3208 def mrdrnd : Flag<["-"], "mrdrnd">, Group<m_x86_Features_Group>;
3209 def mno_rdrnd : Flag<["-"], "mno-rdrnd">, Group<m_x86_Features_Group>;
3210 def mrtm : Flag<["-"], "mrtm">, Group<m_x86_Features_Group>;
3211 def mno_rtm : Flag<["-"], "mno-rtm">, Group<m_x86_Features_Group>;
3212 def mrdseed : Flag<["-"], "mrdseed">, Group<m_x86_Features_Group>;
3213 def mno_rdseed : Flag<["-"], "mno-rdseed">, Group<m_x86_Features_Group>;
3214 def msahf : Flag<["-"], "msahf">, Group<m_x86_Features_Group>;
3215 def mno_sahf : Flag<["-"], "mno-sahf">, Group<m_x86_Features_Group>;
3216 def mserialize : Flag<["-"], "mserialize">, Group<m_x86_Features_Group>;
3217 def mno_serialize : Flag<["-"], "mno-serialize">, Group<m_x86_Features_Group>;
3218 def msgx : Flag<["-"], "msgx">, Group<m_x86_Features_Group>;
3219 def mno_sgx : Flag<["-"], "mno-sgx">, Group<m_x86_Features_Group>;
3220 def msha : Flag<["-"], "msha">, Group<m_x86_Features_Group>;
3221 def mno_sha : Flag<["-"], "mno-sha">, Group<m_x86_Features_Group>;
3222 def mtbm : Flag<["-"], "mtbm">, Group<m_x86_Features_Group>;
3223 def mno_tbm : Flag<["-"], "mno-tbm">, Group<m_x86_Features_Group>;
3224 def mtsxldtrk : Flag<["-"], "mtsxldtrk">, Group<m_x86_Features_Group>;
3225 def mno_tsxldtrk : Flag<["-"], "mno-tsxldtrk">, Group<m_x86_Features_Group>;
3226 def mvaes : Flag<["-"], "mvaes">, Group<m_x86_Features_Group>;
3227 def mno_vaes : Flag<["-"], "mno-vaes">, Group<m_x86_Features_Group>;
3228 def mvpclmulqdq : Flag<["-"], "mvpclmulqdq">, Group<m_x86_Features_Group>;
3229 def mno_vpclmulqdq : Flag<["-"], "mno-vpclmulqdq">, Group<m_x86_Features_Group>;
3230 def mwaitpkg : Flag<["-"], "mwaitpkg">, Group<m_x86_Features_Group>;
3231 def mno_waitpkg : Flag<["-"], "mno-waitpkg">, Group<m_x86_Features_Group>;
3232 def mxop : Flag<["-"], "mxop">, Group<m_x86_Features_Group>;
3233 def mno_xop : Flag<["-"], "mno-xop">, Group<m_x86_Features_Group>;
3234 def mxsave : Flag<["-"], "mxsave">, Group<m_x86_Features_Group>;
3235 def mno_xsave : Flag<["-"], "mno-xsave">, Group<m_x86_Features_Group>;
3236 def mxsavec : Flag<["-"], "mxsavec">, Group<m_x86_Features_Group>;
3237 def mno_xsavec : Flag<["-"], "mno-xsavec">, Group<m_x86_Features_Group>;
3238 def mxsaveopt : Flag<["-"], "mxsaveopt">, Group<m_x86_Features_Group>;
3239 def mno_xsaveopt : Flag<["-"], "mno-xsaveopt">, Group<m_x86_Features_Group>;
3240 def mxsaves : Flag<["-"], "mxsaves">, Group<m_x86_Features_Group>;
3241 def mno_xsaves : Flag<["-"], "mno-xsaves">, Group<m_x86_Features_Group>;
3242 def mshstk : Flag<["-"], "mshstk">, Group<m_x86_Features_Group>;
3243 def mno_shstk : Flag<["-"], "mno-shstk">, Group<m_x86_Features_Group>;
3244 def mretpoline_external_thunk : Flag<["-"], "mretpoline-external-thunk">, Group<m_x86_Features_Group>;
3245 def mno_retpoline_external_thunk : Flag<["-"], "mno-retpoline-external-thunk">, Group<m_x86_Features_Group>;
3246 def mvzeroupper : Flag<["-"], "mvzeroupper">, Group<m_x86_Features_Group>;
3247 def mno_vzeroupper : Flag<["-"], "mno-vzeroupper">, Group<m_x86_Features_Group>;
3249 // These are legacy user-facing driver-level option spellings. They are always
3250 // aliases for options that are spelled using the more common Unix / GNU flag
3251 // style of double-dash and equals-joined flags.
3252 def gcc_toolchain_legacy_spelling : Separate<["-"], "gcc-toolchain">, Alias<gcc_toolchain>;
3253 def target_legacy_spelling : Separate<["-"], "target">, Alias<target>;
3255 // Special internal option to handle -Xlinker --no-demangle.
3256 def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">,
3257 Flags<[Unsupported, NoArgumentUnused]>;
3259 // Special internal option to allow forwarding arbitrary arguments to linker.
3260 def Zlinker_input : Separate<["-"], "Zlinker-input">,
3261 Flags<[Unsupported, NoArgumentUnused]>;
3263 // Reserved library options.
3264 def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">,
3265 Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
3266 def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">,
3267 Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
3270 multiclass BooleanFFlag<string name> {
3271 def f#NAME : Flag<["-"], "f"#name>;
3272 def fno_#NAME : Flag<["-"], "fno-"#name>;
3275 defm : BooleanFFlag<"keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
3277 def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<f_Group>;
3279 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>, Flags<[CoreOption]>;
3281 defm align_labels : BooleanFFlag<"align-labels">, Group<clang_ignored_gcc_optimization_f_Group>;
3282 def falign_labels_EQ : Joined<["-"], "falign-labels=">, Group<clang_ignored_gcc_optimization_f_Group>;
3283 defm align_loops : BooleanFFlag<"align-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
3284 def falign_loops_EQ : Joined<["-"], "falign-loops=">, Group<clang_ignored_gcc_optimization_f_Group>;
3285 defm align_jumps : BooleanFFlag<"align-jumps">, Group<clang_ignored_gcc_optimization_f_Group>;
3286 def falign_jumps_EQ : Joined<["-"], "falign-jumps=">, Group<clang_ignored_gcc_optimization_f_Group>;
3288 // FIXME: This option should be supported and wired up to our diognostics, but
3289 // ignore it for now to avoid breaking builds that use it.
3290 def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>;
3292 defm fcheck_new : BooleanFFlag<"check-new">, Group<clang_ignored_f_Group>;
3293 defm caller_saves : BooleanFFlag<"caller-saves">, Group<clang_ignored_gcc_optimization_f_Group>;
3294 defm reorder_blocks : BooleanFFlag<"reorder-blocks">, Group<clang_ignored_gcc_optimization_f_Group>;
3295 defm eliminate_unused_debug_types : BooleanFFlag<"eliminate-unused-debug-types">, Group<clang_ignored_f_Group>;
3296 defm branch_count_reg : BooleanFFlag<"branch-count-reg">, Group<clang_ignored_gcc_optimization_f_Group>;
3297 defm default_inline : BooleanFFlag<"default-inline">, Group<clang_ignored_gcc_optimization_f_Group>;
3298 defm fat_lto_objects : BooleanFFlag<"fat-lto-objects">, Group<clang_ignored_gcc_optimization_f_Group>;
3299 defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_gcc_optimization_f_Group>;
3300 defm friend_injection : BooleanFFlag<"friend-injection">, Group<clang_ignored_f_Group>;
3301 defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>;
3302 defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_gcc_optimization_f_Group>;
3303 defm gcse_after_reload: BooleanFFlag<"gcse-after-reload">, Group<clang_ignored_gcc_optimization_f_Group>;
3304 defm gcse_las: BooleanFFlag<"gcse-las">, Group<clang_ignored_gcc_optimization_f_Group>;
3305 defm gcse_sm: BooleanFFlag<"gcse-sm">, Group<clang_ignored_gcc_optimization_f_Group>;
3306 defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>;
3307 defm implicit_templates : BooleanFFlag<"implicit-templates">, Group<clang_ignored_f_Group>;
3308 defm implement_inlines : BooleanFFlag<"implement-inlines">, Group<clang_ignored_f_Group>;
3309 defm merge_constants : BooleanFFlag<"merge-constants">, Group<clang_ignored_gcc_optimization_f_Group>;
3310 defm modulo_sched : BooleanFFlag<"modulo-sched">, Group<clang_ignored_gcc_optimization_f_Group>;
3311 defm modulo_sched_allow_regmoves : BooleanFFlag<"modulo-sched-allow-regmoves">,
3312 Group<clang_ignored_gcc_optimization_f_Group>;
3313 defm inline_functions_called_once : BooleanFFlag<"inline-functions-called-once">,
3314 Group<clang_ignored_gcc_optimization_f_Group>;
3315 def finline_limit_EQ : Joined<["-"], "finline-limit=">, Group<clang_ignored_gcc_optimization_f_Group>;
3316 defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>;
3317 defm inline_small_functions : BooleanFFlag<"inline-small-functions">,
3318 Group<clang_ignored_gcc_optimization_f_Group>;
3319 defm ipa_cp : BooleanFFlag<"ipa-cp">,
3320 Group<clang_ignored_gcc_optimization_f_Group>;
3321 defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>;
3322 def fsemantic_interposition : Flag<["-"], "fsemantic-interposition">, Group<f_Group>, Flags<[CC1Option]>;
3323 def fno_semantic_interposition: Flag<["-"], "fno-semantic-interposition">, Group<f_Group>, Flags<[CC1Option]>;
3324 defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>;
3325 defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
3326 defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>;
3327 defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_gcc_optimization_f_Group>;
3328 defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>;
3329 defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>;
3330 defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_gcc_optimization_f_Group>;
3331 defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>;
3332 defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>;
3333 defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_optimization_f_Group>;
3334 defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>;
3335 defm rename_registers : BooleanFFlag<"rename-registers">, Group<clang_ignored_gcc_optimization_f_Group>;
3336 defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>;
3337 defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_gcc_optimization_f_Group>;
3338 defm schedule_insns2 : BooleanFFlag<"schedule-insns2">, Group<clang_ignored_gcc_optimization_f_Group>;
3339 defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>;
3340 defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_gcc_optimization_f_Group>;
3341 defm single_precision_constant : BooleanFFlag<"single-precision-constant">,
3342 Group<clang_ignored_gcc_optimization_f_Group>;
3343 defm spec_constr_count : BooleanFFlag<"spec-constr-count">, Group<clang_ignored_f_Group>;
3344 defm stack_check : BooleanFFlag<"stack-check">, Group<clang_ignored_f_Group>;
3345 defm strength_reduce :
3346 BooleanFFlag<"strength-reduce">, Group<clang_ignored_gcc_optimization_f_Group>;
3347 defm tls_model : BooleanFFlag<"tls-model">, Group<clang_ignored_f_Group>;
3348 defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_gcc_optimization_f_Group>;
3349 defm tree_dce : BooleanFFlag<"tree-dce">, Group<clang_ignored_gcc_optimization_f_Group>;
3350 defm tree_salias : BooleanFFlag<"tree-salias">, Group<clang_ignored_f_Group>;
3351 defm tree_ter : BooleanFFlag<"tree-ter">, Group<clang_ignored_gcc_optimization_f_Group>;
3352 defm tree_vectorizer_verbose : BooleanFFlag<"tree-vectorizer-verbose">, Group<clang_ignored_f_Group>;
3353 defm tree_vrp : BooleanFFlag<"tree-vrp">, Group<clang_ignored_gcc_optimization_f_Group>;
3354 defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
3355 defm unsafe_loop_optimizations : BooleanFFlag<"unsafe-loop-optimizations">,
3356 Group<clang_ignored_gcc_optimization_f_Group>;
3357 defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
3358 defm use_linker_plugin : BooleanFFlag<"use-linker-plugin">, Group<clang_ignored_gcc_optimization_f_Group>;
3359 defm vect_cost_model : BooleanFFlag<"vect-cost-model">, Group<clang_ignored_gcc_optimization_f_Group>;
3360 defm variable_expansion_in_unroller : BooleanFFlag<"variable-expansion-in-unroller">,
3361 Group<clang_ignored_gcc_optimization_f_Group>;
3362 defm web : BooleanFFlag<"web">, Group<clang_ignored_gcc_optimization_f_Group>;
3363 defm whole_program : BooleanFFlag<"whole-program">, Group<clang_ignored_gcc_optimization_f_Group>;
3364 defm devirtualize : BooleanFFlag<"devirtualize">, Group<clang_ignored_gcc_optimization_f_Group>;
3365 defm devirtualize_speculatively : BooleanFFlag<"devirtualize-speculatively">,
3366 Group<clang_ignored_gcc_optimization_f_Group>;
3368 // Generic gfortran options.
3369 def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>;
3370 def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Group<gfortran_Group>;
3371 def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>;
3372 def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>;
3373 def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>;
3375 // "f" options with values for gfortran.
3376 def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>;
3377 def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>;
3378 def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>;
3379 def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>;
3380 def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<gfortran_Group>;
3381 def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>;
3382 def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>;
3383 def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>;
3384 def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>;
3385 def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>;
3386 def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>;
3387 def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>;
3388 def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>;
3389 def fmax_stack_var_size_EQ : Joined<["-"], "fmax-stack-var-size=">, Group<gfortran_Group>;
3390 def fmax_subrecord_length_EQ : Joined<["-"], "fmax-subrecord-length=">, Group<gfortran_Group>;
3391 def frecord_marker_EQ : Joined<["-"], "frecord-marker=">, Group<gfortran_Group>;
3393 // "f" flags for gfortran.
3394 defm aggressive_function_elimination : BooleanFFlag<"aggressive-function-elimination">, Group<gfortran_Group>;
3395 defm align_commons : BooleanFFlag<"align-commons">, Group<gfortran_Group>;
3396 defm all_intrinsics : BooleanFFlag<"all-intrinsics">, Group<gfortran_Group>;
3397 defm automatic : BooleanFFlag<"automatic">, Group<gfortran_Group>;
3398 defm backslash : BooleanFFlag<"backslash">, Group<gfortran_Group>;
3399 defm backtrace : BooleanFFlag<"backtrace">, Group<gfortran_Group>;
3400 defm bounds_check : BooleanFFlag<"bounds-check">, Group<gfortran_Group>;
3401 defm check_array_temporaries : BooleanFFlag<"check-array-temporaries">, Group<gfortran_Group>;
3402 defm cray_pointer : BooleanFFlag<"cray-pointer">, Group<gfortran_Group>;
3403 defm d_lines_as_code : BooleanFFlag<"d-lines-as-code">, Group<gfortran_Group>;
3404 defm d_lines_as_comments : BooleanFFlag<"d-lines-as-comments">, Group<gfortran_Group>;
3405 defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>;
3406 defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>;
3407 defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>;
3408 defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>;
3409 defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>;
3410 defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>;
3411 defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>;
3412 defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>;
3413 defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>;
3414 defm fixed_form : BooleanFFlag<"fixed-form">, Group<gfortran_Group>;
3415 defm free_form : BooleanFFlag<"free-form">, Group<gfortran_Group>;
3416 defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>;
3417 defm implicit_none : BooleanFFlag<"implicit-none">, Group<gfortran_Group>;
3418 defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>;
3419 defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>;
3420 defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>;
3421 defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>;
3422 defm module_private : BooleanFFlag<"module-private">, Group<gfortran_Group>;
3423 defm pack_derived : BooleanFFlag<"pack-derived">, Group<gfortran_Group>;
3424 defm protect_parens : BooleanFFlag<"protect-parens">, Group<gfortran_Group>;
3425 defm range_check : BooleanFFlag<"range-check">, Group<gfortran_Group>;
3426 defm real_4_real_10 : BooleanFFlag<"real-4-real-10">, Group<gfortran_Group>;
3427 defm real_4_real_16 : BooleanFFlag<"real-4-real-16">, Group<gfortran_Group>;
3428 defm real_4_real_8 : BooleanFFlag<"real-4-real-8">, Group<gfortran_Group>;
3429 defm real_8_real_10 : BooleanFFlag<"real-8-real-10">, Group<gfortran_Group>;
3430 defm real_8_real_16 : BooleanFFlag<"real-8-real-16">, Group<gfortran_Group>;
3431 defm real_8_real_4 : BooleanFFlag<"real-8-real-4">, Group<gfortran_Group>;
3432 defm realloc_lhs : BooleanFFlag<"realloc-lhs">, Group<gfortran_Group>;
3433 defm recursive : BooleanFFlag<"recursive">, Group<gfortran_Group>;
3434 defm repack_arrays : BooleanFFlag<"repack-arrays">, Group<gfortran_Group>;
3435 defm second_underscore : BooleanFFlag<"second-underscore">, Group<gfortran_Group>;
3436 defm sign_zero : BooleanFFlag<"sign-zero">, Group<gfortran_Group>;
3437 defm stack_arrays : BooleanFFlag<"stack-arrays">, Group<gfortran_Group>;
3438 defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>;
3439 defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>;
3442 def fsycl : Flag<["-"], "fsycl">, Group<sycl_Group>, Flags<[CC1Option, CoreOption]>,
3443 HelpText<"Enable SYCL kernels compilation for device">;
3444 def fno_sycl : Flag<["-"], "fno-sycl">, Group<sycl_Group>, Flags<[CoreOption]>,
3445 HelpText<"Disable SYCL kernels compilation for device">;
3446 def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>,
3447 HelpText<"SYCL language standard to compile for.">, Values<"2017, 121, 1.2.1, sycl-1.2.1">;
3449 //===----------------------------------------------------------------------===//
3451 //===----------------------------------------------------------------------===//
3453 let Flags = [CC1Option, NoDriverOption] in {
3455 //===----------------------------------------------------------------------===//
3457 //===----------------------------------------------------------------------===//
3459 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
3461 def target_cpu : Separate<["-"], "target-cpu">,
3462 HelpText<"Target a specific cpu type">;
3463 def target_feature : Separate<["-"], "target-feature">,
3464 HelpText<"Target specific attributes">;
3465 def triple : Separate<["-"], "triple">,
3466 HelpText<"Specify target triple (e.g. i686-apple-darwin9)">,
3467 MarshallingInfoString<"TargetOpts->Triple", "llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple())", "std::string">,
3468 AlwaysEmit, Normalizer<"normalizeTriple">, DenormalizeString;
3469 def target_abi : Separate<["-"], "target-abi">,
3470 HelpText<"Target a particular ABI type">;
3471 def target_sdk_version_EQ : Joined<["-"], "target-sdk-version=">,
3472 HelpText<"The version of target SDK used for compilation">;
3476 def target_linker_version : Separate<["-"], "target-linker-version">,
3477 HelpText<"Target linker version">;
3478 def triple_EQ : Joined<["-"], "triple=">, Alias<triple>;
3479 def mfpmath : Separate<["-"], "mfpmath">,
3480 HelpText<"Which unit to use for fp math">;
3482 def fpadding_on_unsigned_fixed_point : Flag<["-"], "fpadding-on-unsigned-fixed-point">,
3483 HelpText<"Force each unsigned fixed point type to have an extra bit of padding to align their scales with those of signed fixed point types">;
3484 def fno_padding_on_unsigned_fixed_point : Flag<["-"], "fno-padding-on-unsigned-fixed-point">;
3486 //===----------------------------------------------------------------------===//
3488 //===----------------------------------------------------------------------===//
3490 def analysis_UnoptimizedCFG : Flag<["-"], "unoptimized-cfg">,
3491 HelpText<"Generate unoptimized CFGs for all analyses">;
3492 def analysis_CFGAddImplicitDtors : Flag<["-"], "cfg-add-implicit-dtors">,
3493 HelpText<"Add C++ implicit destructors to CFGs for all analyses">;
3495 def analyzer_store : Separate<["-"], "analyzer-store">,
3496 HelpText<"Source Code Analysis - Abstract Memory Store Models">;
3497 def analyzer_store_EQ : Joined<["-"], "analyzer-store=">, Alias<analyzer_store>;
3499 def analyzer_constraints : Separate<["-"], "analyzer-constraints">,
3500 HelpText<"Source Code Analysis - Symbolic Constraint Engines">;
3501 def analyzer_constraints_EQ : Joined<["-"], "analyzer-constraints=">,
3502 Alias<analyzer_constraints>;
3504 def analyzer_output : Separate<["-"], "analyzer-output">,
3505 HelpText<"Source Code Analysis - Output Options">;
3506 def analyzer_output_EQ : Joined<["-"], "analyzer-output=">,
3507 Alias<analyzer_output>;
3509 def analyzer_purge : Separate<["-"], "analyzer-purge">,
3510 HelpText<"Source Code Analysis - Dead Symbol Removal Frequency">;
3511 def analyzer_purge_EQ : Joined<["-"], "analyzer-purge=">, Alias<analyzer_purge>;
3513 def analyzer_opt_analyze_headers : Flag<["-"], "analyzer-opt-analyze-headers">,
3514 HelpText<"Force the static analyzer to analyze functions defined in header files">;
3515 def analyzer_opt_analyze_nested_blocks : Flag<["-"], "analyzer-opt-analyze-nested-blocks">,
3516 HelpText<"Analyze the definitions of blocks in addition to functions">;
3517 def analyzer_display_progress : Flag<["-"], "analyzer-display-progress">,
3518 HelpText<"Emit verbose output about the analyzer's progress">;
3519 def analyze_function : Separate<["-"], "analyze-function">,
3520 HelpText<"Run analysis on specific function (for C++ include parameters in name)">;
3521 def analyze_function_EQ : Joined<["-"], "analyze-function=">, Alias<analyze_function>;
3522 def trim_egraph : Flag<["-"], "trim-egraph">,
3523 HelpText<"Only show error-related paths in the analysis graph">;
3524 def analyzer_viz_egraph_graphviz : Flag<["-"], "analyzer-viz-egraph-graphviz">,
3525 HelpText<"Display exploded graph using GraphViz">;
3526 def analyzer_dump_egraph : Separate<["-"], "analyzer-dump-egraph">,
3527 HelpText<"Dump exploded graph to the specified file">;
3528 def analyzer_dump_egraph_EQ : Joined<["-"], "analyzer-dump-egraph=">, Alias<analyzer_dump_egraph>;
3530 def analyzer_inline_max_stack_depth : Separate<["-"], "analyzer-inline-max-stack-depth">,
3531 HelpText<"Bound on stack depth while inlining (4 by default)">;
3532 def analyzer_inline_max_stack_depth_EQ : Joined<["-"], "analyzer-inline-max-stack-depth=">,
3533 Alias<analyzer_inline_max_stack_depth>;
3535 def analyzer_inlining_mode : Separate<["-"], "analyzer-inlining-mode">,
3536 HelpText<"Specify the function selection heuristic used during inlining">;
3537 def analyzer_inlining_mode_EQ : Joined<["-"], "analyzer-inlining-mode=">, Alias<analyzer_inlining_mode>;
3539 def analyzer_disable_retry_exhausted : Flag<["-"], "analyzer-disable-retry-exhausted">,
3540 HelpText<"Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)">;
3542 def analyzer_max_loop : Separate<["-"], "analyzer-max-loop">,
3543 HelpText<"The maximum number of times the analyzer will go through a loop">;
3544 def analyzer_stats : Flag<["-"], "analyzer-stats">,
3545 HelpText<"Print internal analyzer statistics.">;
3547 def analyzer_checker : Separate<["-"], "analyzer-checker">,
3548 HelpText<"Choose analyzer checkers to enable">,
3550 const char *Values =
3551 #define GET_CHECKERS
3552 #define CHECKER(FULLNAME, CLASS, HT, DOC_URI, IS_HIDDEN) FULLNAME ","
3553 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
3555 #define GET_PACKAGES
3556 #define PACKAGE(FULLNAME) FULLNAME ","
3557 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
3561 def analyzer_checker_EQ : Joined<["-"], "analyzer-checker=">,
3562 Alias<analyzer_checker>;
3564 def analyzer_disable_checker : Separate<["-"], "analyzer-disable-checker">,
3565 HelpText<"Choose analyzer checkers to disable">;
3566 def analyzer_disable_checker_EQ : Joined<["-"], "analyzer-disable-checker=">,
3567 Alias<analyzer_disable_checker>;
3569 def analyzer_disable_all_checks : Flag<["-"], "analyzer-disable-all-checks">,
3570 HelpText<"Disable all static analyzer checks">;
3572 def analyzer_checker_help : Flag<["-"], "analyzer-checker-help">,
3573 HelpText<"Display the list of analyzer checkers that are available">;
3575 def analyzer_checker_help_alpha : Flag<["-"], "analyzer-checker-help-alpha">,
3576 HelpText<"Display the list of in development analyzer checkers. These "
3577 "are NOT considered safe, they are unstable and will emit incorrect "
3578 "reports. Enable ONLY FOR DEVELOPMENT purposes">;
3580 def analyzer_checker_help_developer : Flag<["-"], "analyzer-checker-help-developer">,
3581 HelpText<"Display the list of developer-only checkers such as modeling "
3582 "and debug checkers">;
3584 def analyzer_config_help : Flag<["-"], "analyzer-config-help">,
3585 HelpText<"Display the list of -analyzer-config options. These are meant for "
3586 "development purposes only!">;
3588 def analyzer_list_enabled_checkers : Flag<["-"], "analyzer-list-enabled-checkers">,
3589 HelpText<"Display the list of enabled analyzer checkers">;
3591 def analyzer_config : Separate<["-"], "analyzer-config">,
3592 HelpText<"Choose analyzer options to enable">;
3594 def analyzer_checker_option_help : Flag<["-"], "analyzer-checker-option-help">,
3595 HelpText<"Display the list of checker and package options">;
3597 def analyzer_checker_option_help_alpha : Flag<["-"], "analyzer-checker-option-help-alpha">,
3598 HelpText<"Display the list of in development checker and package options. "
3599 "These are NOT considered safe, they are unstable and will emit "
3600 "incorrect reports. Enable ONLY FOR DEVELOPMENT purposes">;
3602 def analyzer_checker_option_help_developer : Flag<["-"], "analyzer-checker-option-help-developer">,
3603 HelpText<"Display the list of checker and package options meant for "
3604 "development purposes only">;
3606 def analyzer_config_compatibility_mode : Separate<["-"], "analyzer-config-compatibility-mode">,
3607 HelpText<"Don't emit errors on invalid analyzer-config inputs">;
3609 def analyzer_config_compatibility_mode_EQ : Joined<["-"], "analyzer-config-compatibility-mode=">,
3610 Alias<analyzer_config_compatibility_mode>;
3612 def analyzer_werror : Flag<["-"], "analyzer-werror">,
3613 HelpText<"Emit analyzer results as errors rather than warnings">;
3615 //===----------------------------------------------------------------------===//
3617 //===----------------------------------------------------------------------===//
3618 def migrator_no_nsalloc_error : Flag<["-"], "no-ns-alloc-error">,
3619 HelpText<"Do not error on use of NSAllocateCollectable/NSReallocateCollectable">;
3621 def migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">,
3622 HelpText<"Do not remove finalize method in gc mode">;
3624 //===----------------------------------------------------------------------===//
3626 //===----------------------------------------------------------------------===//
3628 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
3629 def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">;
3630 def debug_info_macro : Flag<["-"], "debug-info-macro">,
3631 HelpText<"Emit macro debug information">;
3632 def default_function_attr : Separate<["-"], "default-function-attr">,
3633 HelpText<"Apply given attribute to all functions">;
3634 def dwarf_version_EQ : Joined<["-"], "dwarf-version=">;
3635 def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">;
3636 def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,
3637 HelpText<"The string to embed in the Dwarf debug flags record.">;
3638 def record_command_line : Separate<["-"], "record-command-line">,
3639 HelpText<"The string to embed in the .LLVM.command.line section.">;
3640 def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">,
3641 HelpText<"DWARF debug sections compression">;
3642 def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">,
3643 HelpText<"DWARF debug sections compression type">;
3644 def mno_exec_stack : Flag<["-"], "mnoexecstack">,
3645 HelpText<"Mark the file as not needing an executable stack">;
3646 def massembler_no_warn : Flag<["-"], "massembler-no-warn">,
3647 HelpText<"Make assembler not emit warnings">;
3648 def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
3649 HelpText<"Make assembler warnings fatal">;
3650 def mrelax_relocations : Flag<["--"], "mrelax-relocations">,
3651 HelpText<"Use relaxable elf relocations">;
3652 def msave_temp_labels : Flag<["-"], "msave-temp-labels">,
3653 HelpText<"Save temporary labels in the symbol table. "
3654 "Note this may change .s semantics and shouldn't generally be used "
3655 "on compiler-generated code.">;
3656 def mrelocation_model : Separate<["-"], "mrelocation-model">,
3657 HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
3658 NormalizedValuesScope<"llvm::Reloc">,
3659 NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
3660 MarshallingInfoString<"CodeGenOpts.RelocationModel", "PIC_", "Model">,
3662 def fno_math_builtin : Flag<["-"], "fno-math-builtin">,
3663 HelpText<"Disable implicit builtin knowledge of math functions">;
3666 def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">,
3667 HelpText<"Don't run the LLVM IR verifier pass">;
3668 def disable_llvm_passes : Flag<["-"], "disable-llvm-passes">,
3669 HelpText<"Use together with -emit-llvm to get pristine LLVM IR from the "
3670 "frontend by not running any LLVM passes at all">;
3671 def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">,
3672 Alias<disable_llvm_passes>;
3673 def disable_lifetimemarkers : Flag<["-"], "disable-lifetime-markers">,
3674 HelpText<"Disable lifetime-markers emission even when optimizations are "
3676 def disable_O0_optnone : Flag<["-"], "disable-O0-optnone">,
3677 HelpText<"Disable adding the optnone attribute to functions at O0">;
3678 def disable_red_zone : Flag<["-"], "disable-red-zone">,
3679 HelpText<"Do not emit code that uses the red zone.">;
3680 def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">,
3681 HelpText<"Generate debug info with external references to clang modules"
3682 " or precompiled headers">;
3683 def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">,
3684 HelpText<"Generate explicit import from anonymous namespace to containing"
3686 def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">,
3687 HelpText<"Emit complete descriptions of template parameters in forward"
3689 def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">,
3690 HelpText<"Emit an error if a C++ static local initializer would need a guard variable">;
3691 def no_implicit_float : Flag<["-"], "no-implicit-float">,
3692 HelpText<"Don't generate implicit floating point instructions">;
3693 def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">,
3694 HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">;
3695 def fmerge_functions : Flag<["-"], "fmerge-functions">,
3696 HelpText<"Permit merging of identical functions when optimizing.">;
3697 def femit_coverage_notes : Flag<["-"], "femit-coverage-notes">,
3698 HelpText<"Emit a gcov coverage notes file when compiling.">;
3699 def femit_coverage_data: Flag<["-"], "femit-coverage-data">,
3700 HelpText<"Instrument the program to emit gcov coverage data when run.">;
3701 def coverage_data_file : Separate<["-"], "coverage-data-file">,
3702 HelpText<"Emit coverage data to this filename.">;
3703 def coverage_data_file_EQ : Joined<["-"], "coverage-data-file=">,
3704 Alias<coverage_data_file>;
3705 def coverage_notes_file : Separate<["-"], "coverage-notes-file">,
3706 HelpText<"Emit coverage notes to this filename.">;
3707 def coverage_notes_file_EQ : Joined<["-"], "coverage-notes-file=">,
3708 Alias<coverage_notes_file>;
3709 def coverage_version_EQ : Joined<["-"], "coverage-version=">,
3710 HelpText<"Four-byte version string for gcov files.">;
3711 def test_coverage : Flag<["-"], "test-coverage">,
3712 HelpText<"Do not generate coverage files or remove coverage changes from IR">;
3713 def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">,
3714 HelpText<"Dump the coverage mapping records, for testing">;
3715 def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">,
3716 HelpText<"Use register sized accesses to bit-fields, when possible.">;
3717 def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">,
3718 HelpText<"Turn off Type Based Alias Analysis">;
3719 def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">,
3720 HelpText<"Turn off struct-path aware Type Based Alias Analysis">;
3721 def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">,
3722 HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">;
3723 def mdebug_pass : Separate<["-"], "mdebug-pass">,
3724 HelpText<"Enable additional debug output">;
3725 def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">,
3726 HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">;
3727 def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">,
3728 HelpText<"Disable tail call optimization, keeping the call stack accurate">;
3729 def menable_no_infinities : Flag<["-"], "menable-no-infs">,
3730 HelpText<"Allow optimization to assume there are no infinities.">;
3731 def menable_no_nans : Flag<["-"], "menable-no-nans">,
3732 HelpText<"Allow optimization to assume there are no NaNs.">;
3733 def menable_unsafe_fp_math : Flag<["-"], "menable-unsafe-fp-math">,
3734 HelpText<"Allow unsafe floating-point math optimizations which may decrease "
3736 def mreassociate : Flag<["-"], "mreassociate">,
3737 HelpText<"Allow reassociation transformations for floating-point instructions">;
3738 def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">,
3739 HelpText<"Use IEEE 754 quadruple-precision for long double">;
3740 def mfloat_abi : Separate<["-"], "mfloat-abi">,
3741 HelpText<"The float ABI to use">;
3742 def mtp : Separate<["-"], "mtp">,
3743 HelpText<"Mode for reading thread pointer">;
3744 def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">,
3745 HelpText<"Limit float precision to the given value">;
3746 def split_stacks : Flag<["-"], "split-stacks">,
3747 HelpText<"Try to use a split stack if possible.">;
3748 def mregparm : Separate<["-"], "mregparm">,
3749 HelpText<"Limit the number of registers available for integer arguments">;
3750 def msmall_data_limit : Separate<["-"], "msmall-data-limit">,
3751 HelpText<"Put global and static data smaller than the limit into a special section">;
3752 def munwind_tables : Flag<["-"], "munwind-tables">,
3753 HelpText<"Generate unwinding tables for all functions">;
3754 def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">,
3755 HelpText<"Emit complete constructors and destructors as aliases when possible">;
3756 def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">,
3757 HelpText<"Link the given bitcode file before performing optimizations.">;
3758 def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">,
3759 HelpText<"Link and internalize needed symbols from the given bitcode file "
3760 "before performing optimizations.">;
3761 def mlink_cuda_bitcode : Separate<["-"], "mlink-cuda-bitcode">,
3762 Alias<mlink_builtin_bitcode>;
3763 def vectorize_loops : Flag<["-"], "vectorize-loops">,
3764 HelpText<"Run the Loop vectorization passes">;
3765 def vectorize_slp : Flag<["-"], "vectorize-slp">,
3766 HelpText<"Run the SLP vectorization passes">;
3767 def dependent_lib : Joined<["--"], "dependent-lib=">,
3768 HelpText<"Add dependent library">;
3769 def linker_option : Joined<["--"], "linker-option=">,
3770 HelpText<"Add linker option">;
3771 def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">,
3772 HelpText<"Sanitizer coverage type">;
3773 def fsanitize_coverage_indirect_calls
3774 : Flag<["-"], "fsanitize-coverage-indirect-calls">,
3775 HelpText<"Enable sanitizer coverage for indirect calls">;
3776 def fsanitize_coverage_trace_bb
3777 : Flag<["-"], "fsanitize-coverage-trace-bb">,
3778 HelpText<"Enable basic block tracing in sanitizer coverage">;
3779 def fsanitize_coverage_trace_cmp
3780 : Flag<["-"], "fsanitize-coverage-trace-cmp">,
3781 HelpText<"Enable cmp instruction tracing in sanitizer coverage">;
3782 def fsanitize_coverage_trace_div
3783 : Flag<["-"], "fsanitize-coverage-trace-div">,
3784 HelpText<"Enable div instruction tracing in sanitizer coverage">;
3785 def fsanitize_coverage_trace_gep
3786 : Flag<["-"], "fsanitize-coverage-trace-gep">,
3787 HelpText<"Enable gep instruction tracing in sanitizer coverage">;
3788 def fsanitize_coverage_8bit_counters
3789 : Flag<["-"], "fsanitize-coverage-8bit-counters">,
3790 HelpText<"Enable frequency counters in sanitizer coverage">;
3791 def fsanitize_coverage_inline_8bit_counters
3792 : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">,
3793 HelpText<"Enable inline 8-bit counters in sanitizer coverage">;
3794 def fsanitize_coverage_inline_bool_flag
3795 : Flag<["-"], "fsanitize-coverage-inline-bool-flag">,
3796 HelpText<"Enable inline bool flag in sanitizer coverage">;
3797 def fsanitize_coverage_pc_table
3798 : Flag<["-"], "fsanitize-coverage-pc-table">,
3799 HelpText<"Create a table of coverage-instrumented PCs">;
3800 def fsanitize_coverage_trace_pc
3801 : Flag<["-"], "fsanitize-coverage-trace-pc">,
3802 HelpText<"Enable PC tracing in sanitizer coverage">;
3803 def fsanitize_coverage_trace_pc_guard
3804 : Flag<["-"], "fsanitize-coverage-trace-pc-guard">,
3805 HelpText<"Enable PC tracing with guard in sanitizer coverage">;
3806 def fsanitize_coverage_no_prune
3807 : Flag<["-"], "fsanitize-coverage-no-prune">,
3808 HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">;
3809 def fsanitize_coverage_stack_depth
3810 : Flag<["-"], "fsanitize-coverage-stack-depth">,
3811 HelpText<"Enable max stack depth tracing">;
3812 def fpatchable_function_entry_offset_EQ
3813 : Joined<["-"], "fpatchable-function-entry-offset=">, MetaVarName<"<M>">,
3814 HelpText<"Generate M NOPs before function entry">;
3815 def fprofile_instrument_EQ : Joined<["-"], "fprofile-instrument=">,
3816 HelpText<"Enable PGO instrumentation. The accepted value is clang, llvm, "
3817 "or none">, Values<"none,clang,llvm">;
3818 def fprofile_instrument_path_EQ : Joined<["-"], "fprofile-instrument-path=">,
3819 HelpText<"Generate instrumented code to collect execution counts into "
3820 "<file> (overridden by LLVM_PROFILE_FILE env var)">;
3821 def fprofile_instrument_use_path_EQ :
3822 Joined<["-"], "fprofile-instrument-use-path=">,
3823 HelpText<"Specify the profile path in PGO use compilation">;
3824 def flto_visibility_public_std:
3825 Flag<["-"], "flto-visibility-public-std">,
3826 HelpText<"Use public LTO visibility for classes in std and stdext namespaces">;
3827 def flto_unit: Flag<["-"], "flto-unit">,
3828 HelpText<"Emit IR to support LTO unit features (CFI, whole program vtable opt)">;
3829 def fno_lto_unit: Flag<["-"], "fno-lto-unit">;
3830 def fdebug_pass_manager : Flag<["-"], "fdebug-pass-manager">,
3831 HelpText<"Prints debug information for the new pass manager">;
3832 def fno_debug_pass_manager : Flag<["-"], "fno-debug-pass-manager">,
3833 HelpText<"Disables debug printing for the new pass manager">;
3834 // The driver option takes the key as a parameter to the -msign-return-address=
3835 // and -mbranch-protection= options, but CC1 has a separate option so we
3836 // don't have to parse the parameter twice.
3837 def msign_return_address_key_EQ : Joined<["-"], "msign-return-address-key=">,
3838 Values<"a_key,b_key">;
3839 def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">;
3840 def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">;
3841 def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">,
3842 HelpText<"Emit Windows Control Flow Guard tables only (no checks)">;
3843 def cfguard : Flag<["-"], "cfguard">,
3844 HelpText<"Emit Windows Control Flow Guard tables and checks">;
3846 def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">,
3849 //===----------------------------------------------------------------------===//
3850 // Dependency Output Options
3851 //===----------------------------------------------------------------------===//
3853 def sys_header_deps : Flag<["-"], "sys-header-deps">,
3854 HelpText<"Include system headers in dependency output">;
3855 def module_file_deps : Flag<["-"], "module-file-deps">,
3856 HelpText<"Include module files in dependency output">;
3857 def header_include_file : Separate<["-"], "header-include-file">,
3858 HelpText<"Filename (or -) to write header include output to">;
3859 def show_includes : Flag<["--"], "show-includes">,
3860 HelpText<"Print cl.exe style /showIncludes to stdout">;
3862 //===----------------------------------------------------------------------===//
3863 // Diagnostic Options
3864 //===----------------------------------------------------------------------===//
3866 def diagnostic_log_file : Separate<["-"], "diagnostic-log-file">,
3867 HelpText<"Filename (or -) to log diagnostics to">;
3868 def diagnostic_serialized_file : Separate<["-"], "serialize-diagnostic-file">,
3869 MetaVarName<"<filename>">,
3870 HelpText<"File for serializing diagnostics in a binary format">;
3872 def fdiagnostics_format : Separate<["-"], "fdiagnostics-format">,
3873 HelpText<"Change diagnostic formatting to match IDE and command line tools">, Values<"clang,msvc,msvc-fallback,vi">;
3874 def fdiagnostics_show_category : Separate<["-"], "fdiagnostics-show-category">,
3875 HelpText<"Print diagnostic category">, Values<"none,id,name">;
3876 def fno_diagnostics_use_presumed_location : Flag<["-"], "fno-diagnostics-use-presumed-location">,
3877 HelpText<"Ignore #line directives when displaying diagnostic locations">;
3878 def ftabstop : Separate<["-"], "ftabstop">, MetaVarName<"<N>">,
3879 HelpText<"Set the tab stop distance.">;
3880 def ferror_limit : Separate<["-"], "ferror-limit">, MetaVarName<"<N>">,
3881 HelpText<"Set the maximum number of errors to emit before stopping (0 = no limit).">;
3882 def fmacro_backtrace_limit : Separate<["-"], "fmacro-backtrace-limit">, MetaVarName<"<N>">,
3883 HelpText<"Set the maximum number of entries to print in a macro expansion backtrace (0 = no limit).">;
3884 def ftemplate_backtrace_limit : Separate<["-"], "ftemplate-backtrace-limit">, MetaVarName<"<N>">,
3885 HelpText<"Set the maximum number of entries to print in a template instantiation backtrace (0 = no limit).">;
3886 def fconstexpr_backtrace_limit : Separate<["-"], "fconstexpr-backtrace-limit">, MetaVarName<"<N>">,
3887 HelpText<"Set the maximum number of entries to print in a constexpr evaluation backtrace (0 = no limit).">;
3888 def fspell_checking_limit : Separate<["-"], "fspell-checking-limit">, MetaVarName<"<N>">,
3889 HelpText<"Set the maximum number of times to perform spell checking on unrecognized identifiers (0 = no limit).">;
3890 def fcaret_diagnostics_max_lines :
3891 Separate<["-"], "fcaret-diagnostics-max-lines">, MetaVarName<"<N>">,
3892 HelpText<"Set the maximum number of source lines to show in a caret diagnostic">;
3893 def verify_EQ : CommaJoined<["-"], "verify=">,
3894 MetaVarName<"<prefixes>">,
3895 HelpText<"Verify diagnostic output using comment directives that start with"
3896 " prefixes in the comma-separated sequence <prefixes>">;
3897 def verify : Flag<["-"], "verify">,
3898 HelpText<"Equivalent to -verify=expected">;
3899 def verify_ignore_unexpected : Flag<["-"], "verify-ignore-unexpected">,
3900 HelpText<"Ignore unexpected diagnostic messages">;
3901 def verify_ignore_unexpected_EQ : CommaJoined<["-"], "verify-ignore-unexpected=">,
3902 HelpText<"Ignore unexpected diagnostic messages">;
3903 def Wno_rewrite_macros : Flag<["-"], "Wno-rewrite-macros">,
3904 HelpText<"Silence ObjC rewriting warnings">;
3906 //===----------------------------------------------------------------------===//
3908 //===----------------------------------------------------------------------===//
3910 // This isn't normally used, it is just here so we can parse a
3911 // CompilerInvocation out of a driver-derived argument vector.
3912 def cc1 : Flag<["-"], "cc1">;
3913 def cc1as : Flag<["-"], "cc1as">;
3915 def ast_merge : Separate<["-"], "ast-merge">,
3916 MetaVarName<"<ast file>">,
3917 HelpText<"Merge the given AST file into the translation unit being compiled.">;
3918 def aux_target_cpu : Separate<["-"], "aux-target-cpu">,
3919 HelpText<"Target a specific auxiliary cpu type">;
3920 def aux_target_feature : Separate<["-"], "aux-target-feature">,
3921 HelpText<"Target specific auxiliary attributes">;
3922 def aux_triple : Separate<["-"], "aux-triple">,
3923 HelpText<"Auxiliary target triple.">;
3924 def code_completion_at : Separate<["-"], "code-completion-at">,
3925 MetaVarName<"<file>:<line>:<column>">,
3926 HelpText<"Dump code-completion information at a location">;
3927 def remap_file : Separate<["-"], "remap-file">,
3928 MetaVarName<"<from>;<to>">,
3929 HelpText<"Replace the contents of the <from> file with the contents of the <to> file">;
3930 def code_completion_at_EQ : Joined<["-"], "code-completion-at=">,
3931 Alias<code_completion_at>;
3932 def code_completion_macros : Flag<["-"], "code-completion-macros">,
3933 HelpText<"Include macros in code-completion results">;
3934 def code_completion_patterns : Flag<["-"], "code-completion-patterns">,
3935 HelpText<"Include code patterns in code-completion results">;
3936 def no_code_completion_globals : Flag<["-"], "no-code-completion-globals">,
3937 HelpText<"Do not include global declarations in code-completion results.">;
3938 def no_code_completion_ns_level_decls : Flag<["-"], "no-code-completion-ns-level-decls">,
3939 HelpText<"Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.">;
3940 def code_completion_brief_comments : Flag<["-"], "code-completion-brief-comments">,
3941 HelpText<"Include brief documentation comments in code-completion results.">;
3942 def code_completion_with_fixits : Flag<["-"], "code-completion-with-fixits">,
3943 HelpText<"Include code completion results which require small fix-its.">;
3944 def disable_free : Flag<["-"], "disable-free">,
3945 HelpText<"Disable freeing of memory on exit">;
3946 def discard_value_names : Flag<["-"], "discard-value-names">,
3947 HelpText<"Discard value names in LLVM IR">;
3948 def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">,
3949 HelpText<"Load the named plugin (dynamic shared object)">;
3950 def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">,
3951 HelpText<"Use the named plugin action instead of the default action (use \"help\" to list available options)">;
3952 def plugin_arg : JoinedAndSeparate<["-"], "plugin-arg-">,
3953 MetaVarName<"<name> <arg>">,
3954 HelpText<"Pass <arg> to plugin <name>">;
3955 def add_plugin : Separate<["-"], "add-plugin">, MetaVarName<"<name>">,
3956 HelpText<"Use the named plugin action in addition to the default action">;
3957 def ast_dump_filter : Separate<["-"], "ast-dump-filter">,
3958 MetaVarName<"<dump_filter>">,
3959 HelpText<"Use with -ast-dump or -ast-print to dump/print only AST declaration"
3960 " nodes having a certain substring in a qualified name. Use"
3961 " -ast-list to list all filterable declaration node names.">;
3962 def fno_modules_global_index : Flag<["-"], "fno-modules-global-index">,
3963 HelpText<"Do not automatically generate or update the global module index">;
3964 def fno_modules_error_recovery : Flag<["-"], "fno-modules-error-recovery">,
3965 HelpText<"Do not automatically import modules for error recovery">;
3966 def fmodule_map_file_home_is_cwd : Flag<["-"], "fmodule-map-file-home-is-cwd">,
3967 HelpText<"Use the current working directory as the home directory of "
3968 "module maps specified by -fmodule-map-file=<FILE>">;
3969 def fmodule_feature : Separate<["-"], "fmodule-feature">,
3970 MetaVarName<"<feature>">,
3971 HelpText<"Enable <feature> in module map requires declarations">;
3972 def fmodules_embed_file_EQ : Joined<["-"], "fmodules-embed-file=">,
3973 MetaVarName<"<file>">,
3974 HelpText<"Embed the contents of the specified file into the module file "
3976 def fmodules_embed_all_files : Joined<["-"], "fmodules-embed-all-files">,
3977 HelpText<"Embed the contents of all files read by this compilation into "
3978 "the produced module file.">;
3979 def fmodules_local_submodule_visibility :
3980 Flag<["-"], "fmodules-local-submodule-visibility">,
3981 HelpText<"Enforce name visibility rules across submodules of the same "
3982 "top-level module.">;
3983 def fmodules_codegen :
3984 Flag<["-"], "fmodules-codegen">,
3985 HelpText<"Generate code for uses of this module that assumes an explicit "
3986 "object file will be built for the module">;
3987 def fmodules_debuginfo :
3988 Flag<["-"], "fmodules-debuginfo">,
3989 HelpText<"Generate debug info for types in an object file built from this "
3990 "module and do not generate them elsewhere">;
3991 def fmodule_format_EQ : Joined<["-"], "fmodule-format=">,
3992 HelpText<"Select the container format for clang modules and PCH. "
3993 "Supported options are 'raw' and 'obj'.">;
3994 def ftest_module_file_extension_EQ :
3995 Joined<["-"], "ftest-module-file-extension=">,
3996 HelpText<"introduce a module file extension for testing purposes. "
3997 "The argument is parsed as blockname:major:minor:hashed:user info">;
3998 def fconcepts_ts : Flag<["-"], "fconcepts-ts">,
3999 HelpText<"Enable C++ Extensions for Concepts. (deprecated - use -std=c++2a)">;
4000 def fno_concept_satisfaction_caching : Flag<["-"],
4001 "fno-concept-satisfaction-caching">,
4002 HelpText<"Disable satisfaction caching for C++2a Concepts.">;
4004 def frecovery_ast : Flag<["-"], "frecovery-ast">,
4005 HelpText<"Preserve expressions in AST rather than dropping them when "
4006 "encountering semantic errors">;
4007 def fno_recovery_ast : Flag<["-"], "fno-recovery-ast">;
4008 def frecovery_ast_type : Flag<["-"], "frecovery-ast-type">,
4009 HelpText<"Preserve the type for recovery expressions when possible "
4011 def fno_recovery_ast_type : Flag<["-"], "fno-recovery-ast-type">;
4013 let Group = Action_Group in {
4015 def Eonly : Flag<["-"], "Eonly">,
4016 HelpText<"Just run preprocessor, no output (for timings)">;
4017 def dump_raw_tokens : Flag<["-"], "dump-raw-tokens">,
4018 HelpText<"Lex file in raw mode and dump raw tokens">;
4019 def analyze : Flag<["-"], "analyze">,
4020 HelpText<"Run static analysis engine">;
4021 def dump_tokens : Flag<["-"], "dump-tokens">,
4022 HelpText<"Run preprocessor, dump internal rep of tokens">;
4023 def init_only : Flag<["-"], "init-only">,
4024 HelpText<"Only execute frontend initialization">;
4025 def fixit : Flag<["-"], "fixit">,
4026 HelpText<"Apply fix-it advice to the input source">;
4027 def fixit_EQ : Joined<["-"], "fixit=">,
4028 HelpText<"Apply fix-it advice creating a file with the given suffix">;
4029 def print_preamble : Flag<["-"], "print-preamble">,
4030 HelpText<"Print the \"preamble\" of a file, which is a candidate for implicit"
4031 " precompiled headers.">;
4032 def emit_html : Flag<["-"], "emit-html">,
4033 HelpText<"Output input source as HTML">;
4034 def ast_print : Flag<["-"], "ast-print">,
4035 HelpText<"Build ASTs and then pretty-print them">;
4036 def ast_list : Flag<["-"], "ast-list">,
4037 HelpText<"Build ASTs and print the list of declaration node qualified names">;
4038 def ast_dump : Flag<["-"], "ast-dump">,
4039 HelpText<"Build ASTs and then debug dump them">;
4040 def ast_dump_EQ : Joined<["-"], "ast-dump=">,
4041 HelpText<"Build ASTs and then debug dump them in the specified format. "
4042 "Supported formats include: default, json">;
4043 def ast_dump_all : Flag<["-"], "ast-dump-all">,
4044 HelpText<"Build ASTs and then debug dump them, forcing deserialization">;
4045 def ast_dump_all_EQ : Joined<["-"], "ast-dump-all=">,
4046 HelpText<"Build ASTs and then debug dump them in the specified format, "
4047 "forcing deserialization. Supported formats include: default, json">;
4048 def ast_dump_decl_types : Flag<["-"], "ast-dump-decl-types">,
4049 HelpText<"Include declaration types in AST dumps">;
4050 def templight_dump : Flag<["-"], "templight-dump">,
4051 HelpText<"Dump templight information to stdout">;
4052 def ast_dump_lookups : Flag<["-"], "ast-dump-lookups">,
4053 HelpText<"Build ASTs and then debug dump their name lookup tables">;
4054 def ast_view : Flag<["-"], "ast-view">,
4055 HelpText<"Build ASTs and view them with GraphViz">;
4056 def emit_module : Flag<["-"], "emit-module">,
4057 HelpText<"Generate pre-compiled module file from a module map">;
4058 def emit_module_interface : Flag<["-"], "emit-module-interface">,
4059 HelpText<"Generate pre-compiled module file from a C++ module interface">;
4060 def emit_header_module : Flag<["-"], "emit-header-module">,
4061 HelpText<"Generate pre-compiled module file from a set of header files">;
4062 def emit_pch : Flag<["-"], "emit-pch">,
4063 HelpText<"Generate pre-compiled header file">;
4064 def emit_llvm_bc : Flag<["-"], "emit-llvm-bc">,
4065 HelpText<"Build ASTs then convert to LLVM, emit .bc file">;
4066 def emit_llvm_only : Flag<["-"], "emit-llvm-only">,
4067 HelpText<"Build ASTs and convert to LLVM, discarding output">;
4068 def emit_codegen_only : Flag<["-"], "emit-codegen-only">,
4069 HelpText<"Generate machine code, but discard output">;
4070 def emit_obj : Flag<["-"], "emit-obj">,
4071 HelpText<"Emit native object files">;
4072 def rewrite_test : Flag<["-"], "rewrite-test">,
4073 HelpText<"Rewriter playground">;
4074 def rewrite_macros : Flag<["-"], "rewrite-macros">,
4075 HelpText<"Expand macros without full preprocessing">;
4076 def migrate : Flag<["-"], "migrate">,
4077 HelpText<"Migrate source code">;
4078 def compiler_options_dump : Flag<["-"], "compiler-options-dump">,
4079 HelpText<"Dump the compiler configuration options">;
4080 def print_dependency_directives_minimized_source : Flag<["-"],
4081 "print-dependency-directives-minimized-source">,
4082 HelpText<"Print the output of the dependency directives source minimizer">;
4085 def emit_llvm_uselists : Flag<["-"], "emit-llvm-uselists">,
4086 HelpText<"Preserve order of LLVM use-lists when serializing">;
4087 def no_emit_llvm_uselists : Flag<["-"], "no-emit-llvm-uselists">,
4088 HelpText<"Don't preserve order of LLVM use-lists when serializing">;
4090 def mt_migrate_directory : Separate<["-"], "mt-migrate-directory">,
4091 HelpText<"Directory for temporary files produced during ARC or ObjC migration">;
4092 def arcmt_check : Flag<["-"], "arcmt-check">,
4093 HelpText<"Check for ARC migration issues that need manual handling">;
4094 def arcmt_modify : Flag<["-"], "arcmt-modify">,
4095 HelpText<"Apply modifications to files to conform to ARC">;
4096 def arcmt_migrate : Flag<["-"], "arcmt-migrate">,
4097 HelpText<"Apply modifications and produces temporary files that conform to ARC">;
4099 def opt_record_file : Separate<["-"], "opt-record-file">,
4100 HelpText<"File name to use for YAML optimization record output">;
4101 def opt_record_passes : Separate<["-"], "opt-record-passes">,
4102 HelpText<"Only record remark information for passes whose names match the given regular expression">;
4103 def opt_record_format : Separate<["-"], "opt-record-format">,
4104 HelpText<"The format used for serializing remarks (default: YAML)">;
4106 def print_stats : Flag<["-"], "print-stats">,
4107 HelpText<"Print performance metrics and statistics">;
4108 def stats_file : Joined<["-"], "stats-file=">,
4109 HelpText<"Filename to write statistics to">;
4110 def fdump_record_layouts : Flag<["-"], "fdump-record-layouts">,
4111 HelpText<"Dump record layout information">;
4112 def fdump_record_layouts_simple : Flag<["-"], "fdump-record-layouts-simple">,
4113 HelpText<"Dump record layout information in a simple form used for testing">;
4114 def fix_what_you_can : Flag<["-"], "fix-what-you-can">,
4115 HelpText<"Apply fix-it advice even in the presence of unfixable errors">;
4116 def fix_only_warnings : Flag<["-"], "fix-only-warnings">,
4117 HelpText<"Apply fix-it advice only for warnings, not errors">;
4118 def fixit_recompile : Flag<["-"], "fixit-recompile">,
4119 HelpText<"Apply fix-it changes and recompile">;
4120 def fixit_to_temp : Flag<["-"], "fixit-to-temporary">,
4121 HelpText<"Apply fix-it changes to temporary files">;
4123 def foverride_record_layout_EQ : Joined<["-"], "foverride-record-layout=">,
4124 HelpText<"Override record layouts with those in the given file">;
4125 def pch_through_header_EQ : Joined<["-"], "pch-through-header=">,
4126 HelpText<"Stop PCH generation after including this file. When using a PCH, "
4127 "skip tokens until after this file is included.">;
4128 def pch_through_hdrstop_create : Flag<["-"], "pch-through-hdrstop-create">,
4129 HelpText<"When creating a PCH, stop PCH generation after #pragma hdrstop.">;
4130 def pch_through_hdrstop_use : Flag<["-"], "pch-through-hdrstop-use">,
4131 HelpText<"When using a PCH, skip tokens until after a #pragma hdrstop.">;
4132 def fno_pch_timestamp : Flag<["-"], "fno-pch-timestamp">,
4133 HelpText<"Disable inclusion of timestamp in precompiled headers">;
4134 def building_pch_with_obj : Flag<["-"], "building-pch-with-obj">,
4135 HelpText<"This compilation is part of building a PCH with corresponding object file.">;
4137 def aligned_alloc_unavailable : Flag<["-"], "faligned-alloc-unavailable">,
4138 HelpText<"Aligned allocation/deallocation functions are unavailable">;
4140 //===----------------------------------------------------------------------===//
4142 //===----------------------------------------------------------------------===//
4144 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
4146 def version : Flag<["-"], "version">,
4147 HelpText<"Print the compiler version">;
4148 def main_file_name : Separate<["-"], "main-file-name">,
4149 HelpText<"Main file name to use for debug info and source if missing">;
4150 def split_dwarf_output : Separate<["-"], "split-dwarf-output">,
4151 HelpText<"File name to use for split dwarf debug info output">;
4155 def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">,
4156 HelpText<"Weakly link in the blocks runtime">;
4157 def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">,
4158 HelpText<"Assume all functions with C linkage do not unwind">;
4159 def split_dwarf_file : Separate<["-"], "split-dwarf-file">,
4160 HelpText<"Name of the split dwarf debug info file to encode in the object file">;
4161 def fno_wchar : Flag<["-"], "fno-wchar">,
4162 HelpText<"Disable C++ builtin type wchar_t">;
4163 def fconstant_string_class : Separate<["-"], "fconstant-string-class">,
4164 MetaVarName<"<class name>">,
4165 HelpText<"Specify the class to use for constant Objective-C string objects.">;
4166 def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">,
4167 HelpText<"Objective-C++ Automatic Reference Counting standard library kind">, Values<"libc++,libstdc++,none">;
4168 def fobjc_runtime_has_weak : Flag<["-"], "fobjc-runtime-has-weak">,
4169 HelpText<"The target Objective-C runtime supports ARC weak operations">;
4170 def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">,
4171 HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">;
4172 def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">,
4173 HelpText<"disable the default synthesis of Objective-C properties">;
4174 def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">,
4175 HelpText<"enable extended encoding of block type signature">;
4176 def function_alignment : Separate<["-"], "function-alignment">,
4177 HelpText<"default alignment for functions">;
4178 def pic_level : Separate<["-"], "pic-level">,
4179 HelpText<"Value for __PIC__">;
4180 def pic_is_pie : Flag<["-"], "pic-is-pie">,
4181 HelpText<"File is for a position independent executable">;
4182 def fno_validate_pch : Flag<["-"], "fno-validate-pch">,
4183 HelpText<"Disable validation of precompiled headers">;
4184 def fallow_pch_with_errors : Flag<["-"], "fallow-pch-with-compiler-errors">,
4185 HelpText<"Accept a PCH file that was created with compiler errors">;
4186 def dump_deserialized_pch_decls : Flag<["-"], "dump-deserialized-decls">,
4187 HelpText<"Dump declarations that are deserialized from PCH, for testing">;
4188 def error_on_deserialized_pch_decl : Separate<["-"], "error-on-deserialized-decl">,
4189 HelpText<"Emit error if a specific declaration is deserialized from PCH, for testing">;
4190 def error_on_deserialized_pch_decl_EQ : Joined<["-"], "error-on-deserialized-decl=">,
4191 Alias<error_on_deserialized_pch_decl>;
4192 def static_define : Flag<["-"], "static-define">,
4193 HelpText<"Should __STATIC__ be defined">;
4194 def stack_protector : Separate<["-"], "stack-protector">,
4195 HelpText<"Enable stack protectors">;
4196 def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">,
4197 HelpText<"Lower bound for a buffer to be considered for stack protection">;
4198 def fvisibility : Separate<["-"], "fvisibility">,
4199 HelpText<"Default type and symbol visibility">;
4200 def ftype_visibility : Separate<["-"], "ftype-visibility">,
4201 HelpText<"Default type visibility">;
4202 def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">,
4203 HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">;
4204 def ftemplate_depth : Separate<["-"], "ftemplate-depth">,
4205 HelpText<"Maximum depth of recursive template instantiation">;
4206 def foperator_arrow_depth : Separate<["-"], "foperator-arrow-depth">,
4207 HelpText<"Maximum number of 'operator->'s to call for a member access">;
4208 def fconstexpr_depth : Separate<["-"], "fconstexpr-depth">,
4209 HelpText<"Maximum depth of recursive constexpr function calls">;
4210 def fconstexpr_steps : Separate<["-"], "fconstexpr-steps">,
4211 HelpText<"Maximum number of steps in constexpr function evaluation">;
4212 def fbracket_depth : Separate<["-"], "fbracket-depth">,
4213 HelpText<"Maximum nesting level for parentheses, brackets, and braces">;
4214 def fconst_strings : Flag<["-"], "fconst-strings">,
4215 HelpText<"Use a const qualified type for string literals in C and ObjC">;
4216 def fno_const_strings : Flag<["-"], "fno-const-strings">,
4217 HelpText<"Don't use a const qualified type for string literals in C and ObjC">;
4218 def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">,
4219 HelpText<"Ignore bit-field types when aligning structures">;
4220 def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">,
4221 HelpText<"Use a fake address space map; OpenCL testing purposes only">;
4222 def faddress_space_map_mangling_EQ : Joined<["-"], "faddress-space-map-mangling=">, MetaVarName<"<yes|no|target>">,
4223 HelpText<"Set the mode for address space map based mangling; OpenCL testing purposes only">;
4224 def funknown_anytype : Flag<["-"], "funknown-anytype">,
4225 HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">;
4226 def fdebugger_support : Flag<["-"], "fdebugger-support">,
4227 HelpText<"Enable special debugger support behavior">;
4228 def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">,
4229 HelpText<"Enable casting unknown expression results to id">;
4230 def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">,
4231 HelpText<"Enable special debugger support for Objective-C subscripting and literals">;
4232 def fdeprecated_macro : Flag<["-"], "fdeprecated-macro">,
4233 HelpText<"Defines the __DEPRECATED macro">;
4234 def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">,
4235 HelpText<"Undefines the __DEPRECATED macro">;
4236 def fobjc_subscripting_legacy_runtime : Flag<["-"], "fobjc-subscripting-legacy-runtime">,
4237 HelpText<"Allow Objective-C array and dictionary subscripting in legacy runtime">;
4238 def vtordisp_mode_EQ : Joined<["-"], "vtordisp-mode=">,
4239 HelpText<"Control vtordisp placement on win32 targets">;
4240 def fnative_half_type: Flag<["-"], "fnative-half-type">,
4241 HelpText<"Use the native half type for __fp16 instead of promoting to float">;
4242 def fnative_half_arguments_and_returns : Flag<["-"], "fnative-half-arguments-and-returns">,
4243 HelpText<"Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)">;
4244 def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">,
4245 HelpText<"Allow function arguments and returns of type half">;
4246 def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">,
4247 HelpText<"Set default calling convention">, Values<"cdecl,fastcall,stdcall,vectorcall,regcall">;
4248 def finclude_default_header : Flag<["-"], "finclude-default-header">,
4249 HelpText<"Include default header file for OpenCL">;
4250 def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">,
4251 HelpText<"Add OpenCL builtin function declarations (experimental)">;
4252 def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">,
4253 HelpText<"Preserve 3-component vector type">;
4254 def fwchar_type_EQ : Joined<["-"], "fwchar-type=">,
4255 HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">;
4256 def fsigned_wchar : Flag<["-"], "fsigned-wchar">,
4257 HelpText<"Use a signed type for wchar_t">;
4258 def fno_signed_wchar : Flag<["-"], "fno-signed-wchar">,
4259 HelpText<"Use an unsigned type for wchar_t">;
4260 def fcompatibility_qualified_id_block_param_type_checking : Flag<["-"], "fcompatibility-qualified-id-block-type-checking">,
4261 HelpText<"Allow using blocks with parameters of more specific type than "
4262 "the type system guarantees when a parameter is qualified id">;
4264 // FIXME: Remove these entirely once functionality/tests have been excised.
4265 def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>,
4266 HelpText<"Use GC exclusively for Objective-C related memory management">;
4267 def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>,
4268 HelpText<"Enable Objective-C garbage collection">;
4270 //===----------------------------------------------------------------------===//
4271 // Header Search Options
4272 //===----------------------------------------------------------------------===//
4274 def nostdsysteminc : Flag<["-"], "nostdsysteminc">,
4275 HelpText<"Disable standard system #include directories">;
4276 def fdisable_module_hash : Flag<["-"], "fdisable-module-hash">,
4277 HelpText<"Disable the module hash">;
4278 def fmodules_hash_content : Flag<["-"], "fmodules-hash-content">,
4279 HelpText<"Enable hashing the content of a module file">;
4280 def fmodules_strict_context_hash : Flag<["-"], "fmodules-strict-context-hash">,
4281 HelpText<"Enable hashing of all compiler options that could impact the "
4282 "semantics of a module in an implicit build">,
4283 MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash", "false">;
4284 def c_isystem : JoinedOrSeparate<["-"], "c-isystem">, MetaVarName<"<directory>">,
4285 HelpText<"Add directory to the C SYSTEM include search path">;
4286 def objc_isystem : JoinedOrSeparate<["-"], "objc-isystem">,
4287 MetaVarName<"<directory>">,
4288 HelpText<"Add directory to the ObjC SYSTEM include search path">;
4289 def objcxx_isystem : JoinedOrSeparate<["-"], "objcxx-isystem">,
4290 MetaVarName<"<directory>">,
4291 HelpText<"Add directory to the ObjC++ SYSTEM include search path">;
4292 def internal_isystem : JoinedOrSeparate<["-"], "internal-isystem">,
4293 MetaVarName<"<directory>">,
4294 HelpText<"Add directory to the internal system include search path; these "
4295 "are assumed to not be user-provided and are used to model system "
4296 "and standard headers' paths.">;
4297 def internal_externc_isystem : JoinedOrSeparate<["-"], "internal-externc-isystem">,
4298 MetaVarName<"<directory>">,
4299 HelpText<"Add directory to the internal system include search path with "
4300 "implicit extern \"C\" semantics; these are assumed to not be "
4301 "user-provided and are used to model system and standard headers' "
4304 //===----------------------------------------------------------------------===//
4305 // Preprocessor Options
4306 //===----------------------------------------------------------------------===//
4308 def chain_include : Separate<["-"], "chain-include">, MetaVarName<"<file>">,
4309 HelpText<"Include and chain a header file after turning it into PCH">;
4310 def preamble_bytes_EQ : Joined<["-"], "preamble-bytes=">,
4311 HelpText<"Assume that the precompiled header is a precompiled preamble "
4312 "covering the first N bytes of the main file">;
4313 def detailed_preprocessing_record : Flag<["-"], "detailed-preprocessing-record">,
4314 HelpText<"include a detailed record of preprocessing actions">;
4315 def setup_static_analyzer : Flag<["-"], "setup-static-analyzer">,
4316 HelpText<"Set up preprocessor for static analyzer (done automatically when static analyzer is run).">;
4317 def disable_pragma_debug_crash : Flag<["-"], "disable-pragma-debug-crash">,
4318 HelpText<"Disable any #pragma clang __debug that can lead to crashing behavior. This is meant for testing.">;
4320 //===----------------------------------------------------------------------===//
4322 //===----------------------------------------------------------------------===//
4324 def cl_ext_EQ : CommaJoined<["-"], "cl-ext=">,
4325 HelpText<"OpenCL only. Enable or disable OpenCL extensions. The argument is a comma-separated sequence of one or more extension names, each prefixed by '+' or '-'.">;
4327 //===----------------------------------------------------------------------===//
4329 //===----------------------------------------------------------------------===//
4331 def fcuda_is_device : Flag<["-"], "fcuda-is-device">,
4332 HelpText<"Generate code for CUDA device">;
4333 def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">,
4334 HelpText<"Incorporate CUDA device-side binary into host object file.">;
4335 def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">,
4336 HelpText<"Allow variadic functions in CUDA device code.">;
4337 def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">,
4338 HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">;
4340 //===----------------------------------------------------------------------===//
4342 //===----------------------------------------------------------------------===//
4344 def fopenmp_is_device : Flag<["-"], "fopenmp-is-device">,
4345 HelpText<"Generate code only for an OpenMP target device.">;
4346 def fopenmp_host_ir_file_path : Separate<["-"], "fopenmp-host-ir-file-path">,
4347 HelpText<"Path to the IR file produced by the frontend for the host.">;
4349 //===----------------------------------------------------------------------===//
4351 //===----------------------------------------------------------------------===//
4353 def fsycl_is_device : Flag<["-"], "fsycl-is-device">,
4354 HelpText<"Generate code for SYCL device.">;
4356 } // let Flags = [CC1Option]
4358 //===----------------------------------------------------------------------===//
4359 // cc1as-only Options
4360 //===----------------------------------------------------------------------===//
4362 let Flags = [CC1AsOption, NoDriverOption] in {
4365 def n : Flag<["-"], "n">,
4366 HelpText<"Don't automatically start assembly file with a text section">;
4369 def filetype : Separate<["-"], "filetype">,
4370 HelpText<"Specify the output file type ('asm', 'null', or 'obj')">;
4372 // Transliterate Options
4373 def output_asm_variant : Separate<["-"], "output-asm-variant">,
4374 HelpText<"Select the asm variant index to use for output">;
4375 def show_encoding : Flag<["-"], "show-encoding">,
4376 HelpText<"Show instruction encoding information in transliterate mode">;
4377 def show_inst : Flag<["-"], "show-inst">,
4378 HelpText<"Show internal instruction representation in transliterate mode">;
4381 def dwarf_debug_producer : Separate<["-"], "dwarf-debug-producer">,
4382 HelpText<"The string to embed in the Dwarf debug AT_producer record.">;
4384 def defsym : Separate<["-"], "defsym">,
4385 HelpText<"Define a value for a symbol">;
4387 } // let Flags = [CC1AsOption]
4389 //===----------------------------------------------------------------------===//
4391 //===----------------------------------------------------------------------===//
4393 def cl_Group : OptionGroup<"<clang-cl options>">, Flags<[CLOption]>,
4394 HelpText<"CL.EXE COMPATIBILITY OPTIONS">;
4396 def cl_compile_Group : OptionGroup<"<clang-cl compile-only options>">,
4399 def cl_ignored_Group : OptionGroup<"<clang-cl ignored options>">,
4402 class CLFlag<string name> : Option<["/", "-"], name, KIND_FLAG>,
4403 Group<cl_Group>, Flags<[CLOption, DriverOption]>;
4405 class CLCompileFlag<string name> : Option<["/", "-"], name, KIND_FLAG>,
4406 Group<cl_compile_Group>, Flags<[CLOption, DriverOption]>;
4408 class CLIgnoredFlag<string name> : Option<["/", "-"], name, KIND_FLAG>,
4409 Group<cl_ignored_Group>, Flags<[CLOption, DriverOption]>;
4411 class CLJoined<string name> : Option<["/", "-"], name, KIND_JOINED>,
4412 Group<cl_Group>, Flags<[CLOption, DriverOption]>;
4414 class CLCompileJoined<string name> : Option<["/", "-"], name, KIND_JOINED>,
4415 Group<cl_compile_Group>, Flags<[CLOption, DriverOption]>;
4417 class CLIgnoredJoined<string name> : Option<["/", "-"], name, KIND_JOINED>,
4418 Group<cl_ignored_Group>, Flags<[CLOption, DriverOption, HelpHidden]>;
4420 class CLJoinedOrSeparate<string name> : Option<["/", "-"], name,
4421 KIND_JOINED_OR_SEPARATE>, Group<cl_Group>, Flags<[CLOption, DriverOption]>;
4423 class CLCompileJoinedOrSeparate<string name> : Option<["/", "-"], name,
4424 KIND_JOINED_OR_SEPARATE>, Group<cl_compile_Group>,
4425 Flags<[CLOption, DriverOption]>;
4427 class CLRemainingArgsJoined<string name> : Option<["/", "-"], name,
4428 KIND_REMAINING_ARGS_JOINED>, Group<cl_Group>, Flags<[CLOption, DriverOption]>;
4431 // (We don't put any of these in cl_compile_Group as the options they alias are
4432 // already in the right group.)
4434 def _SLASH_Brepro : CLFlag<"Brepro">,
4435 HelpText<"Do not write current time into COFF output (breaks link.exe /incremental)">,
4436 Alias<mno_incremental_linker_compatible>;
4437 def _SLASH_Brepro_ : CLFlag<"Brepro-">,
4438 HelpText<"Write current time into COFF output (default)">,
4439 Alias<mincremental_linker_compatible>;
4440 def _SLASH_C : CLFlag<"C">,
4441 HelpText<"Do not discard comments when preprocessing">, Alias<C>;
4442 def _SLASH_c : CLFlag<"c">, HelpText<"Compile only">, Alias<c>;
4443 def _SLASH_d1PP : CLFlag<"d1PP">,
4444 HelpText<"Retain macro definitions in /E mode">, Alias<dD>;
4445 def _SLASH_d1reportAllClassLayout : CLFlag<"d1reportAllClassLayout">,
4446 HelpText<"Dump record layout information">,
4447 Alias<Xclang>, AliasArgs<["-fdump-record-layouts"]>;
4448 def _SLASH_diagnostics_caret : CLFlag<"diagnostics:caret">,
4449 HelpText<"Enable caret and column diagnostics (default)">;
4450 def _SLASH_diagnostics_column : CLFlag<"diagnostics:column">,
4451 HelpText<"Disable caret diagnostics but keep column info">;
4452 def _SLASH_diagnostics_classic : CLFlag<"diagnostics:classic">,
4453 HelpText<"Disable column and caret diagnostics">;
4454 def _SLASH_D : CLJoinedOrSeparate<"D">, HelpText<"Define macro">,
4455 MetaVarName<"<macro[=value]>">, Alias<D>;
4456 def _SLASH_E : CLFlag<"E">, HelpText<"Preprocess to stdout">, Alias<E>;
4457 def _SLASH_fp_except : CLFlag<"fp:except">, HelpText<"">, Alias<ftrapping_math>;
4458 def _SLASH_fp_except_ : CLFlag<"fp:except-">,
4459 HelpText<"">, Alias<fno_trapping_math>;
4460 def _SLASH_fp_fast : CLFlag<"fp:fast">, HelpText<"">, Alias<ffast_math>;
4461 def _SLASH_fp_precise : CLFlag<"fp:precise">,
4462 HelpText<"">, Alias<fno_fast_math>;
4463 def _SLASH_fp_strict : CLFlag<"fp:strict">, HelpText<"">, Alias<fno_fast_math>;
4464 def _SLASH_GA : CLFlag<"GA">, Alias<ftlsmodel_EQ>, AliasArgs<["local-exec"]>,
4465 HelpText<"Assume thread-local variables are defined in the executable">;
4466 def _SLASH_GR : CLFlag<"GR">, HelpText<"Emit RTTI data (default)">;
4467 def _SLASH_GR_ : CLFlag<"GR-">, HelpText<"Do not emit RTTI data">;
4468 def _SLASH_GF : CLIgnoredFlag<"GF">,
4469 HelpText<"Enable string pooling (default)">;
4470 def _SLASH_GF_ : CLFlag<"GF-">, HelpText<"Disable string pooling">,
4471 Alias<fwritable_strings>;
4472 def _SLASH_GS : CLFlag<"GS">,
4473 HelpText<"Enable buffer security check (default)">;
4474 def _SLASH_GS_ : CLFlag<"GS-">, HelpText<"Disable buffer security check">;
4475 def : CLFlag<"Gs">, HelpText<"Use stack probes (default)">,
4476 Alias<mstack_probe_size>, AliasArgs<["4096"]>;
4477 def _SLASH_Gs : CLJoined<"Gs">,
4478 HelpText<"Set stack probe size (default 4096)">, Alias<mstack_probe_size>;
4479 def _SLASH_Gy : CLFlag<"Gy">, HelpText<"Put each function in its own section">,
4480 Alias<ffunction_sections>;
4481 def _SLASH_Gy_ : CLFlag<"Gy-">,
4482 HelpText<"Do not put each function in its own section (default)">,
4483 Alias<fno_function_sections>;
4484 def _SLASH_Gw : CLFlag<"Gw">, HelpText<"Put each data item in its own section">,
4485 Alias<fdata_sections>;
4486 def _SLASH_Gw_ : CLFlag<"Gw-">,
4487 HelpText<"Do not put each data item in its own section (default)">,
4488 Alias<fno_data_sections>;
4489 def _SLASH_help : CLFlag<"help">, Alias<help>,
4490 HelpText<"Display available options">;
4491 def _SLASH_HELP : CLFlag<"HELP">, Alias<help>;
4492 def _SLASH_I : CLJoinedOrSeparate<"I">,
4493 HelpText<"Add directory to include search path">, MetaVarName<"<dir>">,
4495 def _SLASH_J : CLFlag<"J">, HelpText<"Make char type unsigned">,
4496 Alias<funsigned_char>;
4498 // The _SLASH_O option handles all the /O flags, but we also provide separate
4499 // aliased options to provide separate help messages.
4500 def _SLASH_O : CLJoined<"O">,
4501 HelpText<"Set multiple /O flags at once; e.g. '/O2y-' for '/O2 /Oy-'">,
4502 MetaVarName<"<flags>">;
4503 def : CLFlag<"O1">, Alias<_SLASH_O>, AliasArgs<["1"]>,
4504 HelpText<"Optimize for size (like /Og /Os /Oy /Ob2 /GF /Gy)">;
4505 def : CLFlag<"O2">, Alias<_SLASH_O>, AliasArgs<["2"]>,
4506 HelpText<"Optimize for speed (like /Og /Oi /Ot /Oy /Ob2 /GF /Gy)">;
4507 def : CLFlag<"Ob0">, Alias<_SLASH_O>, AliasArgs<["b0"]>,
4508 HelpText<"Disable function inlining">;
4509 def : CLFlag<"Ob1">, Alias<_SLASH_O>, AliasArgs<["b1"]>,
4510 HelpText<"Only inline functions explicitly or implicitly marked inline">;
4511 def : CLFlag<"Ob2">, Alias<_SLASH_O>, AliasArgs<["b2"]>,
4512 HelpText<"Inline functions as deemed beneficial by the compiler">;
4513 def : CLFlag<"Od">, Alias<_SLASH_O>, AliasArgs<["d"]>,
4514 HelpText<"Disable optimization">;
4515 def : CLFlag<"Og">, Alias<_SLASH_O>, AliasArgs<["g"]>,
4516 HelpText<"No effect">;
4517 def : CLFlag<"Oi">, Alias<_SLASH_O>, AliasArgs<["i"]>,
4518 HelpText<"Enable use of builtin functions">;
4519 def : CLFlag<"Oi-">, Alias<_SLASH_O>, AliasArgs<["i-"]>,
4520 HelpText<"Disable use of builtin functions">;
4521 def : CLFlag<"Os">, Alias<_SLASH_O>, AliasArgs<["s"]>,
4522 HelpText<"Optimize for size">;
4523 def : CLFlag<"Ot">, Alias<_SLASH_O>, AliasArgs<["t"]>,
4524 HelpText<"Optimize for speed">;
4525 def : CLFlag<"Ox">, Alias<_SLASH_O>, AliasArgs<["x"]>,
4526 HelpText<"Deprecated (like /Og /Oi /Ot /Oy /Ob2); use /O2">;
4527 def : CLFlag<"Oy">, Alias<_SLASH_O>, AliasArgs<["y"]>,
4528 HelpText<"Enable frame pointer omission (x86 only)">;
4529 def : CLFlag<"Oy-">, Alias<_SLASH_O>, AliasArgs<["y-"]>,
4530 HelpText<"Disable frame pointer omission (x86 only, default)">;
4532 def _SLASH_QUESTION : CLFlag<"?">, Alias<help>,
4533 HelpText<"Display available options">;
4534 def _SLASH_Qvec : CLFlag<"Qvec">,
4535 HelpText<"Enable the loop vectorization passes">, Alias<fvectorize>;
4536 def _SLASH_Qvec_ : CLFlag<"Qvec-">,
4537 HelpText<"Disable the loop vectorization passes">, Alias<fno_vectorize>;
4538 def _SLASH_showIncludes : CLFlag<"showIncludes">,
4539 HelpText<"Print info about included files to stderr">;
4540 def _SLASH_showIncludes_user : CLFlag<"showIncludes:user">,
4541 HelpText<"Like /showIncludes but omit system headers">;
4542 def _SLASH_showFilenames : CLFlag<"showFilenames">,
4543 HelpText<"Print the name of each compiled file">;
4544 def _SLASH_showFilenames_ : CLFlag<"showFilenames-">,
4545 HelpText<"Do not print the name of each compiled file (default)">;
4546 def _SLASH_source_charset : CLCompileJoined<"source-charset:">,
4547 HelpText<"Set source encoding, supports only UTF-8">,
4548 Alias<finput_charset_EQ>;
4549 def _SLASH_execution_charset : CLCompileJoined<"execution-charset:">,
4550 HelpText<"Set runtime encoding, supports only UTF-8">,
4551 Alias<fexec_charset_EQ>;
4552 def _SLASH_std : CLCompileJoined<"std:">,
4553 HelpText<"Set C++ version (c++14,c++17,c++latest)">;
4554 def _SLASH_U : CLJoinedOrSeparate<"U">, HelpText<"Undefine macro">,
4555 MetaVarName<"<macro>">, Alias<U>;
4556 def _SLASH_validate_charset : CLFlag<"validate-charset">,
4557 Alias<W_Joined>, AliasArgs<["invalid-source-encoding"]>;
4558 def _SLASH_validate_charset_ : CLFlag<"validate-charset-">,
4559 Alias<W_Joined>, AliasArgs<["no-invalid-source-encoding"]>;
4560 def _SLASH_W0 : CLFlag<"W0">, HelpText<"Disable all warnings">, Alias<w>;
4561 def _SLASH_W1 : CLFlag<"W1">, HelpText<"Enable -Wall">, Alias<Wall>;
4562 def _SLASH_W2 : CLFlag<"W2">, HelpText<"Enable -Wall">, Alias<Wall>;
4563 def _SLASH_W3 : CLFlag<"W3">, HelpText<"Enable -Wall">, Alias<Wall>;
4564 def _SLASH_W4 : CLFlag<"W4">, HelpText<"Enable -Wall and -Wextra">, Alias<WCL4>;
4565 def _SLASH_Wall : CLFlag<"Wall">, HelpText<"Enable -Weverything">,
4566 Alias<W_Joined>, AliasArgs<["everything"]>;
4567 def _SLASH_WX : CLFlag<"WX">, HelpText<"Treat warnings as errors">,
4568 Alias<W_Joined>, AliasArgs<["error"]>;
4569 def _SLASH_WX_ : CLFlag<"WX-">,
4570 HelpText<"Do not treat warnings as errors (default)">,
4571 Alias<W_Joined>, AliasArgs<["no-error"]>;
4572 def _SLASH_w_flag : CLFlag<"w">, HelpText<"Disable all warnings">, Alias<w>;
4573 def _SLASH_wd4005 : CLFlag<"wd4005">, Alias<W_Joined>,
4574 AliasArgs<["no-macro-redefined"]>;
4575 def _SLASH_wd4018 : CLFlag<"wd4018">, Alias<W_Joined>,
4576 AliasArgs<["no-sign-compare"]>;
4577 def _SLASH_wd4100 : CLFlag<"wd4100">, Alias<W_Joined>,
4578 AliasArgs<["no-unused-parameter"]>;
4579 def _SLASH_wd4910 : CLFlag<"wd4910">, Alias<W_Joined>,
4580 AliasArgs<["no-dllexport-explicit-instantiation-decl"]>;
4581 def _SLASH_wd4996 : CLFlag<"wd4996">, Alias<W_Joined>,
4582 AliasArgs<["no-deprecated-declarations"]>;
4583 def _SLASH_vd : CLJoined<"vd">, HelpText<"Control vtordisp placement">,
4584 Alias<vtordisp_mode_EQ>;
4585 def _SLASH_X : CLFlag<"X">,
4586 HelpText<"Do not add %INCLUDE% to include search path">, Alias<nostdlibinc>;
4587 def _SLASH_Zc_sizedDealloc : CLFlag<"Zc:sizedDealloc">,
4588 HelpText<"Enable C++14 sized global deallocation functions">,
4589 Alias<fsized_deallocation>;
4590 def _SLASH_Zc_sizedDealloc_ : CLFlag<"Zc:sizedDealloc-">,
4591 HelpText<"Disable C++14 sized global deallocation functions">,
4592 Alias<fno_sized_deallocation>;
4593 def _SLASH_Zc_alignedNew : CLFlag<"Zc:alignedNew">,
4594 HelpText<"Enable C++17 aligned allocation functions">,
4595 Alias<faligned_allocation>;
4596 def _SLASH_Zc_alignedNew_ : CLFlag<"Zc:alignedNew-">,
4597 HelpText<"Disable C++17 aligned allocation functions">,
4598 Alias<fno_aligned_allocation>;
4599 def _SLASH_Zc_char8_t : CLFlag<"Zc:char8_t">,
4600 HelpText<"Enable char8_t from C++2a">,
4602 def _SLASH_Zc_char8_t_ : CLFlag<"Zc:char8_t-">,
4603 HelpText<"Disable char8_t from c++2a">,
4604 Alias<fno_char8__t>;
4605 def _SLASH_Zc_strictStrings : CLFlag<"Zc:strictStrings">,
4606 HelpText<"Treat string literals as const">, Alias<W_Joined>,
4607 AliasArgs<["error=c++11-compat-deprecated-writable-strings"]>;
4608 def _SLASH_Zc_threadSafeInit : CLFlag<"Zc:threadSafeInit">,
4609 HelpText<"Enable thread-safe initialization of static variables">,
4610 Alias<fthreadsafe_statics>;
4611 def _SLASH_Zc_threadSafeInit_ : CLFlag<"Zc:threadSafeInit-">,
4612 HelpText<"Disable thread-safe initialization of static variables">,
4613 Alias<fno_threadsafe_statics>;
4614 def _SLASH_Zc_trigraphs : CLFlag<"Zc:trigraphs">,
4615 HelpText<"Enable trigraphs">, Alias<ftrigraphs>;
4616 def _SLASH_Zc_trigraphs_off : CLFlag<"Zc:trigraphs-">,
4617 HelpText<"Disable trigraphs (default)">, Alias<fno_trigraphs>;
4618 def _SLASH_Zc_twoPhase : CLFlag<"Zc:twoPhase">,
4619 HelpText<"Enable two-phase name lookup in templates">,
4620 Alias<fno_delayed_template_parsing>;
4621 def _SLASH_Zc_twoPhase_ : CLFlag<"Zc:twoPhase-">,
4622 HelpText<"Disable two-phase name lookup in templates (default)">,
4623 Alias<fdelayed_template_parsing>;
4624 def _SLASH_Z7 : CLFlag<"Z7">,
4625 HelpText<"Enable CodeView debug information in object files">;
4626 def _SLASH_Zd : CLFlag<"Zd">,
4627 HelpText<"Emit debug line number tables only">;
4628 def _SLASH_Zi : CLFlag<"Zi">, Alias<_SLASH_Z7>,
4629 HelpText<"Like /Z7">;
4630 def _SLASH_Zp : CLJoined<"Zp">,
4631 HelpText<"Set default maximum struct packing alignment">,
4632 Alias<fpack_struct_EQ>;
4633 def _SLASH_Zp_flag : CLFlag<"Zp">,
4634 HelpText<"Set default maximum struct packing alignment to 1">,
4635 Alias<fpack_struct_EQ>, AliasArgs<["1"]>;
4636 def _SLASH_Zs : CLFlag<"Zs">, HelpText<"Syntax-check only">,
4637 Alias<fsyntax_only>;
4638 def _SLASH_openmp_ : CLFlag<"openmp-">,
4639 HelpText<"Disable OpenMP support">, Alias<fno_openmp>;
4640 def _SLASH_openmp : CLFlag<"openmp">, HelpText<"Enable OpenMP support">,
4642 def _SLASH_openmp_experimental : CLFlag<"openmp:experimental">,
4643 HelpText<"Enable OpenMP support with experimental SIMD support">,
4648 def _SLASH_arch : CLCompileJoined<"arch:">,
4649 HelpText<"Set architecture for code generation">;
4651 def _SLASH_M_Group : OptionGroup<"</M group>">, Group<cl_compile_Group>;
4652 def _SLASH_volatile_Group : OptionGroup<"</volatile group>">,
4653 Group<cl_compile_Group>;
4655 def _SLASH_EH : CLJoined<"EH">, HelpText<"Set exception handling model">;
4656 def _SLASH_EP : CLFlag<"EP">,
4657 HelpText<"Disable linemarker output and preprocess to stdout">;
4658 def _SLASH_FA : CLFlag<"FA">,
4659 HelpText<"Output assembly code file during compilation">;
4660 def _SLASH_Fa : CLJoined<"Fa">,
4661 HelpText<"Set assembly output file name (with /FA)">,
4662 MetaVarName<"<file or dir/>">;
4663 def _SLASH_fallback : CLCompileFlag<"fallback">,
4664 HelpText<"Fall back to cl.exe if clang-cl fails to compile">;
4665 def _SLASH_FI : CLJoinedOrSeparate<"FI">,
4666 HelpText<"Include file before parsing">, Alias<include_>;
4667 def _SLASH_Fe : CLJoined<"Fe">,
4668 HelpText<"Set output executable file name">,
4669 MetaVarName<"<file or dir/>">;
4670 def _SLASH_Fi : CLCompileJoined<"Fi">,
4671 HelpText<"Set preprocess output file name (with /P)">,
4672 MetaVarName<"<file>">;
4673 def _SLASH_Fo : CLCompileJoined<"Fo">,
4674 HelpText<"Set output object file (with /c)">,
4675 MetaVarName<"<file or dir/>">;
4676 def _SLASH_guard : CLJoined<"guard:">,
4677 HelpText<"Enable Control Flow Guard with /guard:cf, or only the table with /guard:cf,nochecks">;
4678 def _SLASH_GX : CLFlag<"GX">,
4679 HelpText<"Deprecated; use /EHsc">;
4680 def _SLASH_GX_ : CLFlag<"GX-">,
4681 HelpText<"Deprecated (like not passing /EH)">;
4682 def _SLASH_imsvc : CLJoinedOrSeparate<"imsvc">,
4683 HelpText<"Add <dir> to system include search path, as if in %INCLUDE%">,
4684 MetaVarName<"<dir>">;
4685 def _SLASH_LD : CLFlag<"LD">, HelpText<"Create DLL">;
4686 def _SLASH_LDd : CLFlag<"LDd">, HelpText<"Create debug DLL">;
4687 def _SLASH_link : CLRemainingArgsJoined<"link">,
4688 HelpText<"Forward options to the linker">, MetaVarName<"<options>">;
4689 def _SLASH_MD : Option<["/", "-"], "MD", KIND_FLAG>, Group<_SLASH_M_Group>,
4690 Flags<[CLOption, DriverOption]>, HelpText<"Use DLL run-time">;
4691 def _SLASH_MDd : Option<["/", "-"], "MDd", KIND_FLAG>, Group<_SLASH_M_Group>,
4692 Flags<[CLOption, DriverOption]>, HelpText<"Use DLL debug run-time">;
4693 def _SLASH_MT : Option<["/", "-"], "MT", KIND_FLAG>, Group<_SLASH_M_Group>,
4694 Flags<[CLOption, DriverOption]>, HelpText<"Use static run-time">;
4695 def _SLASH_MTd : Option<["/", "-"], "MTd", KIND_FLAG>, Group<_SLASH_M_Group>,
4696 Flags<[CLOption, DriverOption]>, HelpText<"Use static debug run-time">;
4697 def _SLASH_o : CLJoinedOrSeparate<"o">,
4698 HelpText<"Deprecated (set output file name); use /Fe or /Fe">,
4699 MetaVarName<"<file or dir/>">;
4700 def _SLASH_P : CLFlag<"P">, HelpText<"Preprocess to file">;
4701 def _SLASH_Tc : CLCompileJoinedOrSeparate<"Tc">,
4702 HelpText<"Treat <file> as C source file">, MetaVarName<"<file>">;
4703 def _SLASH_TC : CLCompileFlag<"TC">, HelpText<"Treat all source files as C">;
4704 def _SLASH_Tp : CLCompileJoinedOrSeparate<"Tp">,
4705 HelpText<"Treat <file> as C++ source file">, MetaVarName<"<file>">;
4706 def _SLASH_TP : CLCompileFlag<"TP">, HelpText<"Treat all source files as C++">;
4707 def _SLASH_volatile_iso : Option<["/", "-"], "volatile:iso", KIND_FLAG>,
4708 Group<_SLASH_volatile_Group>, Flags<[CLOption, DriverOption]>,
4709 HelpText<"Volatile loads and stores have standard semantics">;
4710 def _SLASH_vmb : CLFlag<"vmb">,
4711 HelpText<"Use a best-case representation method for member pointers">;
4712 def _SLASH_vmg : CLFlag<"vmg">,
4713 HelpText<"Use a most-general representation for member pointers">;
4714 def _SLASH_vms : CLFlag<"vms">,
4715 HelpText<"Set the default most-general representation to single inheritance">;
4716 def _SLASH_vmm : CLFlag<"vmm">,
4717 HelpText<"Set the default most-general representation to "
4718 "multiple inheritance">;
4719 def _SLASH_vmv : CLFlag<"vmv">,
4720 HelpText<"Set the default most-general representation to "
4721 "virtual inheritance">;
4722 def _SLASH_volatile_ms : Option<["/", "-"], "volatile:ms", KIND_FLAG>,
4723 Group<_SLASH_volatile_Group>, Flags<[CLOption, DriverOption]>,
4724 HelpText<"Volatile loads and stores have acquire and release semantics">;
4725 def _SLASH_clang : CLJoined<"clang:">,
4726 HelpText<"Pass <arg> to the clang driver">, MetaVarName<"<arg>">;
4727 def _SLASH_Zl : CLFlag<"Zl">,
4728 HelpText<"Do not let object file auto-link default libraries">;
4730 def _SLASH_Yc : CLJoined<"Yc">,
4731 HelpText<"Generate a pch file for all code up to and including <filename>">,
4732 MetaVarName<"<filename>">;
4733 def _SLASH_Yu : CLJoined<"Yu">,
4734 HelpText<"Load a pch file and use it instead of all code up to "
4735 "and including <filename>">,
4736 MetaVarName<"<filename>">;
4737 def _SLASH_Y_ : CLFlag<"Y-">,
4738 HelpText<"Disable precompiled headers, overrides /Yc and /Yu">;
4739 def _SLASH_Zc_dllexportInlines : CLFlag<"Zc:dllexportInlines">,
4740 HelpText<"dllexport/dllimport inline member functions of dllexport/import classes (default)">;
4741 def _SLASH_Zc_dllexportInlines_ : CLFlag<"Zc:dllexportInlines-">,
4742 HelpText<"Do not dllexport/dllimport inline member functions of dllexport/import classes">;
4743 def _SLASH_Fp : CLJoined<"Fp">,
4744 HelpText<"Set pch file name (with /Yc and /Yu)">, MetaVarName<"<file>">;
4746 def _SLASH_Gd : CLFlag<"Gd">,
4747 HelpText<"Set __cdecl as a default calling convention">;
4748 def _SLASH_Gr : CLFlag<"Gr">,
4749 HelpText<"Set __fastcall as a default calling convention">;
4750 def _SLASH_Gz : CLFlag<"Gz">,
4751 HelpText<"Set __stdcall as a default calling convention">;
4752 def _SLASH_Gv : CLFlag<"Gv">,
4753 HelpText<"Set __vectorcall as a default calling convention">;
4754 def _SLASH_Gregcall : CLFlag<"Gregcall">,
4755 HelpText<"Set __regcall as a default calling convention">;
4759 def _SLASH_analyze_ : CLIgnoredFlag<"analyze-">;
4760 def _SLASH_bigobj : CLIgnoredFlag<"bigobj">;
4761 def _SLASH_cgthreads : CLIgnoredJoined<"cgthreads">;
4762 def _SLASH_d2FastFail : CLIgnoredFlag<"d2FastFail">;
4763 def _SLASH_d2Zi_PLUS : CLIgnoredFlag<"d2Zi+">;
4764 def _SLASH_errorReport : CLIgnoredJoined<"errorReport">;
4765 def _SLASH_FC : CLIgnoredFlag<"FC">;
4766 def _SLASH_Fd : CLIgnoredJoined<"Fd">;
4767 def _SLASH_FS : CLIgnoredFlag<"FS">;
4768 def _SLASH_JMC : CLIgnoredFlag<"JMC">;
4769 def _SLASH_kernel_ : CLIgnoredFlag<"kernel-">;
4770 def _SLASH_nologo : CLIgnoredFlag<"nologo">;
4771 def _SLASH_permissive_ : CLIgnoredFlag<"permissive-">;
4772 def _SLASH_RTC : CLIgnoredJoined<"RTC">;
4773 def _SLASH_sdl : CLIgnoredFlag<"sdl">;
4774 def _SLASH_sdl_ : CLIgnoredFlag<"sdl-">;
4775 def _SLASH_utf8 : CLIgnoredFlag<"utf-8">,
4776 HelpText<"Set source and runtime encoding to UTF-8 (default)">;
4777 def _SLASH_w : CLIgnoredJoined<"w">;
4778 def _SLASH_Zc___cplusplus : CLIgnoredFlag<"Zc:__cplusplus">;
4779 def _SLASH_Zc_auto : CLIgnoredFlag<"Zc:auto">;
4780 def _SLASH_Zc_forScope : CLIgnoredFlag<"Zc:forScope">;
4781 def _SLASH_Zc_inline : CLIgnoredFlag<"Zc:inline">;
4782 def _SLASH_Zc_rvalueCast : CLIgnoredFlag<"Zc:rvalueCast">;
4783 def _SLASH_Zc_ternary : CLIgnoredFlag<"Zc:ternary">;
4784 def _SLASH_Zc_wchar_t : CLIgnoredFlag<"Zc:wchar_t">;
4785 def _SLASH_ZH_MD5 : CLIgnoredFlag<"ZH:MD5">;
4786 def _SLASH_ZH_SHA1 : CLIgnoredFlag<"ZH:SHA1">;
4787 def _SLASH_ZH_SHA_256 : CLIgnoredFlag<"ZH:SHA_256">;
4788 def _SLASH_Zm : CLIgnoredJoined<"Zm">;
4789 def _SLASH_Zo : CLIgnoredFlag<"Zo">;
4790 def _SLASH_Zo_ : CLIgnoredFlag<"Zo-">;
4795 def _SLASH_await : CLFlag<"await">;
4796 def _SLASH_constexpr : CLJoined<"constexpr:">;
4797 def _SLASH_AI : CLJoinedOrSeparate<"AI">;
4798 def _SLASH_Bt : CLFlag<"Bt">;
4799 def _SLASH_Bt_plus : CLFlag<"Bt+">;
4800 def _SLASH_clr : CLJoined<"clr">;
4801 def _SLASH_d2 : CLJoined<"d2">;
4802 def _SLASH_doc : CLJoined<"doc">;
4803 def _SLASH_FA_joined : CLJoined<"FA">;
4804 def _SLASH_favor : CLJoined<"favor">;
4805 def _SLASH_F : CLJoinedOrSeparate<"F">;
4806 def _SLASH_Fm : CLJoined<"Fm">;
4807 def _SLASH_Fr : CLJoined<"Fr">;
4808 def _SLASH_FR : CLJoined<"FR">;
4809 def _SLASH_FU : CLJoinedOrSeparate<"FU">;
4810 def _SLASH_Fx : CLFlag<"Fx">;
4811 def _SLASH_G1 : CLFlag<"G1">;
4812 def _SLASH_G2 : CLFlag<"G2">;
4813 def _SLASH_Ge : CLFlag<"Ge">;
4814 def _SLASH_Gh : CLFlag<"Gh">;
4815 def _SLASH_GH : CLFlag<"GH">;
4816 def _SLASH_GL : CLFlag<"GL">;
4817 def _SLASH_GL_ : CLFlag<"GL-">;
4818 def _SLASH_Gm : CLFlag<"Gm">;
4819 def _SLASH_Gm_ : CLFlag<"Gm-">;
4820 def _SLASH_GT : CLFlag<"GT">;
4821 def _SLASH_GZ : CLFlag<"GZ">;
4822 def _SLASH_H : CLFlag<"H">;
4823 def _SLASH_homeparams : CLFlag<"homeparams">;
4824 def _SLASH_hotpatch : CLFlag<"hotpatch">;
4825 def _SLASH_kernel : CLFlag<"kernel">;
4826 def _SLASH_LN : CLFlag<"LN">;
4827 def _SLASH_MP : CLJoined<"MP">;
4828 def _SLASH_Qfast_transcendentals : CLFlag<"Qfast_transcendentals">;
4829 def _SLASH_QIfist : CLFlag<"QIfist">;
4830 def _SLASH_QIntel_jcc_erratum : CLFlag<"QIntel-jcc-erratum">;
4831 def _SLASH_Qimprecise_fwaits : CLFlag<"Qimprecise_fwaits">;
4832 def _SLASH_Qpar : CLFlag<"Qpar">;
4833 def _SLASH_Qpar_report : CLJoined<"Qpar-report">;
4834 def _SLASH_Qsafe_fp_loads : CLFlag<"Qsafe_fp_loads">;
4835 def _SLASH_Qspectre : CLFlag<"Qspectre">;
4836 def _SLASH_Qspectre_load : CLFlag<"Qspectre-load">;
4837 def _SLASH_Qspectre_load_cf : CLFlag<"Qspectre-load-cf">;
4838 def _SLASH_Qvec_report : CLJoined<"Qvec-report">;
4839 def _SLASH_u : CLFlag<"u">;
4840 def _SLASH_V : CLFlag<"V">;
4841 def _SLASH_WL : CLFlag<"WL">;
4842 def _SLASH_Wp64 : CLFlag<"Wp64">;
4843 def _SLASH_Yd : CLFlag<"Yd">;
4844 def _SLASH_Yl : CLJoined<"Yl">;
4845 def _SLASH_Za : CLFlag<"Za">;
4846 def _SLASH_Zc : CLJoined<"Zc:">;
4847 def _SLASH_Ze : CLFlag<"Ze">;
4848 def _SLASH_Zg : CLFlag<"Zg">;
4849 def _SLASH_ZI : CLFlag<"ZI">;
4850 def _SLASH_ZW : CLJoined<"ZW">;