1 //===--- Options.td - Options for clang -----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the options accepted by clang.
12 //===----------------------------------------------------------------------===//
14 // Include the common option parsing interfaces.
15 include "llvm/Option/OptParser.td"
20 // DriverOption - The option is a "driver" option, and should not be forwarded
22 def DriverOption : OptionFlag;
24 // LinkerInput - The option is a linker input.
25 def LinkerInput : OptionFlag;
27 // NoArgumentUnused - Don't report argument unused warnings for this option; this
28 // is useful for options like -static or -dynamic which a user may always end up
29 // passing, even if the platform defaults to (or only supports) that option.
30 def NoArgumentUnused : OptionFlag;
32 // Unsupported - The option is unsupported, and the driver will reject command
34 def Unsupported : OptionFlag;
36 // Ignored - The option is unsupported, and the driver will silently ignore it.
37 def Ignored : OptionFlag;
39 // CoreOption - This is considered a "core" Clang option, available in both
40 // clang and clang-cl modes.
41 def CoreOption : OptionFlag;
43 // CLOption - This is a cl.exe compatibility option. Options with this flag
44 // are made available when the driver is running in CL compatibility mode.
45 def CLOption : OptionFlag;
47 // CC1Option - This option should be accepted by clang -cc1.
48 def CC1Option : OptionFlag;
50 // CC1AsOption - This option should be accepted by clang -cc1as.
51 def CC1AsOption : OptionFlag;
53 // NoDriverOption - This option should not be accepted by the driver.
54 def NoDriverOption : OptionFlag;
56 // A short name to show in documentation. The name will be interpreted as rST.
57 class DocName<string name> { string DocName = name; }
59 // A brief description to show in documentation, interpreted as rST.
60 class DocBrief<code descr> { code DocBrief = descr; }
62 // Indicates that this group should be flattened into its parent when generating
64 class DocFlatten { bit DocFlatten = 1; }
66 // Indicates that this warning is ignored, but accepted with a warning for
68 class IgnoredGCCCompat : Flags<[HelpHidden]> {}
73 def Action_Group : OptionGroup<"<action group>">, DocName<"Actions">,
74 DocBrief<[{The action to perform on the input.}]>;
76 // Meta-group for options which are only used for compilation,
77 // and not linking etc.
78 def CompileOnly_Group : OptionGroup<"<CompileOnly group>">,
79 DocName<"Compilation flags">, DocBrief<[{
80 Flags controlling the behavior of Clang during compilation. These flags have
81 no effect during actions that do not perform compilation.}]>;
83 def Preprocessor_Group : OptionGroup<"<Preprocessor group>">,
84 Group<CompileOnly_Group>,
85 DocName<"Preprocessor flags">, DocBrief<[{
86 Flags controlling the behavior of the Clang preprocessor.}]>;
88 def IncludePath_Group : OptionGroup<"<I/i group>">, Group<Preprocessor_Group>,
89 DocName<"Include path management">,
91 Flags controlling how ``#include``\s are resolved to files.}]>;
93 def I_Group : OptionGroup<"<I group>">, Group<IncludePath_Group>, DocFlatten;
94 def i_Group : OptionGroup<"<i group>">, Group<IncludePath_Group>, DocFlatten;
95 def clang_i_Group : OptionGroup<"<clang i group>">, Group<i_Group>, DocFlatten;
97 def M_Group : OptionGroup<"<M group>">, Group<Preprocessor_Group>,
98 DocName<"Dependency file generation">, DocBrief<[{
99 Flags controlling generation of a dependency file for ``make``-like build
102 def d_Group : OptionGroup<"<d group>">, Group<Preprocessor_Group>,
103 DocName<"Dumping preprocessor state">, DocBrief<[{
104 Flags allowing the state of the preprocessor to be dumped in various ways.}]>;
106 def Diag_Group : OptionGroup<"<W/R group>">, Group<CompileOnly_Group>,
107 DocName<"Diagnostic flags">, DocBrief<[{
108 Flags controlling which warnings, errors, and remarks Clang will generate.
109 See the :doc:`full list of warning and remark flags <DiagnosticsReference>`.}]>;
111 def R_Group : OptionGroup<"<R group>">, Group<Diag_Group>, DocFlatten;
112 def R_value_Group : OptionGroup<"<R (with value) group>">, Group<R_Group>,
114 def W_Group : OptionGroup<"<W group>">, Group<Diag_Group>, DocFlatten;
115 def W_value_Group : OptionGroup<"<W (with value) group>">, Group<W_Group>,
118 def f_Group : OptionGroup<"<f group>">, Group<CompileOnly_Group>,
119 DocName<"Target-independent compilation options">;
121 def f_clang_Group : OptionGroup<"<f (clang-only) group>">,
122 Group<CompileOnly_Group>, DocFlatten;
123 def pedantic_Group : OptionGroup<"<pedantic group>">, Group<f_Group>,
125 def opencl_Group : OptionGroup<"<opencl group>">, Group<f_Group>,
126 DocName<"OpenCL flags">;
128 def m_Group : OptionGroup<"<m group>">, Group<CompileOnly_Group>,
129 DocName<"Target-dependent compilation options">;
131 // Feature groups - these take command line options that correspond directly to
132 // target specific features and can be translated directly from command line
134 def m_aarch64_Features_Group : OptionGroup<"<aarch64 features group>">,
135 Group<m_Group>, DocName<"AARCH64">;
136 def m_amdgpu_Features_Group : OptionGroup<"<amdgpu features group>">,
137 Group<m_Group>, DocName<"AMDGPU">;
138 def m_arm_Features_Group : OptionGroup<"<arm features group>">,
139 Group<m_Group>, DocName<"ARM">;
140 def m_hexagon_Features_Group : OptionGroup<"<hexagon features group>">,
141 Group<m_Group>, DocName<"Hexagon">;
142 // The features added by this group will not be added to target features.
143 // These are explicitly handled.
144 def m_hexagon_Features_HVX_Group : OptionGroup<"<hexagon features group>">,
145 Group<m_Group>, DocName<"Hexagon">;
146 def m_ppc_Features_Group : OptionGroup<"<ppc features group>">,
147 Group<m_Group>, DocName<"PowerPC">;
148 def m_wasm_Features_Group : OptionGroup<"<wasm features group>">,
149 Group<m_Group>, DocName<"WebAssembly">;
150 def m_x86_Features_Group : OptionGroup<"<x86 features group>">,
151 Group<m_Group>, Flags<[CoreOption]>, DocName<"X86">;
153 def m_libc_Group : OptionGroup<"<m libc group>">, Group<m_Group>,
156 def O_Group : OptionGroup<"<O group>">, Group<CompileOnly_Group>,
157 DocName<"Optimization level">, DocBrief<[{
158 Flags controlling how much optimization should be performed.}]>;
160 def DebugInfo_Group : OptionGroup<"<g group>">, Group<CompileOnly_Group>,
161 DocName<"Debug information generation">, DocBrief<[{
162 Flags controlling how much and what kind of debug information should be
165 def g_Group : OptionGroup<"<g group>">, Group<DebugInfo_Group>,
166 DocName<"Kind and level of debug information">;
167 def gN_Group : OptionGroup<"<gN group>">, Group<g_Group>,
168 DocName<"Debug level">;
169 def ggdbN_Group : OptionGroup<"<ggdbN group>">, Group<gN_Group>, DocFlatten;
170 def gTune_Group : OptionGroup<"<gTune group>">, Group<g_Group>,
171 DocName<"Debugger to tune debug information for">;
172 def g_flags_Group : OptionGroup<"<g flags group>">, Group<DebugInfo_Group>,
173 DocName<"Debug information flags">;
175 def StaticAnalyzer_Group : OptionGroup<"<Static analyzer group>">,
176 DocName<"Static analyzer flags">, DocBrief<[{
177 Flags controlling the behavior of the Clang Static Analyzer.}]>;
179 // gfortran options that we recognize in the driver and pass along when
180 // invoking GCC to compile Fortran code.
181 def gfortran_Group : OptionGroup<"<gfortran group>">,
182 DocName<"Fortran compilation flags">, DocBrief<[{
183 Flags that will be passed onto the ``gfortran`` compiler when Clang is given
186 def Link_Group : OptionGroup<"<T/e/s/t/u group>">, DocName<"Linker flags">,
187 DocBrief<[{Flags that are passed on to the linker}]>;
188 def T_Group : OptionGroup<"<T group>">, Group<Link_Group>, DocFlatten;
189 def u_Group : OptionGroup<"<u group>">, Group<Link_Group>, DocFlatten;
191 def reserved_lib_Group : OptionGroup<"<reserved libs group>">,
192 Flags<[Unsupported]>;
194 // Temporary groups for clang options which we know we don't support,
195 // but don't want to verbosely warn the user about.
196 def clang_ignored_f_Group : OptionGroup<"<clang ignored f group>">,
197 Group<f_Group>, Flags<[Ignored]>;
198 def clang_ignored_m_Group : OptionGroup<"<clang ignored m group>">,
199 Group<m_Group>, Flags<[Ignored]>;
201 // Group for clang options in the process of deprecation.
202 // Please include the version that deprecated the flag as comment to allow
203 // easier garbage collection.
204 def clang_ignored_legacy_options_Group : OptionGroup<"<clang legacy flags>">,
205 Group<f_Group>, Flags<[Ignored]>;
207 // Retired with clang-5.0
208 def : Flag<["-"], "fslp-vectorize-aggressive">, Group<clang_ignored_legacy_options_Group>;
209 def : Flag<["-"], "fno-slp-vectorize-aggressive">, Group<clang_ignored_legacy_options_Group>;
211 // Group that ignores all gcc optimizations that won't be implemented
212 def clang_ignored_gcc_optimization_f_Group : OptionGroup<
213 "<clang_ignored_gcc_optimization_f_Group>">, Group<f_Group>, Flags<[Ignored]>;
218 // The internal option ID must be a valid C++ identifier and results in a
219 // clang::driver::options::OPT_XX enum constant for XX.
221 // We want to unambiguously be able to refer to options from the driver source
222 // code, for this reason the option name is mangled into an ID. This mangling
223 // isn't guaranteed to have an inverse, but for practical purposes it does.
225 // The mangling scheme is to ignore the leading '-', and perform the following
237 // Developer Driver Options
239 def internal_Group : OptionGroup<"<clang internal options>">, Flags<[HelpHidden]>;
240 def internal_driver_Group : OptionGroup<"<clang driver internal options>">,
241 Group<internal_Group>, HelpText<"DRIVER OPTIONS">;
242 def internal_debug_Group :
243 OptionGroup<"<clang debug/development internal options>">,
244 Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">;
246 class InternalDriverOpt : Group<internal_driver_Group>,
247 Flags<[DriverOption, HelpHidden]>;
248 def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>,
249 Flags<[CoreOption, DriverOption, HelpHidden]>,
250 HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'">;
251 def rsp_quoting : Joined<["--"], "rsp-quoting=">, Group<internal_driver_Group>,
252 Flags<[CoreOption, DriverOption, HelpHidden]>,
253 HelpText<"Set the rsp quoting to either 'posix', or 'windows'">;
254 def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt,
255 HelpText<"Name for native GCC compiler">,
256 MetaVarName<"<gcc-path>">;
257 def ccc_pch_is_pch : Flag<["-"], "ccc-pch-is-pch">, InternalDriverOpt,
258 HelpText<"Use lazy PCH for precompiled headers">;
259 def ccc_pch_is_pth : Flag<["-"], "ccc-pch-is-pth">, InternalDriverOpt,
260 HelpText<"Use pretokenized headers for precompiled headers">;
262 class InternalDebugOpt : Group<internal_debug_Group>,
263 Flags<[DriverOption, HelpHidden, CoreOption]>;
264 def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt,
265 HelpText<"Simulate installation in the given directory">;
266 def ccc_print_phases : Flag<["-"], "ccc-print-phases">, InternalDebugOpt,
267 HelpText<"Dump list of actions to perform">;
268 def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, InternalDebugOpt,
269 HelpText<"Show bindings of tools to actions">;
271 def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, InternalDriverOpt,
272 HelpText<"Check for ARC migration issues that need manual handling">;
273 def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, InternalDriverOpt,
274 HelpText<"Apply modifications to files to conform to ARC">;
275 def ccc_arcmt_migrate : Separate<["-"], "ccc-arcmt-migrate">, InternalDriverOpt,
276 HelpText<"Apply modifications and produces temporary files that conform to ARC">;
277 def arcmt_migrate_report_output : Separate<["-"], "arcmt-migrate-report-output">,
278 HelpText<"Output path for the plist report">, Flags<[CC1Option]>;
279 def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">,
280 HelpText<"Emit ARC errors even if the migrator can fix them">,
282 def gen_reproducer: Flag<["-"], "gen-reproducer">, InternalDebugOpt,
283 HelpText<"Auto-generates preprocessed source files and a reproduction script">;
285 def _migrate : Flag<["--"], "migrate">, Flags<[DriverOption]>,
286 HelpText<"Run the migrator">;
287 def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">,
289 HelpText<"Apply modifications and produces temporary files to migrate to "
290 "modern ObjC syntax">;
291 def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>,
292 HelpText<"Enable migration to modern ObjC literals">;
293 def objcmt_migrate_subscripting : Flag<["-"], "objcmt-migrate-subscripting">, Flags<[CC1Option]>,
294 HelpText<"Enable migration to modern ObjC subscripting">;
295 def objcmt_migrate_property : Flag<["-"], "objcmt-migrate-property">, Flags<[CC1Option]>,
296 HelpText<"Enable migration to modern ObjC property">;
297 def objcmt_migrate_all : Flag<["-"], "objcmt-migrate-all">, Flags<[CC1Option]>,
298 HelpText<"Enable migration to modern ObjC">;
299 def objcmt_migrate_readonly_property : Flag<["-"], "objcmt-migrate-readonly-property">, Flags<[CC1Option]>,
300 HelpText<"Enable migration to modern ObjC readonly property">;
301 def objcmt_migrate_readwrite_property : Flag<["-"], "objcmt-migrate-readwrite-property">, Flags<[CC1Option]>,
302 HelpText<"Enable migration to modern ObjC readwrite property">;
303 def objcmt_migrate_property_dot_syntax : Flag<["-"], "objcmt-migrate-property-dot-syntax">, Flags<[CC1Option]>,
304 HelpText<"Enable migration of setter/getter messages to property-dot syntax">;
305 def objcmt_migrate_annotation : Flag<["-"], "objcmt-migrate-annotation">, Flags<[CC1Option]>,
306 HelpText<"Enable migration to property and method annotations">;
307 def objcmt_migrate_instancetype : Flag<["-"], "objcmt-migrate-instancetype">, Flags<[CC1Option]>,
308 HelpText<"Enable migration to infer instancetype for method result type">;
309 def objcmt_migrate_nsmacros : Flag<["-"], "objcmt-migrate-ns-macros">, Flags<[CC1Option]>,
310 HelpText<"Enable migration to NS_ENUM/NS_OPTIONS macros">;
311 def objcmt_migrate_protocol_conformance : Flag<["-"], "objcmt-migrate-protocol-conformance">, Flags<[CC1Option]>,
312 HelpText<"Enable migration to add protocol conformance on classes">;
313 def objcmt_atomic_property : Flag<["-"], "objcmt-atomic-property">, Flags<[CC1Option]>,
314 HelpText<"Make migration to 'atomic' properties">;
315 def objcmt_returns_innerpointer_property : Flag<["-"], "objcmt-returns-innerpointer-property">, Flags<[CC1Option]>,
316 HelpText<"Enable migration to annotate property with NS_RETURNS_INNER_POINTER">;
317 def objcmt_ns_nonatomic_iosonly: Flag<["-"], "objcmt-ns-nonatomic-iosonly">, Flags<[CC1Option]>,
318 HelpText<"Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute">;
319 def objcmt_migrate_designated_init : Flag<["-"], "objcmt-migrate-designated-init">, Flags<[CC1Option]>,
320 HelpText<"Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods">;
321 def objcmt_whitelist_dir_path: Joined<["-"], "objcmt-whitelist-dir-path=">, Flags<[CC1Option]>,
322 HelpText<"Only modify files with a filename contained in the provided directory path">;
323 // The misspelt "white-list" [sic] alias is due for removal.
324 def : Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>,
325 Alias<objcmt_whitelist_dir_path>;
327 // Make sure all other -ccc- options are rejected.
328 def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>;
332 def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,
333 HelpText<"Print (but do not run) the commands to run for this compilation">;
334 def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>,
335 Flags<[DriverOption, CoreOption]>;
336 def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>, Group<gfortran_Group>;
337 def B : JoinedOrSeparate<["-"], "B">, MetaVarName<"<dir>">,
338 HelpText<"Add <dir> to search path for binaries and object files used implicitly">;
339 def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
340 HelpText<"Include comments from within macros in preprocessed output">;
341 def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
342 HelpText<"Include comments in preprocessed output">;
343 def D : JoinedOrSeparate<["-"], "D">, Group<Preprocessor_Group>,
344 Flags<[CC1Option]>, MetaVarName<"<macro>=<value>">,
345 HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">;
346 def E : Flag<["-"], "E">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
347 HelpText<"Only run the preprocessor">;
348 def F : JoinedOrSeparate<["-"], "F">, Flags<[RenderJoined,CC1Option]>,
349 HelpText<"Add directory to framework include search path">;
350 def G : JoinedOrSeparate<["-"], "G">, Flags<[DriverOption]>, Group<m_Group>,
351 MetaVarName<"<size>">, HelpText<"Put objects of at most <size> bytes "
352 "into small data section (MIPS / Hexagon)">;
353 def G_EQ : Joined<["-"], "G=">, Flags<[DriverOption]>, Group<m_Group>, Alias<G>;
354 def H : Flag<["-"], "H">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
355 HelpText<"Show header includes and nesting depth">;
356 def I_ : Flag<["-"], "I-">, Group<I_Group>,
357 HelpText<"Restrict all prior -I flags to double-quoted inclusion and "
358 "remove current directory from include path">;
359 def I : JoinedOrSeparate<["-"], "I">, Group<I_Group>,
360 Flags<[CC1Option,CC1AsOption]>, MetaVarName<"<dir>">,
361 HelpText<"Add directory to include search path">;
362 def L : JoinedOrSeparate<["-"], "L">, Flags<[RenderJoined]>, Group<Link_Group>,
363 MetaVarName<"<dir>">, HelpText<"Add directory to library search path">;
364 def MD : Flag<["-"], "MD">, Group<M_Group>,
365 HelpText<"Write a depfile containing user and system headers">;
366 def MMD : Flag<["-"], "MMD">, Group<M_Group>,
367 HelpText<"Write a depfile containing user headers">;
368 def M : Flag<["-"], "M">, Group<M_Group>,
369 HelpText<"Like -MD, but also implies -E and writes to stdout by default">;
370 def MM : Flag<["-"], "MM">, Group<M_Group>,
371 HelpText<"Like -MMD, but also implies -E and writes to stdout by default">;
372 def MF : JoinedOrSeparate<["-"], "MF">, Group<M_Group>,
373 HelpText<"Write depfile output from -MMD, -MD, -MM, or -M to <file>">,
374 MetaVarName<"<file>">;
375 def MG : Flag<["-"], "MG">, Group<M_Group>, Flags<[CC1Option]>,
376 HelpText<"Add missing headers to depfile">;
377 def MJ : JoinedOrSeparate<["-"], "MJ">, Group<M_Group>,
378 HelpText<"Write a compilation database entry per input">;
379 def MP : Flag<["-"], "MP">, Group<M_Group>, Flags<[CC1Option]>,
380 HelpText<"Create phony target for each dependency (other than main file)">;
381 def MQ : JoinedOrSeparate<["-"], "MQ">, Group<M_Group>, Flags<[CC1Option]>,
382 HelpText<"Specify name of main file output to quote in depfile">;
383 def MT : JoinedOrSeparate<["-"], "MT">, Group<M_Group>, Flags<[CC1Option]>,
384 HelpText<"Specify name of main file output in depfile">;
385 def MV : Flag<["-"], "MV">, Group<M_Group>, Flags<[CC1Option]>,
386 HelpText<"Use NMake/Jom format for the depfile">;
387 def Mach : Flag<["-"], "Mach">, Group<Link_Group>;
388 def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>;
389 def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>;
390 def ObjCXX : Flag<["-"], "ObjC++">, Flags<[DriverOption]>,
391 HelpText<"Treat source input files as Objective-C++ inputs">;
392 def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
393 HelpText<"Treat source input files as Objective-C inputs">;
394 def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>;
395 def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["2"]>;
396 def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
397 def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
398 HelpText<"Disable linemarker output in -E mode">;
399 def Qn : Flag<["-"], "Qn">, IgnoredGCCCompat;
400 def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>,
401 HelpText<"Don't emit warning for unused driver arguments">;
402 def Q : Flag<["-"], "Q">, IgnoredGCCCompat;
403 def Rpass_EQ : Joined<["-"], "Rpass=">, Group<R_value_Group>, Flags<[CC1Option]>,
404 HelpText<"Report transformations performed by optimization passes whose "
405 "name matches the given POSIX regular expression">;
406 def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">, Group<R_value_Group>,
408 HelpText<"Report missed transformations by optimization passes whose "
409 "name matches the given POSIX regular expression">;
410 def Rpass_analysis_EQ : Joined<["-"], "Rpass-analysis=">, Group<R_value_Group>,
412 HelpText<"Report transformation analysis from optimization passes whose "
413 "name matches the given POSIX regular expression">;
414 def R_Joined : Joined<["-"], "R">, Group<R_Group>, Flags<[CC1Option, CoreOption]>,
415 MetaVarName<"<remark>">, HelpText<"Enable the specified remark">;
416 def S : Flag<["-"], "S">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
417 HelpText<"Only run preprocess and compilation steps">;
418 def Tbss : JoinedOrSeparate<["-"], "Tbss">, Group<T_Group>,
419 MetaVarName<"<addr>">, HelpText<"Set starting address of BSS to <addr>">;
420 def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>,
421 MetaVarName<"<addr>">, HelpText<"Set starting address of BSS to <addr>">;
422 def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>,
423 MetaVarName<"<addr>">, HelpText<"Set starting address of BSS to <addr>">;
424 def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>,
425 MetaVarName<"<script>">, HelpText<"Specify <script> as linker script">;
426 def U : JoinedOrSeparate<["-"], "U">, Group<Preprocessor_Group>,
427 Flags<[CC1Option]>, MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">;
428 def V : JoinedOrSeparate<["-"], "V">, Flags<[DriverOption, Unsupported]>;
429 def Wa_COMMA : CommaJoined<["-"], "Wa,">,
430 HelpText<"Pass the comma separated arguments in <arg> to the assembler">,
431 MetaVarName<"<arg>">;
432 def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
433 def WCL4 : Flag<["-"], "WCL4">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
434 def Wdeprecated : Flag<["-"], "Wdeprecated">, Group<W_Group>, Flags<[CC1Option]>,
435 HelpText<"Enable warnings for deprecated constructs and define __DEPRECATED">;
436 def Wno_deprecated : Flag<["-"], "Wno-deprecated">, Group<W_Group>, Flags<[CC1Option]>;
437 def Wl_COMMA : CommaJoined<["-"], "Wl,">, Flags<[LinkerInput, RenderAsInput]>,
438 HelpText<"Pass the comma separated arguments in <arg> to the linker">,
439 MetaVarName<"<arg>">, Group<Link_Group>;
440 // FIXME: This is broken; these should not be Joined arguments.
441 def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Group<W_Group>,
443 def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>,
445 def Wp_COMMA : CommaJoined<["-"], "Wp,">,
446 HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,
447 MetaVarName<"<arg>">, Group<Preprocessor_Group>;
448 def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
449 def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
450 def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>,
451 MetaVarName<"<warning>">, HelpText<"Enable the specified warning">;
452 def Xanalyzer : Separate<["-"], "Xanalyzer">,
453 HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">,
454 Group<StaticAnalyzer_Group>;
455 def Xarch__ : JoinedAndSeparate<["-"], "Xarch_">, Flags<[DriverOption]>;
456 def Xassembler : Separate<["-"], "Xassembler">,
457 HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">,
458 Group<CompileOnly_Group>;
459 def Xclang : Separate<["-"], "Xclang">,
460 HelpText<"Pass <arg> to the clang compiler">, MetaVarName<"<arg>">,
461 Flags<[DriverOption, CoreOption]>, Group<CompileOnly_Group>;
462 def Xcuda_fatbinary : Separate<["-"], "Xcuda-fatbinary">,
463 HelpText<"Pass <arg> to fatbinary invocation">, MetaVarName<"<arg>">;
464 def Xcuda_ptxas : Separate<["-"], "Xcuda-ptxas">,
465 HelpText<"Pass <arg> to the ptxas assembler">, MetaVarName<"<arg>">;
466 def Xopenmp_target : Separate<["-"], "Xopenmp-target">,
467 HelpText<"Pass <arg> to the target offloading toolchain.">, MetaVarName<"<arg>">;
468 def Xopenmp_target_EQ : JoinedAndSeparate<["-"], "Xopenmp-target=">,
469 HelpText<"Pass <arg> to the specified target offloading toolchain. The triple that identifies the toolchain must be provided after the equals sign.">, MetaVarName<"<arg>">;
470 def z : Separate<["-"], "z">, Flags<[LinkerInput, RenderAsInput]>,
471 HelpText<"Pass -z <arg> to the linker">, MetaVarName<"<arg>">,
473 def Xlinker : Separate<["-"], "Xlinker">, Flags<[LinkerInput, RenderAsInput]>,
474 HelpText<"Pass <arg> to the linker">, MetaVarName<"<arg>">,
476 def Xpreprocessor : Separate<["-"], "Xpreprocessor">, Group<Preprocessor_Group>,
477 HelpText<"Pass <arg> to the preprocessor">, MetaVarName<"<arg>">;
478 def X_Flag : Flag<["-"], "X">, Group<Link_Group>;
479 def X_Joined : Joined<["-"], "X">, IgnoredGCCCompat;
480 def Z_Flag : Flag<["-"], "Z">, Group<Link_Group>;
481 // FIXME: All we do with this is reject it. Remove.
482 def Z_Joined : Joined<["-"], "Z">;
483 def all__load : Flag<["-"], "all_load">;
484 def allowable__client : Separate<["-"], "allowable_client">;
485 def ansi : Flag<["-", "--"], "ansi">;
486 def arch__errors__fatal : Flag<["-"], "arch_errors_fatal">;
487 def arch : Separate<["-"], "arch">, Flags<[DriverOption]>;
488 def arch__only : Separate<["-"], "arch_only">;
489 def a : Joined<["-"], "a">;
490 def autocomplete : Joined<["--"], "autocomplete=">;
491 def bind__at__load : Flag<["-"], "bind_at_load">;
492 def bundle__loader : Separate<["-"], "bundle_loader">;
493 def bundle : Flag<["-"], "bundle">;
494 def b : JoinedOrSeparate<["-"], "b">, Flags<[Unsupported]>;
495 def cl_opt_disable : Flag<["-"], "cl-opt-disable">, Group<opencl_Group>, Flags<[CC1Option]>,
496 HelpText<"OpenCL only. This option disables all optimizations. By default optimizations are enabled.">;
497 def cl_strict_aliasing : Flag<["-"], "cl-strict-aliasing">, Group<opencl_Group>, Flags<[CC1Option]>,
498 HelpText<"OpenCL only. This option is added for compatibility with OpenCL 1.0.">;
499 def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group<opencl_Group>, Flags<[CC1Option]>,
500 HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">;
501 def cl_finite_math_only : Flag<["-"], "cl-finite-math-only">, Group<opencl_Group>, Flags<[CC1Option]>,
502 HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">;
503 def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_Group>, Flags<[CC1Option]>,
504 HelpText<"OpenCL only. Generate kernel argument metadata.">;
505 def cl_unsafe_math_optimizations : Flag<["-"], "cl-unsafe-math-optimizations">, Group<opencl_Group>, Flags<[CC1Option]>,
506 HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.">;
507 def cl_fast_relaxed_math : Flag<["-"], "cl-fast-relaxed-math">, Group<opencl_Group>, Flags<[CC1Option]>,
508 HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.">;
509 def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC1Option]>,
510 HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">;
511 def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>,
512 HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">;
513 def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>,
514 HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0">;
515 def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>, Flags<[CC1Option]>,
516 HelpText<"OpenCL only. Allow denormals to be flushed to zero.">;
517 def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
518 HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">;
519 def client__name : JoinedOrSeparate<["-"], "client_name">;
520 def combine : Flag<["-", "--"], "combine">, Flags<[DriverOption, Unsupported]>;
521 def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
522 def coverage : Flag<["-", "--"], "coverage">, Flags<[CoreOption]>;
523 def cpp_precomp : Flag<["-"], "cpp-precomp">, Group<clang_ignored_f_Group>;
524 def current__version : JoinedOrSeparate<["-"], "current_version">;
525 def cxx_isystem : JoinedOrSeparate<["-"], "cxx-isystem">, Group<clang_i_Group>,
526 HelpText<"Add directory to the C++ SYSTEM include search path">, Flags<[CC1Option]>,
527 MetaVarName<"<directory>">;
528 def c : Flag<["-"], "c">, Flags<[DriverOption]>, Group<Action_Group>,
529 HelpText<"Only run preprocess, compile, and assemble steps">;
530 def cuda_device_only : Flag<["--"], "cuda-device-only">,
531 HelpText<"Compile CUDA code for device only">;
532 def cuda_host_only : Flag<["--"], "cuda-host-only">,
533 HelpText<"Compile CUDA code for host only. Has no effect on non-CUDA "
535 def cuda_compile_host_device : Flag<["--"], "cuda-compile-host-device">,
536 HelpText<"Compile CUDA code for both host and device (default). Has no "
537 "effect on non-CUDA compilations.">;
538 def cuda_gpu_arch_EQ : Joined<["--"], "cuda-gpu-arch=">, Flags<[DriverOption]>,
539 HelpText<"CUDA GPU architecture (e.g. sm_35). May be specified more than once.">;
540 def no_cuda_gpu_arch_EQ : Joined<["--"], "no-cuda-gpu-arch=">, Flags<[DriverOption]>,
541 HelpText<"Remove GPU architecture (e.g. sm_35) from the list of GPUs to compile for. "
542 "'all' resets the list to its default value.">;
543 def cuda_noopt_device_debug : Flag<["--"], "cuda-noopt-device-debug">,
544 HelpText<"Enable device-side debug info generation. Disables ptxas optimizations.">;
545 def no_cuda_version_check : Flag<["--"], "no-cuda-version-check">,
546 HelpText<"Don't error out if the detected version of the CUDA install is "
547 "too low for the requested CUDA gpu architecture.">;
548 def no_cuda_noopt_device_debug : Flag<["--"], "no-cuda-noopt-device-debug">;
549 def cuda_path_EQ : Joined<["--"], "cuda-path=">, Group<i_Group>,
550 HelpText<"CUDA installation path">;
551 def ptxas_path_EQ : Joined<["--"], "ptxas-path=">, Group<i_Group>,
552 HelpText<"Path to ptxas (used for compiling CUDA code)">;
553 def fcuda_flush_denormals_to_zero : Flag<["-"], "fcuda-flush-denormals-to-zero">,
554 Flags<[CC1Option]>, HelpText<"Flush denormal floating point values to zero in CUDA device mode.">;
555 def fno_cuda_flush_denormals_to_zero : Flag<["-"], "fno-cuda-flush-denormals-to-zero">;
556 def fcuda_approx_transcendentals : Flag<["-"], "fcuda-approx-transcendentals">,
557 Flags<[CC1Option]>, HelpText<"Use approximate transcendental functions">;
558 def fno_cuda_approx_transcendentals : Flag<["-"], "fno-cuda-approx-transcendentals">;
559 def dA : Flag<["-"], "dA">, Group<d_Group>;
560 def dD : Flag<["-"], "dD">, Group<d_Group>, Flags<[CC1Option]>,
561 HelpText<"Print macro definitions in -E mode in addition to normal output">;
562 def dI : Flag<["-"], "dI">, Group<d_Group>, Flags<[CC1Option]>,
563 HelpText<"Print include directives in -E mode in addition to normal output">;
564 def dM : Flag<["-"], "dM">, Group<d_Group>, Flags<[CC1Option]>,
565 HelpText<"Print macro definitions in -E mode instead of normal output">;
566 def dead__strip : Flag<["-"], "dead_strip">;
567 def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>,
568 HelpText<"Filename (or -) to write dependency output to">;
569 def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
570 HelpText<"Filename to write DOT-formatted header dependencies to">;
571 def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
572 Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
573 def dumpmachine : Flag<["-"], "dumpmachine">;
574 def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
575 def dumpversion : Flag<["-"], "dumpversion">;
576 def dylib__file : Separate<["-"], "dylib_file">;
577 def dylinker__install__name : JoinedOrSeparate<["-"], "dylinker_install_name">;
578 def dylinker : Flag<["-"], "dylinker">;
579 def dynamiclib : Flag<["-"], "dynamiclib">;
580 def dynamic : Flag<["-"], "dynamic">, Flags<[NoArgumentUnused]>;
581 def d_Flag : Flag<["-"], "d">, Group<d_Group>;
582 def d_Joined : Joined<["-"], "d">, Group<d_Group>;
583 def emit_ast : Flag<["-"], "emit-ast">,
584 HelpText<"Emit Clang AST files for source inputs">;
585 def emit_llvm : Flag<["-"], "emit-llvm">, Flags<[CC1Option]>, Group<Action_Group>,
586 HelpText<"Use the LLVM representation for assembler and object files">;
587 def exported__symbols__list : Separate<["-"], "exported_symbols_list">;
588 def e : JoinedOrSeparate<["-"], "e">, Group<Link_Group>;
589 def fPIC : Flag<["-"], "fPIC">, Group<f_Group>;
590 def fno_PIC : Flag<["-"], "fno-PIC">, Group<f_Group>;
591 def fPIE : Flag<["-"], "fPIE">, Group<f_Group>;
592 def fno_PIE : Flag<["-"], "fno-PIE">, Group<f_Group>;
593 def faccess_control : Flag<["-"], "faccess-control">, Group<f_Group>;
594 def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>;
595 def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>,
596 HelpText<"Use Apple's kernel extensions ABI">;
597 def fapple_pragma_pack : Flag<["-"], "fapple-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>,
598 HelpText<"Enable Apple gcc-compatible #pragma pack handling">;
599 def shared_libsan : Flag<["-"], "shared-libsan">;
600 def static_libsan : Flag<["-"], "static-libsan">;
601 def : Flag<["-"], "shared-libasan">, Alias<shared_libsan>;
602 def fasm : Flag<["-"], "fasm">, Group<f_Group>;
604 def fasm_blocks : Flag<["-"], "fasm-blocks">, Group<f_Group>, Flags<[CC1Option]>;
605 def fno_asm_blocks : Flag<["-"], "fno-asm-blocks">, Group<f_Group>;
607 def fassume_sane_operator_new : Flag<["-"], "fassume-sane-operator-new">, Group<f_Group>;
608 def fastcp : Flag<["-"], "fastcp">, Group<f_Group>;
609 def fastf : Flag<["-"], "fastf">, Group<f_Group>;
610 def fast : Flag<["-"], "fast">, Group<f_Group>;
611 def fasynchronous_unwind_tables : Flag<["-"], "fasynchronous-unwind-tables">, Group<f_Group>;
613 def fdouble_square_bracket_attributes : Flag<[ "-" ], "fdouble-square-bracket-attributes">,
614 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
615 HelpText<"Enable '[[]]' attributes in all C and C++ language modes">;
616 def fno_double_square_bracket_attributes : Flag<[ "-" ], "fno-double-square-bracket-attributes">,
617 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
618 HelpText<"Disable '[[]]' attributes in all C and C++ language modes">;
620 def fautolink : Flag <["-"], "fautolink">, Group<f_Group>;
621 def fno_autolink : Flag <["-"], "fno-autolink">, Group<f_Group>,
622 Flags<[DriverOption, CC1Option]>,
623 HelpText<"Disable generation of linker directives for automatic library linking">;
626 def fcoroutines_ts : Flag <["-"], "fcoroutines-ts">, Group<f_Group>,
627 Flags<[DriverOption, CC1Option]>,
628 HelpText<"Enable support for the C++ Coroutines TS">;
629 def fno_coroutines_ts : Flag <["-"], "fno-coroutines-ts">, Group<f_Group>,
630 Flags<[DriverOption]>;
632 def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
633 Group<f_Group>, Flags<[DriverOption, CC1Option]>, MetaVarName<"<option>">,
634 HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">;
635 def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>,
636 Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>,
637 HelpText<"Embed LLVM IR bitcode as data">;
638 def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">,
639 Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>,
640 HelpText<"Embed placeholder LLVM IR data as a marker">;
641 def fgnu_inline_asm : Flag<["-"], "fgnu-inline-asm">, Group<f_Group>, Flags<[DriverOption]>;
642 def fno_gnu_inline_asm : Flag<["-"], "fno-gnu-inline-asm">, Group<f_Group>,
643 Flags<[DriverOption, CC1Option]>,
644 HelpText<"Disable GNU style inline asm">;
646 def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>,
648 def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Group>,
650 def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">,
651 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
652 HelpText<"Enable sample-based profile guided optimizations">;
653 def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">,
654 Group<f_Group>, Flags<[DriverOption, CC1Option]>,
655 HelpText<"Specifies that the sample profile is accurate">,
656 DocBrief<[{Specifies that the sample profile is accurate. If the sample
657 profile is accurate, callsites without profile samples are marked
658 as cold. Otherwise, treat callsites without profile samples as if
659 we have no profile}]>;
660 def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">,
661 Group<f_Group>, Flags<[DriverOption]>;
662 def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>,
663 Alias<fprofile_sample_use>;
664 def fno_auto_profile : Flag<["-"], "fno-auto-profile">, Group<f_Group>,
665 Alias<fno_profile_sample_use>;
666 def fauto_profile_EQ : Joined<["-"], "fauto-profile=">,
667 Alias<fprofile_sample_use_EQ>;
668 def fauto_profile_accurate : Flag<["-"], "fauto-profile-accurate">,
669 Group<f_Group>, Alias<fprofile_sample_accurate>;
670 def fno_auto_profile_accurate : Flag<["-"], "fno-auto-profile-accurate">,
671 Group<f_Group>, Alias<fno_profile_sample_accurate>;
672 def fdebug_info_for_profiling : Flag<["-"], "fdebug-info-for-profiling">, Group<f_Group>,
674 HelpText<"Emit extra debug info to make sample profile more accurate.">;
675 def fno_debug_info_for_profiling : Flag<["-"], "fno-debug-info-for-profiling">, Group<f_Group>,
676 Flags<[DriverOption]>,
677 HelpText<"Do not emit extra debug info for sample profiler.">;
678 def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">,
679 Group<f_Group>, Flags<[CoreOption]>,
680 HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
681 def fprofile_instr_generate_EQ : Joined<["-"], "fprofile-instr-generate=">,
682 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<file>">,
683 HelpText<"Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)">;
684 def fprofile_instr_use : Flag<["-"], "fprofile-instr-use">, Group<f_Group>,
686 def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">,
687 Group<f_Group>, Flags<[CoreOption]>,
688 HelpText<"Use instrumentation data for profile-guided optimization">;
689 def fcoverage_mapping : Flag<["-"], "fcoverage-mapping">,
690 Group<f_Group>, Flags<[CC1Option]>,
691 HelpText<"Generate coverage mapping to enable code coverage analysis">;
692 def fno_coverage_mapping : Flag<["-"], "fno-coverage-mapping">,
693 Group<f_Group>, Flags<[DriverOption]>,
694 HelpText<"Disable code coverage analysis">;
695 def fprofile_generate : Flag<["-"], "fprofile-generate">,
696 Group<f_Group>, Flags<[DriverOption]>,
697 HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
698 def fprofile_generate_EQ : Joined<["-"], "fprofile-generate=">,
699 Group<f_Group>, Flags<[DriverOption]>, MetaVarName<"<directory>">,
700 HelpText<"Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
701 def fprofile_use : Flag<["-"], "fprofile-use">, Group<f_Group>,
702 Alias<fprofile_instr_use>;
703 def fprofile_use_EQ : Joined<["-"], "fprofile-use=">,
704 Group<f_Group>, Flags<[DriverOption]>, MetaVarName<"<pathname>">,
705 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>.">;
706 def fno_profile_instr_generate : Flag<["-"], "fno-profile-instr-generate">,
707 Group<f_Group>, Flags<[DriverOption]>,
708 HelpText<"Disable generation of profile instrumentation.">;
709 def fno_profile_generate : Flag<["-"], "fno-profile-generate">,
710 Group<f_Group>, Flags<[DriverOption]>,
711 HelpText<"Disable generation of profile instrumentation.">;
712 def fno_profile_instr_use : Flag<["-"], "fno-profile-instr-use">,
713 Group<f_Group>, Flags<[DriverOption]>,
714 HelpText<"Disable using instrumentation data for profile-guided optimization">;
715 def fno_profile_use : Flag<["-"], "fno-profile-use">,
716 Alias<fno_profile_instr_use>;
718 def fblocks : Flag<["-"], "fblocks">, Group<f_Group>, Flags<[CC1Option]>,
719 HelpText<"Enable the 'blocks' language feature">;
720 def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>;
721 def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>,
722 HelpText<"Accept non-standard constructs supported by the Borland compiler">;
723 def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>;
724 def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>,
725 Flags<[DriverOption]>, HelpText<"Load the clang builtins module map file.">;
726 def fcaret_diagnostics : Flag<["-"], "fcaret-diagnostics">, Group<f_Group>;
727 def fclang_abi_compat_EQ : Joined<["-"], "fclang-abi-compat=">, Group<f_clang_Group>,
728 Flags<[CC1Option]>, MetaVarName<"<version>">, Values<"<major>.<minor>,latest">,
729 HelpText<"Attempt to match the ABI of Clang <version>">;
730 def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>;
731 def fcolor_diagnostics : Flag<["-"], "fcolor-diagnostics">, Group<f_Group>,
732 Flags<[CoreOption, CC1Option]>, HelpText<"Use colors in diagnostics">;
733 def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>,
734 Flags<[CoreOption, DriverOption]>;
735 def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
736 def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>,
737 Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">;
738 def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
739 HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,
740 MetaVarName<"<arg>">;
741 def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group<f_clang_Group>, Flags<[CC1Option]>;
742 def fcommon : Flag<["-"], "fcommon">, Group<f_Group>;
743 def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>;
744 def fconstant_cfstrings : Flag<["-"], "fconstant-cfstrings">, Group<f_Group>;
745 def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>;
746 def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>;
747 def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>;
748 def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">,
750 def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused]>,
751 HelpText<"Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash">;
752 def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>;
753 def fcxx_exceptions: Flag<["-"], "fcxx-exceptions">, Group<f_Group>,
754 HelpText<"Enable C++ exceptions">, Flags<[CC1Option]>;
755 def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>,
756 Flags<[DriverOption]>;
757 def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>;
758 def fdebug_pass_structure : Flag<["-"], "fdebug-pass-structure">, Group<f_Group>;
759 def fdepfile_entry : Joined<["-"], "fdepfile-entry=">,
760 Group<f_clang_Group>, Flags<[CC1Option]>;
761 def fdiagnostics_fixit_info : Flag<["-"], "fdiagnostics-fixit-info">, Group<f_clang_Group>;
762 def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group<f_clang_Group>,
763 Flags<[CoreOption, CC1Option]>, HelpText<"Print fix-its in machine parseable form">;
764 def fdiagnostics_print_source_range_info : Flag<["-"], "fdiagnostics-print-source-range-info">,
765 Group<f_clang_Group>, Flags<[CC1Option]>,
766 HelpText<"Print source range spans in numeric form">;
767 def fdiagnostics_show_hotness : Flag<["-"], "fdiagnostics-show-hotness">, Group<f_Group>,
768 Flags<[CC1Option]>, HelpText<"Enable profile hotness information in diagnostic line">;
769 def fdiagnostics_hotness_threshold_EQ : Joined<["-"], "fdiagnostics-hotness-threshold=">,
770 Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<number>">,
771 HelpText<"Prevent optimization remarks from being output if they do not have at least this profile count">;
772 def fdiagnostics_show_option : Flag<["-"], "fdiagnostics-show-option">, Group<f_Group>,
773 Flags<[CC1Option]>, HelpText<"Print option name with mappable diagnostics">;
774 def fdiagnostics_show_note_include_stack : Flag<["-"], "fdiagnostics-show-note-include-stack">,
775 Group<f_Group>, Flags<[CC1Option]>, HelpText<"Display include stacks for diagnostic notes">;
776 def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>;
777 def fdiagnostics_show_category_EQ : Joined<["-"], "fdiagnostics-show-category=">, Group<f_clang_Group>;
778 def fdiagnostics_show_template_tree : Flag<["-"], "fdiagnostics-show-template-tree">,
779 Group<f_Group>, Flags<[CC1Option]>,
780 HelpText<"Print a template comparison tree for differing templates">;
781 def fdeclspec : Flag<["-"], "fdeclspec">, Group<f_clang_Group>,
782 HelpText<"Allow __declspec as a keyword">, Flags<[CC1Option]>;
783 def fdollars_in_identifiers : Flag<["-"], "fdollars-in-identifiers">, Group<f_Group>,
784 HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;
785 def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
786 def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
787 def fdwarf_directory_asm : Flag<["-"], "fdwarf-directory-asm">, Group<f_Group>;
788 def fno_dwarf_directory_asm : Flag<["-"], "fno-dwarf-directory-asm">, Group<f_Group>, Flags<[CC1Option]>;
789 def felide_constructors : Flag<["-"], "felide-constructors">, Group<f_Group>;
790 def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>,
792 HelpText<"Do not elide types when printing diagnostics">;
793 def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>;
794 def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
795 HelpText<"Emit all declarations, even if unused">;
796 def femulated_tls : Flag<["-"], "femulated-tls">, Group<f_Group>, Flags<[CC1Option]>,
797 HelpText<"Use emutls functions to access thread_local variables">;
798 def fno_emulated_tls : Flag<["-"], "fno-emulated-tls">, Group<f_Group>;
799 def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
800 def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
801 def fexceptions : Flag<["-"], "fexceptions">, Group<f_Group>, Flags<[CC1Option]>,
802 HelpText<"Enable support for exception handling">;
803 def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>,
804 Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">;
805 def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>,
806 Flags<[CC1Option]>, HelpText<"Use SjLj style exceptions">;
807 def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group<f_Group>,
808 Flags<[CC1Option]>, HelpText<"Use SEH style exceptions">;
809 def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">,
810 Group<clang_ignored_gcc_optimization_f_Group>;
811 def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
812 def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
813 def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>;
814 def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
815 def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>;
816 def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
817 def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
818 def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
819 def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group<f_Group>, Flags<[CC1Option]>;
820 def ffast_math : Flag<["-"], "ffast-math">, Group<f_Group>, Flags<[CC1Option]>,
821 HelpText<"Allow aggressive, lossy floating-point optimizations">;
822 def fno_fast_math : Flag<["-"], "fno-fast-math">, Group<f_Group>;
823 def fmath_errno : Flag<["-"], "fmath-errno">, Group<f_Group>, Flags<[CC1Option]>,
824 HelpText<"Require math functions to indicate errors by setting errno">;
825 def fno_math_errno : Flag<["-"], "fno-math-errno">, Group<f_Group>;
826 def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>;
827 def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>;
828 def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>;
829 def fjump_tables : Flag<["-"], "fjump-tables">, Group<f_Group>;
830 def fno_jump_tables : Flag<["-"], "fno-jump-tables">, Group<f_Group>, Flags<[CC1Option]>,
831 HelpText<"Do not use jump tables for lowering switches">;
833 // Begin sanitizer flags. These should all be core options exposed in all driver
835 let Flags = [CC1Option, CoreOption] in {
837 def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>,
838 MetaVarName<"<check>">,
839 HelpText<"Turn on runtime checks for various forms of undefined "
840 "or suspicious behavior. See user manual for available checks">;
841 def fno_sanitize_EQ : CommaJoined<["-"], "fno-sanitize=">, Group<f_clang_Group>,
842 Flags<[CoreOption, DriverOption]>;
843 def fsanitize_blacklist : Joined<["-"], "fsanitize-blacklist=">,
844 Group<f_clang_Group>,
845 HelpText<"Path to blacklist file for sanitizers">;
846 def fno_sanitize_blacklist : Flag<["-"], "fno-sanitize-blacklist">,
847 Group<f_clang_Group>,
848 HelpText<"Don't use blacklist file for sanitizers">;
849 def fsanitize_coverage
850 : CommaJoined<["-"], "fsanitize-coverage=">,
851 Group<f_clang_Group>,
852 HelpText<"Specify the type of coverage instrumentation for Sanitizers">;
853 def fno_sanitize_coverage
854 : CommaJoined<["-"], "fno-sanitize-coverage=">,
855 Group<f_clang_Group>, Flags<[CoreOption, DriverOption]>,
856 HelpText<"Disable specified features of coverage instrumentation for "
857 "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">;
858 def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">,
859 Group<f_clang_Group>,
860 HelpText<"Enable origins tracking in MemorySanitizer">;
861 def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">,
862 Group<f_clang_Group>,
863 HelpText<"Enable origins tracking in MemorySanitizer">;
864 def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">,
865 Group<f_clang_Group>,
866 Flags<[CoreOption, DriverOption]>,
867 HelpText<"Disable origins tracking in MemorySanitizer">;
868 def fsanitize_memory_use_after_dtor : Flag<["-"], "fsanitize-memory-use-after-dtor">,
869 Group<f_clang_Group>,
870 HelpText<"Enable use-after-destroy detection in MemorySanitizer">;
871 def fno_sanitize_memory_use_after_dtor : Flag<["-"], "fno-sanitize-memory-use-after-dtor">,
872 Group<f_clang_Group>,
873 HelpText<"Disable use-after-destroy detection in MemorySanitizer">;
874 def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">,
875 Group<f_clang_Group>,
876 HelpText<"Level of field padding for AddressSanitizer">;
877 def fsanitize_address_use_after_scope : Flag<["-"], "fsanitize-address-use-after-scope">,
878 Group<f_clang_Group>,
879 HelpText<"Enable use-after-scope detection in AddressSanitizer">;
880 def fno_sanitize_address_use_after_scope : Flag<["-"], "fno-sanitize-address-use-after-scope">,
881 Group<f_clang_Group>,
882 Flags<[CoreOption, DriverOption]>,
883 HelpText<"Disable use-after-scope detection in AddressSanitizer">;
884 def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">,
885 Group<f_clang_Group>,
886 HelpText<"Enable linker dead stripping of globals in AddressSanitizer">;
887 def fsanitize_recover : Flag<["-"], "fsanitize-recover">, Group<f_clang_Group>;
888 def fno_sanitize_recover : Flag<["-"], "fno-sanitize-recover">,
889 Flags<[CoreOption, DriverOption]>,
890 Group<f_clang_Group>;
891 def fsanitize_recover_EQ : CommaJoined<["-"], "fsanitize-recover=">,
892 Group<f_clang_Group>,
893 HelpText<"Enable recovery for specified sanitizers">;
894 def fno_sanitize_recover_EQ
895 : CommaJoined<["-"], "fno-sanitize-recover=">,
896 Group<f_clang_Group>,
897 Flags<[CoreOption, DriverOption]>,
898 HelpText<"Disable recovery for specified sanitizers">;
899 def fsanitize_trap_EQ : CommaJoined<["-"], "fsanitize-trap=">, Group<f_clang_Group>,
900 HelpText<"Enable trapping for specified sanitizers">;
901 def fno_sanitize_trap_EQ : CommaJoined<["-"], "fno-sanitize-trap=">, Group<f_clang_Group>,
902 Flags<[CoreOption, DriverOption]>,
903 HelpText<"Disable trapping for specified sanitizers">;
904 def fsanitize_undefined_trap_on_error : Flag<["-"], "fsanitize-undefined-trap-on-error">,
905 Group<f_clang_Group>;
906 def fno_sanitize_undefined_trap_on_error : Flag<["-"], "fno-sanitize-undefined-trap-on-error">,
907 Group<f_clang_Group>;
908 def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">,
909 Group<f_clang_Group>;
910 def fno_sanitize_minimal_runtime : Flag<["-"], "fno-sanitize-minimal-runtime">,
911 Group<f_clang_Group>;
912 def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">,
913 Group<f_clang_Group>;
914 def fsanitize_cfi_cross_dso : Flag<["-"], "fsanitize-cfi-cross-dso">,
915 Group<f_clang_Group>,
916 HelpText<"Enable control flow integrity (CFI) checks for cross-DSO calls.">;
917 def fno_sanitize_cfi_cross_dso : Flag<["-"], "fno-sanitize-cfi-cross-dso">,
918 Flags<[CoreOption, DriverOption]>,
919 Group<f_clang_Group>,
920 HelpText<"Disable control flow integrity (CFI) checks for cross-DSO calls.">;
921 def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">,
922 Group<f_clang_Group>,
923 HelpText<"Generalize pointers in CFI indirect call type signature checks">;
924 def fsanitize_stats : Flag<["-"], "fsanitize-stats">,
925 Group<f_clang_Group>,
926 HelpText<"Enable sanitizer statistics gathering.">;
927 def fno_sanitize_stats : Flag<["-"], "fno-sanitize-stats">,
928 Group<f_clang_Group>,
929 Flags<[CoreOption, DriverOption]>,
930 HelpText<"Disable sanitizer statistics gathering.">;
931 def fsanitize_thread_memory_access : Flag<["-"], "fsanitize-thread-memory-access">,
932 Group<f_clang_Group>,
933 HelpText<"Enable memory access instrumentation in ThreadSanitizer (default)">;
934 def fno_sanitize_thread_memory_access : Flag<["-"], "fno-sanitize-thread-memory-access">,
935 Group<f_clang_Group>,
936 Flags<[CoreOption, DriverOption]>,
937 HelpText<"Disable memory access instrumentation in ThreadSanitizer">;
938 def fsanitize_thread_func_entry_exit : Flag<["-"], "fsanitize-thread-func-entry-exit">,
939 Group<f_clang_Group>,
940 HelpText<"Enable function entry/exit instrumentation in ThreadSanitizer (default)">;
941 def fno_sanitize_thread_func_entry_exit : Flag<["-"], "fno-sanitize-thread-func-entry-exit">,
942 Group<f_clang_Group>,
943 Flags<[CoreOption, DriverOption]>,
944 HelpText<"Disable function entry/exit instrumentation in ThreadSanitizer">;
945 def fsanitize_thread_atomics : Flag<["-"], "fsanitize-thread-atomics">,
946 Group<f_clang_Group>,
947 HelpText<"Enable atomic operations instrumentation in ThreadSanitizer (default)">;
948 def fno_sanitize_thread_atomics : Flag<["-"], "fno-sanitize-thread-atomics">,
949 Group<f_clang_Group>,
950 Flags<[CoreOption, DriverOption]>,
951 HelpText<"Disable atomic operations instrumentation in ThreadSanitizer">;
952 def fsanitize_undefined_strip_path_components_EQ : Joined<["-"], "fsanitize-undefined-strip-path-components=">,
953 Group<f_clang_Group>, MetaVarName<"<number>">,
954 HelpText<"Strip (or keep only, if negative) a given number of path components "
955 "when emitting check metadata.">;
957 } // end -f[no-]sanitize* flags
959 def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">,
961 def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">,
963 def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
964 def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
965 def freciprocal_math :
966 Flag<["-"], "freciprocal-math">, Group<f_Group>, Flags<[CC1Option]>,
967 HelpText<"Allow division operations to be reassociated">;
968 def fno_reciprocal_math : Flag<["-"], "fno-reciprocal-math">, Group<f_Group>;
969 def ffinite_math_only : Flag<["-"], "ffinite-math-only">, Group<f_Group>, Flags<[CC1Option]>;
970 def fno_finite_math_only : Flag<["-"], "fno-finite-math-only">, Group<f_Group>;
971 def fsigned_zeros : Flag<["-"], "fsigned-zeros">, Group<f_Group>;
972 def fno_signed_zeros :
973 Flag<["-"], "fno-signed-zeros">, Group<f_Group>, Flags<[CC1Option]>,
974 HelpText<"Allow optimizations that ignore the sign of floating point zeros">;
975 def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>;
976 def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>;
977 def fhonor_infinities : Flag<["-"], "fhonor-infinities">, Group<f_Group>;
978 def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>;
979 // This option was originally misspelt "infinites" [sic].
980 def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
981 def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
982 def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>, Flags<[CC1Option]>;
983 def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>, Flags<[CC1Option]>;
984 def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>,
985 Flags<[CC1Option]>, HelpText<"Form fused FP ops (e.g. FMAs): fast (everywhere)"
986 " | on (according to FP_CONTRACT pragma, default) | off (never fuse)">, Values<"fast,on,off">;
988 def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>;
989 def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>;
991 def frewrite_includes : Flag<["-"], "frewrite-includes">, Group<f_Group>,
993 def fno_rewrite_includes : Flag<["-"], "fno-rewrite-includes">, Group<f_Group>;
995 def frewrite_imports : Flag<["-"], "frewrite-imports">, Group<f_Group>,
997 def fno_rewrite_imports : Flag<["-"], "fno-rewrite-imports">, Group<f_Group>;
999 def frewrite_map_file : Separate<["-"], "frewrite-map-file">,
1001 Flags<[ DriverOption, CC1Option ]>;
1002 def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">,
1004 Flags<[DriverOption]>;
1006 def fuse_line_directives : Flag<["-"], "fuse-line-directives">, Group<f_Group>,
1008 def fno_use_line_directives : Flag<["-"], "fno-use-line-directives">, Group<f_Group>;
1010 def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>,
1011 HelpText<"Assert that the compilation takes place in a freestanding environment">;
1012 def fgnu_keywords : Flag<["-"], "fgnu-keywords">, Group<f_Group>, Flags<[CC1Option]>,
1013 HelpText<"Allow GNU-extension keywords regardless of language standard">;
1014 def fgnu89_inline : Flag<["-"], "fgnu89-inline">, Group<f_Group>, Flags<[CC1Option]>,
1015 HelpText<"Use the gnu89 inline semantics">;
1016 def fno_gnu89_inline : Flag<["-"], "fno-gnu89-inline">, Group<f_Group>;
1017 def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>,
1018 HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;
1019 def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>;
1020 def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>,
1022 def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>;
1023 def finline_functions : Flag<["-"], "finline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
1024 HelpText<"Inline suitable functions">;
1025 def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
1026 HelpText<"Inline functions which are (explicitly or implicitly) marked inline">;
1027 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
1028 def fexperimental_new_pass_manager : Flag<["-"], "fexperimental-new-pass-manager">,
1029 Group<f_clang_Group>, Flags<[CC1Option]>,
1030 HelpText<"Enables an experimental new pass manager in LLVM.">;
1031 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
1032 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
1033 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
1034 HelpText<"Generate calls to instrument function entry and exit">;
1035 def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>,
1036 HelpText<"Like -finstrument-functions, but insert the calls after inlining">;
1037 def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>,
1038 HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">;
1040 def fxray_instrument : Flag<["-"], "fxray-instrument">, Group<f_Group>,
1042 HelpText<"Generate XRay instrumentation sleds on function entry and exit">;
1043 def fnoxray_instrument : Flag<["-"], "fno-xray-instrument">, Group<f_Group>,
1046 def fxray_instruction_threshold_EQ :
1047 JoinedOrSeparate<["-"], "fxray-instruction-threshold=">,
1048 Group<f_Group>, Flags<[CC1Option]>,
1049 HelpText<"Sets the minimum function size to instrument with XRay">;
1050 def fxray_instruction_threshold_ :
1051 JoinedOrSeparate<["-"], "fxray-instruction-threshold">,
1052 Group<f_Group>, Flags<[CC1Option]>;
1054 def fxray_always_instrument :
1055 JoinedOrSeparate<["-"], "fxray-always-instrument=">,
1056 Group<f_Group>, Flags<[CC1Option]>,
1057 HelpText<"Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">;
1058 def fxray_never_instrument :
1059 JoinedOrSeparate<["-"], "fxray-never-instrument=">,
1060 Group<f_Group>, Flags<[CC1Option]>,
1061 HelpText<"Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.">;
1063 def fxray_always_emit_customevents : Flag<["-"], "fxray-always-emit-customevents">, Group<f_Group>,
1065 HelpText<"Determine whether to always emit __xray_customevent(...) calls even if the function it appears in is not always instrumented.">;
1066 def fnoxray_always_emit_customevents : Flag<["-"], "fno-xray-always-emit-customevents">, Group<f_Group>,
1069 def ffine_grained_bitfield_accesses : Flag<["-"],
1070 "ffine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
1071 HelpText<"Use separate accesses for bitfields with legal widths and alignments.">;
1072 def fno_fine_grained_bitfield_accesses : Flag<["-"],
1073 "fno-fine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
1074 HelpText<"Use large-integer access for consecutive bitfield runs.">;
1076 def flat__namespace : Flag<["-"], "flat_namespace">;
1077 def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>;
1078 def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>;
1079 def flto_EQ : Joined<["-"], "flto=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1080 HelpText<"Set LTO mode to either 'full' or 'thin'">, Values<"thin,full">;
1081 def flto : Flag<["-"], "flto">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
1082 HelpText<"Enable LTO in 'full' mode">;
1083 def fno_lto : Flag<["-"], "fno-lto">, Group<f_Group>,
1084 HelpText<"Disable LTO mode (default)">;
1085 def flto_jobs_EQ : Joined<["-"], "flto-jobs=">,
1086 Flags<[CC1Option]>, Group<f_Group>,
1087 HelpText<"Controls the backend parallelism of -flto=thin (default "
1088 "of 0 means the number of threads will be derived from "
1089 "the number of CPUs detected)">;
1090 def fthinlto_index_EQ : Joined<["-"], "fthinlto-index=">,
1091 Flags<[CC1Option]>, Group<f_Group>,
1092 HelpText<"Perform ThinLTO importing using provided function summary index">;
1093 def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">,
1094 Group<f_Group>, Flags<[DriverOption, CoreOption]>;
1095 def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>;
1096 def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>;
1097 def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1098 HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;
1099 def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
1100 HelpText<"Enable full Microsoft Visual C++ compatibility">;
1101 def fms_volatile : Joined<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>;
1102 def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[DriverOption, CoreOption]>,
1103 HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
1104 def fms_compatibility_version
1105 : Joined<["-"], "fms-compatibility-version=">,
1107 Flags<[ CC1Option, CoreOption ]>,
1108 HelpText<"Dot-separated value representing the Microsoft compiler "
1109 "version number to report in _MSC_VER (0 = don't define it "
1111 def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,
1112 HelpText<"Parse templated function definitions at the end of the "
1113 "translation unit">, Flags<[CC1Option, CoreOption]>;
1114 def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
1115 def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
1116 Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
1117 HelpText<"Specify the module cache path">;
1118 def fmodules_user_build_path : Separate<["-"], "fmodules-user-build-path">, Group<i_Group>,
1119 Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
1120 HelpText<"Specify the module user build path">;
1121 def fprebuilt_module_path : Joined<["-"], "fprebuilt-module-path=">, Group<i_Group>,
1122 Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
1123 HelpText<"Specify the prebuilt module path">;
1124 def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>,
1125 Flags<[CC1Option]>, MetaVarName<"<seconds>">,
1126 HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">;
1127 def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>,
1128 Flags<[CC1Option]>, MetaVarName<"<seconds>">,
1129 HelpText<"Specify the interval (in seconds) after which a module file will be considered unused">;
1130 def fmodules_search_all : Flag <["-"], "fmodules-search-all">, Group<f_Group>,
1131 Flags<[DriverOption, CC1Option]>,
1132 HelpText<"Search even non-imported modules to resolve references">;
1133 def fbuild_session_timestamp : Joined<["-"], "fbuild-session-timestamp=">,
1134 Group<i_Group>, Flags<[CC1Option]>, MetaVarName<"<time since Epoch in seconds>">,
1135 HelpText<"Time when the current build session started">;
1136 def fbuild_session_file : Joined<["-"], "fbuild-session-file=">,
1137 Group<i_Group>, MetaVarName<"<file>">,
1138 HelpText<"Use the last modification time of <file> as the build session timestamp">;
1139 def fmodules_validate_once_per_build_session : Flag<["-"], "fmodules-validate-once-per-build-session">,
1140 Group<i_Group>, Flags<[CC1Option]>,
1141 HelpText<"Don't verify input files for the modules if the module has been "
1142 "successfully validated or loaded during this build session">;
1143 def fmodules_disable_diagnostic_validation : Flag<["-"], "fmodules-disable-diagnostic-validation">,
1144 Group<i_Group>, Flags<[CC1Option]>,
1145 HelpText<"Disable validation of the diagnostic options when loading the module">;
1146 def fmodules_validate_system_headers : Flag<["-"], "fmodules-validate-system-headers">,
1147 Group<i_Group>, Flags<[CC1Option]>,
1148 HelpText<"Validate the system headers that a module depends on when loading the module">;
1149 def fmodules : Flag <["-"], "fmodules">, Group<f_Group>,
1150 Flags<[DriverOption, CC1Option]>,
1151 HelpText<"Enable the 'modules' language feature">;
1152 def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group>,
1153 Flags<[DriverOption, CC1Option]>,
1154 HelpText<"Implicitly search the file system for module map files.">;
1155 def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_Group>,
1156 Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">;
1157 def fmodule_maps : Flag <["-"], "fmodule-maps">, Alias<fimplicit_module_maps>;
1158 def fmodule_name_EQ : Joined<["-"], "fmodule-name=">, Group<f_Group>,
1159 Flags<[DriverOption,CC1Option]>, MetaVarName<"<name>">,
1160 HelpText<"Specify the name of the module to build">;
1161 def fmodule_name : Separate<["-"], "fmodule-name">, Alias<fmodule_name_EQ>;
1162 def fmodule_implementation_of : Separate<["-"], "fmodule-implementation-of">,
1163 Flags<[CC1Option]>, Alias<fmodule_name_EQ>;
1164 def fmodule_map_file : Joined<["-"], "fmodule-map-file=">,
1165 Group<f_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"<file>">,
1166 HelpText<"Load this module map file">;
1167 def fmodule_file : Joined<["-"], "fmodule-file=">,
1168 Group<i_Group>, Flags<[DriverOption,CC1Option]>, MetaVarName<"[<name>=]<file>">,
1169 HelpText<"Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.">;
1170 def fmodules_ignore_macro : Joined<["-"], "fmodules-ignore-macro=">, Group<f_Group>, Flags<[CC1Option]>,
1171 HelpText<"Ignore the definition of the given macro when building and loading modules">;
1172 def fmodules_decluse : Flag <["-"], "fmodules-decluse">, Group<f_Group>,
1173 Flags<[DriverOption,CC1Option]>,
1174 HelpText<"Require declaration of modules used within a module">;
1175 def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>,
1176 Flags<[DriverOption,CC1Option]>,
1177 HelpText<"Like -fmodules-decluse but requires all headers to be in modules">;
1178 def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>,
1179 Flags<[DriverOption, CC1Option]>;
1180 def fno_implicit_modules :
1181 Flag <["-"], "fno-implicit-modules">,
1182 Group<f_Group>, Flags<[DriverOption, CC1Option]>;
1183 def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>;
1185 def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>;
1186 def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>;
1187 def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>;
1188 def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>;
1189 def fno_access_control : Flag<["-"], "fno-access-control">, Group<f_Group>, Flags<[CC1Option]>,
1190 HelpText<"Disable C++ access control">;
1191 def fno_apple_pragma_pack : Flag<["-"], "fno-apple-pragma-pack">, Group<f_Group>;
1192 def fno_asm : Flag<["-"], "fno-asm">, Group<f_Group>;
1193 def fno_asynchronous_unwind_tables : Flag<["-"], "fno-asynchronous-unwind-tables">, Group<f_Group>;
1194 def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>,
1195 HelpText<"Don't assume that C++'s global operator new can't alias any pointer">,
1197 def fno_blocks : Flag<["-"], "fno-blocks">, Group<f_Group>;
1198 def fno_borland_extensions : Flag<["-"], "fno-borland-extensions">, Group<f_Group>;
1199 def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option]>,
1200 HelpText<"Disable implicit builtin knowledge of functions">;
1201 def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<f_Group>, Flags<[CC1Option]>,
1202 HelpText<"Disable implicit builtin knowledge of a specific function">;
1203 def fno_caret_diagnostics : Flag<["-"], "fno-caret-diagnostics">, Group<f_Group>,
1205 def fno_color_diagnostics : Flag<["-"], "fno-color-diagnostics">, Group<f_Group>,
1206 Flags<[CoreOption, CC1Option]>;
1207 def fno_diagnostics_color : Flag<["-"], "fno-diagnostics-color">, Group<f_Group>,
1208 Flags<[CoreOption, DriverOption]>;
1209 def fno_common : Flag<["-"], "fno-common">, Group<f_Group>, Flags<[CC1Option]>,
1210 HelpText<"Compile common globals like normal definitions">;
1211 def fno_constant_cfstrings : Flag<["-"], "fno-constant-cfstrings">, Group<f_Group>,
1213 HelpText<"Disable creation of CodeFoundation-type constant strings">;
1214 def fno_cxx_exceptions: Flag<["-"], "fno-cxx-exceptions">, Group<f_Group>;
1215 def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>,
1216 Flags<[DriverOption]>;
1217 def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>,
1218 Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">;
1219 def fno_diagnostics_show_hotness : Flag<["-"], "fno-diagnostics-show-hotness">, Group<f_Group>;
1220 def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_Group>;
1221 def fno_diagnostics_show_note_include_stack : Flag<["-"], "fno-diagnostics-show-note-include-stack">,
1222 Flags<[CC1Option]>, Group<f_Group>;
1223 def fno_declspec : Flag<["-"], "fno-declspec">, Group<f_clang_Group>,
1224 HelpText<"Disallow __declspec as a keyword">, Flags<[CC1Option]>;
1225 def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>,
1226 HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;
1227 def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
1228 HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;
1229 def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
1230 def fno_exceptions : Flag<["-"], "fno-exceptions">, Group<f_Group>;
1231 def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
1232 def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
1233 def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>;
1234 def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">,
1235 Group<f_clang_Group>, Flags<[CC1Option]>,
1236 HelpText<"Disables an experimental new pass manager in LLVM.">;
1237 def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>,
1238 HelpText<"Use the given vector functions library">, Values<"Accelerate,SVML,none">;
1239 def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
1240 HelpText<"Disallow implicit conversions between vectors with a different number of elements or different element types">, Flags<[CC1Option]>;
1241 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
1242 Flags<[CC1Option]>, HelpText<"Disallow merging of constants">;
1243 def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
1244 Flags<[DriverOption]>;
1245 def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>,
1246 Flags<[DriverOption]>;
1247 def fno_module_maps : Flag <["-"], "fno-module-maps">, Alias<fno_implicit_module_maps>;
1248 def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>,
1249 Flags<[DriverOption]>;
1250 def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>,
1251 Flags<[DriverOption]>;
1252 def fimplicit_modules : Flag <["-"], "fimplicit-modules">, Group<f_Group>,
1253 Flags<[DriverOption]>;
1254 def fmodule_file_deps : Flag <["-"], "fmodule-file-deps">, Group<f_Group>,
1255 Flags<[DriverOption]>;
1256 def fno_module_file_deps : Flag <["-"], "fno-module-file-deps">, Group<f_Group>,
1257 Flags<[DriverOption]>;
1258 def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>,
1259 Flags<[CoreOption]>;
1260 def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>,
1261 Flags<[CoreOption]>;
1262 def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>,
1263 HelpText<"Disable delayed template parsing">,
1264 Flags<[DriverOption, CoreOption]>;
1265 def fno_objc_exceptions: Flag<["-"], "fno-objc-exceptions">, Group<f_Group>;
1266 def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>;
1267 def fno_objc_weak : Flag<["-"], "fno-objc-weak">, Group<f_Group>, Flags<[CC1Option]>;
1268 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
1269 def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>,
1270 HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,
1272 def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>;
1273 def fno_rtti : Flag<["-"], "fno-rtti">, Group<f_Group>, Flags<[CC1Option]>,
1274 HelpText<"Disable generation of rtti information">;
1275 def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>;
1276 def fno_show_column : Flag<["-"], "fno-show-column">, Group<f_Group>, Flags<[CC1Option]>,
1277 HelpText<"Do not include column number on diagnostics">;
1278 def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>,
1279 Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;
1280 def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
1281 Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">;
1282 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
1283 Flags<[CC1Option]>, HelpText<"Disable spell-checking">;
1284 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
1285 HelpText<"Disable the use of stack protectors">;
1286 def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>,
1287 Flags<[DriverOption, CoreOption]>;
1288 def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>;
1289 def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>;
1290 def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>;
1291 def fno_strict_vtable_pointers: Flag<["-"], "fno-strict-vtable-pointers">,
1293 def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>;
1294 def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>,
1295 Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">;
1296 def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>,
1297 HelpText<"Don't use __cxa_atexit for calling destructors">;
1298 def fno_use_init_array : Flag<["-"], "fno-use-init-array">, Group<f_Group>, Flags<[CC1Option]>,
1299 HelpText<"Don't use .init_array instead of .ctors">;
1300 def fno_unit_at_a_time : Flag<["-"], "fno-unit-at-a-time">, Group<f_Group>;
1301 def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>;
1302 def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>;
1303 def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>;
1304 def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>;
1305 def fno_zero_initialized_in_bss : Flag<["-"], "fno-zero-initialized-in-bss">, Group<f_Group>;
1306 def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>,
1307 HelpText<"Synthesize retain and release calls for Objective-C pointers">;
1308 def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>;
1309 def fobjc_arc_exceptions : Flag<["-"], "fobjc-arc-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
1310 HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">;
1311 def fno_objc_arc_exceptions : Flag<["-"], "fno-objc-arc-exceptions">, Group<f_Group>;
1312 def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>;
1313 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
1314 def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>,
1315 HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;
1316 def fapplication_extension : Flag<["-"], "fapplication-extension">,
1317 Group<f_Group>, Flags<[CC1Option]>,
1318 HelpText<"Restrict code to those available for App Extensions">;
1319 def fno_application_extension : Flag<["-"], "fno-application-extension">,
1321 def frelaxed_template_template_args : Flag<["-"], "frelaxed-template-template-args">,
1322 Flags<[CC1Option]>, HelpText<"Enable C++17 relaxed template template argument matching">,
1324 def fno_relaxed_template_template_args : Flag<["-"], "fno-relaxed-template-template-args">,
1326 def fsized_deallocation : Flag<["-"], "fsized-deallocation">, Flags<[CC1Option]>,
1327 HelpText<"Enable C++14 sized global deallocation functions">, Group<f_Group>;
1328 def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Group<f_Group>;
1329 def faligned_allocation : Flag<["-"], "faligned-allocation">, Flags<[CC1Option]>,
1330 HelpText<"Enable C++17 aligned allocation functions">, Group<f_Group>;
1331 def fno_aligned_allocation: Flag<["-"], "fno-aligned-allocation">,
1332 Group<f_Group>, Flags<[CC1Option]>;
1333 def fnew_alignment_EQ : Joined<["-"], "fnew-alignment=">,
1334 HelpText<"Specifies the largest alignment guaranteed by '::operator new(size_t)'">,
1335 MetaVarName<"<align>">, Group<f_Group>, Flags<[CC1Option]>;
1336 def : Separate<["-"], "fnew-alignment">, Alias<fnew_alignment_EQ>;
1337 def : Flag<["-"], "faligned-new">, Alias<faligned_allocation>;
1338 def : Flag<["-"], "fno-aligned-new">, Alias<fno_aligned_allocation>;
1339 def faligned_new_EQ : Joined<["-"], "faligned-new=">;
1341 def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
1342 def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;
1343 def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">,
1345 def fno_objc_infer_related_result_type : Flag<["-"],
1346 "fno-objc-infer-related-result-type">, Group<f_Group>,
1348 "do not infer Objective-C related result type based on method family">,
1350 def fobjc_link_runtime: Flag<["-"], "fobjc-link-runtime">, Group<f_Group>;
1351 def fobjc_weak : Flag<["-"], "fobjc-weak">, Group<f_Group>, Flags<[CC1Option]>,
1352 HelpText<"Enable ARC-style weak references in Objective-C">;
1354 // Objective-C ABI options.
1355 def fobjc_runtime_EQ : Joined<["-"], "fobjc-runtime=">, Group<f_Group>, Flags<[CC1Option]>,
1356 HelpText<"Specify the target Objective-C runtime kind and version">;
1357 def fobjc_abi_version_EQ : Joined<["-"], "fobjc-abi-version=">, Group<f_Group>;
1358 def fobjc_nonfragile_abi_version_EQ : Joined<["-"], "fobjc-nonfragile-abi-version=">, Group<f_Group>;
1359 def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>;
1360 def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>;
1362 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
1363 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
1364 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
1365 def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
1366 def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
1367 def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;
1368 def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>, Flags<[NoArgumentUnused]>;
1369 def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
1370 def fopenmp_targets_EQ : CommaJoined<["-"], "fopenmp-targets=">, Flags<[DriverOption, CC1Option]>,
1371 HelpText<"Specify comma-separated list of triples OpenMP offloading targets to be supported">;
1372 def fopenmp_dump_offload_linker_script : Flag<["-"], "fopenmp-dump-offload-linker-script">, Group<f_Group>,
1373 Flags<[NoArgumentUnused]>;
1374 def fopenmp_relocatable_target : Flag<["-"], "fopenmp-relocatable-target">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
1375 HelpText<"OpenMP target code is compiled as relocatable using the -c flag. For OpenMP targets the code is relocatable by default.">;
1376 def fnoopenmp_relocatable_target : Flag<["-"], "fnoopenmp-relocatable-target">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
1377 HelpText<"Do not compile OpenMP target code as relocatable.">;
1378 def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>;
1379 def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>;
1380 def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">;
1381 def force__flat__namespace : Flag<["-"], "force_flat_namespace">;
1382 def force__load : Separate<["-"], "force_load">;
1383 def force_addr : Joined<["-"], "fforce-addr">, Group<clang_ignored_f_Group>;
1384 def foutput_class_dir_EQ : Joined<["-"], "foutput-class-dir=">, Group<f_Group>;
1385 def fpack_struct : Flag<["-"], "fpack-struct">, Group<f_Group>;
1386 def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>;
1387 def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>,
1388 HelpText<"Specify the default maximum struct packing alignment">;
1389 def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>,
1390 HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">;
1391 def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>;
1392 def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
1393 HelpText<"Recognize and construct Pascal-style string literals">;
1394 def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
1395 HelpText<"Override the default ABI to return all structs on the stack">;
1396 def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>;
1397 def fpic : Flag<["-"], "fpic">, Group<f_Group>;
1398 def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
1399 def fpie : Flag<["-"], "fpie">, Group<f_Group>;
1400 def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
1401 def fplt : Flag<["-"], "fplt">, Group<f_Group>, Flags<[CC1Option]>,
1402 HelpText<"Use the PLT to make function calls">;
1403 def fno_plt : Flag<["-"], "fno-plt">, Group<f_Group>, Flags<[CC1Option]>,
1404 HelpText<"Do not use the PLT to make function calls">;
1405 def fropi : Flag<["-"], "fropi">, Group<f_Group>;
1406 def fno_ropi : Flag<["-"], "fno-ropi">, Group<f_Group>;
1407 def frwpi : Flag<["-"], "frwpi">, Group<f_Group>;
1408 def fno_rwpi : Flag<["-"], "fno-rwpi">, Group<f_Group>;
1409 def fplugin_EQ : Joined<["-"], "fplugin=">, Group<f_Group>, Flags<[DriverOption]>, MetaVarName<"<dsopath>">,
1410 HelpText<"Load the named plugin (dynamic shared object)">;
1411 def fpreserve_as_comments : Flag<["-"], "fpreserve-as-comments">, Group<f_Group>;
1412 def fno_preserve_as_comments : Flag<["-"], "fno-preserve-as-comments">, Group<f_Group>, Flags<[CC1Option]>,
1413 HelpText<"Do not preserve comments in inline assembly">;
1414 def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>;
1415 def fno_profile_arcs : Flag<["-"], "fno-profile-arcs">, Group<f_Group>;
1416 def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
1417 def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>;
1418 def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
1419 HelpText<"Override the default ABI to return small structs in registers">;
1420 def frtti : Flag<["-"], "frtti">, Group<f_Group>;
1421 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
1422 def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
1423 HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
1424 def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>,
1425 HelpText<"Force wchar_t to be a short unsigned int">;
1426 def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>,
1427 HelpText<"Force wchar_t to be an unsigned int">;
1428 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
1429 HelpText<"Which overload candidates to show when overload resolution fails: "
1430 "best|all; defaults to all">, Values<"best,all">;
1431 def fshow_column : Flag<["-"], "fshow-column">, Group<f_Group>, Flags<[CC1Option]>;
1432 def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>;
1433 def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
1434 def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>;
1435 def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>;
1436 def fsigned_char : Flag<["-"], "fsigned-char">, Group<f_Group>;
1437 def fno_signed_char : Flag<["-"], "fno-signed-char">, Group<f_Group>,
1438 Flags<[CC1Option]>, HelpText<"Char is unsigned">;
1439 def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>;
1440 def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>,
1441 HelpText<"Force the usage of stack protectors for all functions">;
1442 def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>,
1443 HelpText<"Use a strong heuristic to apply stack protectors to functions">;
1444 def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>,
1445 HelpText<"Enable stack protectors for functions potentially vulnerable to stack smashing">;
1446 def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>, Flags<[CoreOption]>,
1447 HelpText<"Emit full debug info for all types used by the program">;
1448 def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CoreOption]>,
1449 HelpText<"Limit debug information produced to reduce size of debug binary">;
1450 def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Flags<[CoreOption]>, Alias<fno_standalone_debug>;
1451 def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Flags<[CoreOption]>, Alias<fstandalone_debug>;
1452 def fdebug_macro : Flag<["-"], "fdebug-macro">, Group<f_Group>, Flags<[CoreOption]>,
1453 HelpText<"Emit macro debug information">;
1454 def fno_debug_macro : Flag<["-"], "fno-debug-macro">, Group<f_Group>, Flags<[CoreOption]>,
1455 HelpText<"Do not emit macro debug information">;
1456 def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,
1457 Flags<[DriverOption, CoreOption]>;
1458 def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
1459 HelpText<"Enable optimizations based on the strict definition of an enum's "
1461 def fstrict_vtable_pointers: Flag<["-"], "fstrict-vtable-pointers">,
1462 Group<f_Group>, Flags<[CC1Option]>,
1463 HelpText<"Enable optimizations based on the strict rules for overwriting "
1464 "polymorphic C++ objects">;
1465 def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>;
1466 def fsyntax_only : Flag<["-"], "fsyntax-only">,
1467 Flags<[DriverOption,CoreOption,CC1Option]>, Group<Action_Group>;
1468 def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>;
1469 def ftemplate_depth_EQ : Joined<["-"], "ftemplate-depth=">, Group<f_Group>;
1470 def ftemplate_depth_ : Joined<["-"], "ftemplate-depth-">, Group<f_Group>;
1471 def ftemplate_backtrace_limit_EQ : Joined<["-"], "ftemplate-backtrace-limit=">,
1473 def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">,
1476 def fsave_optimization_record : Flag<["-"], "fsave-optimization-record">,
1477 Group<f_Group>, HelpText<"Generate a YAML optimization record file">;
1478 def fno_save_optimization_record : Flag<["-"], "fno-save-optimization-record">,
1479 Group<f_Group>, Flags<[NoArgumentUnused]>;
1480 def foptimization_record_file_EQ : Joined<["-"], "foptimization-record-file=">,
1482 HelpText<"Specify the file name of any generated YAML optimization record">;
1484 def ftest_coverage : Flag<["-"], "ftest-coverage">, Group<f_Group>;
1485 def fvectorize : Flag<["-"], "fvectorize">, Group<f_Group>,
1486 HelpText<"Enable the loop vectorization passes">;
1487 def fno_vectorize : Flag<["-"], "fno-vectorize">, Group<f_Group>;
1488 def : Flag<["-"], "ftree-vectorize">, Alias<fvectorize>;
1489 def : Flag<["-"], "fno-tree-vectorize">, Alias<fno_vectorize>;
1490 def fslp_vectorize : Flag<["-"], "fslp-vectorize">, Group<f_Group>,
1491 HelpText<"Enable the superword-level parallelism vectorization passes">;
1492 def fno_slp_vectorize : Flag<["-"], "fno-slp-vectorize">, Group<f_Group>;
1493 def : Flag<["-"], "ftree-slp-vectorize">, Alias<fslp_vectorize>;
1494 def : Flag<["-"], "fno-tree-slp-vectorize">, Alias<fno_slp_vectorize>;
1495 def Wlarge_by_value_copy_def : Flag<["-"], "Wlarge-by-value-copy">,
1496 HelpText<"Warn if a function definition returns or accepts an object larger "
1497 "in bytes than a given value">, Flags<[HelpHidden]>;
1498 def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>;
1500 // These "special" warning flags are effectively processed as f_Group flags by the driver:
1501 // Just silence warnings about -Wlarger-than for now.
1502 def Wlarger_than_EQ : Joined<["-"], "Wlarger-than=">, Group<clang_ignored_f_Group>;
1503 def Wlarger_than_ : Joined<["-"], "Wlarger-than-">, Alias<Wlarger_than_EQ>;
1504 def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[DriverOption]>;
1506 def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>;
1507 def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group<f_Group>;
1508 def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>;
1509 def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>;
1510 def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>,
1511 HelpText<"Trap on integer overflow">;
1512 def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>,
1513 MetaVarName<"<function name>">,
1514 HelpText<"Specify the function to be called on overflow">;
1515 def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>;
1516 def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>,
1517 HelpText<"Issue call to specified function rather than a trap instruction">;
1518 def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>;
1519 def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
1520 HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;
1521 def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
1522 HelpText<"Turn off loop unroller">, Flags<[CC1Option]>;
1523 def freroll_loops : Flag<["-"], "freroll-loops">, Group<f_Group>,
1524 HelpText<"Turn on loop reroller">, Flags<[CC1Option]>;
1525 def fno_reroll_loops : Flag<["-"], "fno-reroll-loops">, Group<f_Group>,
1526 HelpText<"Turn off loop reroller">;
1527 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
1528 HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
1529 def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
1530 HelpText<"Do not process trigraph sequences">, Flags<[CC1Option]>;
1531 def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>;
1532 def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>;
1533 def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">;
1534 def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>;
1535 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
1536 def fuse_init_array : Flag<["-"], "fuse-init-array">, Group<f_Group>, Flags<[CC1Option]>,
1537 HelpText<"Use .init_array instead of .ctors">;
1538 def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
1539 def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>;
1540 def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>,
1541 HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">;
1542 def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>,
1543 HelpText<"Give inline C++ member functions default visibility by default">,
1545 def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>,
1546 HelpText<"Give global types 'default' visibility and global functions and "
1547 "variables 'hidden' visibility by default">;
1548 def fwhole_program_vtables : Flag<["-"], "fwhole-program-vtables">, Group<f_Group>,
1549 Flags<[CoreOption, CC1Option]>,
1550 HelpText<"Enables whole-program vtable optimization. Requires -flto">;
1551 def fno_whole_program_vtables : Flag<["-"], "fno-whole-program-vtables">, Group<f_Group>,
1552 Flags<[CoreOption]>;
1553 def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>,
1554 HelpText<"Treat signed integer overflow as two's complement">;
1555 def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>,
1556 HelpText<"Store string literals as writable data">;
1557 def fzero_initialized_in_bss : Flag<["-"], "fzero-initialized-in-bss">, Group<f_Group>;
1558 def ffunction_sections : Flag<["-"], "ffunction-sections">, Group<f_Group>,
1560 HelpText<"Place each function in its own section (ELF Only)">;
1561 def fno_function_sections : Flag<["-"], "fno-function-sections">,
1562 Group<f_Group>, Flags<[CC1Option]>;
1563 def fdata_sections : Flag <["-"], "fdata-sections">, Group<f_Group>,
1564 Flags<[CC1Option]>, HelpText<"Place each data in its own section (ELF Only)">;
1565 def fno_data_sections : Flag <["-"], "fno-data-sections">, Group<f_Group>,
1568 def funique_section_names : Flag <["-"], "funique-section-names">,
1569 Group<f_Group>, Flags<[CC1Option]>,
1570 HelpText<"Use unique names for text and data sections (ELF Only)">;
1571 def fno_unique_section_names : Flag <["-"], "fno-unique-section-names">,
1572 Group<f_Group>, Flags<[CC1Option]>;
1574 def fstrict_return : Flag<["-"], "fstrict-return">, Group<f_Group>,
1576 HelpText<"Always treat control flow paths that fall off the end of a "
1577 "non-void function as unreachable">;
1578 def fno_strict_return : Flag<["-"], "fno-strict-return">, Group<f_Group>,
1581 def fallow_editor_placeholders : Flag<["-"], "fallow-editor-placeholders">,
1582 Group<f_Group>, Flags<[CC1Option]>,
1583 HelpText<"Treat editor placeholders as valid source code">;
1584 def fno_allow_editor_placeholders : Flag<["-"],
1585 "fno-allow-editor-placeholders">, Group<f_Group>;
1587 def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
1588 Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;
1589 def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>,
1591 def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, Group<f_Group>,
1592 Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;
1593 def fno_split_dwarf_inlining: Flag<["-"], "fno-split-dwarf-inlining">, Group<f_Group>,
1595 def fdebug_prefix_map_EQ
1596 : Joined<["-"], "fdebug-prefix-map=">, Group<f_Group>, Flags<[CC1Option]>,
1597 HelpText<"remap file source paths in debug info">;
1598 def g_Flag : Flag<["-"], "g">, Group<g_Group>,
1599 HelpText<"Generate source-level debug information">;
1600 def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
1601 Flags<[CoreOption]>, HelpText<"Emit debug line number tables only">;
1602 def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>;
1603 def g0 : Flag<["-"], "g0">, Group<gN_Group>;
1604 def g1 : Flag<["-"], "g1">, Group<gN_Group>, Alias<gline_tables_only>;
1605 def g2 : Flag<["-"], "g2">, Group<gN_Group>;
1606 def g3 : Flag<["-"], "g3">, Group<gN_Group>;
1607 def ggdb : Flag<["-"], "ggdb">, Group<gTune_Group>;
1608 def ggdb0 : Flag<["-"], "ggdb0">, Group<ggdbN_Group>;
1609 def ggdb1 : Flag<["-"], "ggdb1">, Group<ggdbN_Group>;
1610 def ggdb2 : Flag<["-"], "ggdb2">, Group<ggdbN_Group>;
1611 def ggdb3 : Flag<["-"], "ggdb3">, Group<ggdbN_Group>;
1612 def glldb : Flag<["-"], "glldb">, Group<gTune_Group>;
1613 def gsce : Flag<["-"], "gsce">, Group<gTune_Group>;
1614 def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>,
1615 HelpText<"Generate source-level debug information with dwarf version 2">;
1616 def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>,
1617 HelpText<"Generate source-level debug information with dwarf version 3">;
1618 def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>,
1619 HelpText<"Generate source-level debug information with dwarf version 4">;
1620 def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>,
1621 HelpText<"Generate source-level debug information with dwarf version 5">;
1622 def gcodeview : Flag<["-"], "gcodeview">,
1623 HelpText<"Generate CodeView debug information">,
1624 Flags<[CC1Option, CC1AsOption, CoreOption]>;
1625 // Equivalent to our default dwarf version. Forces usual dwarf emission when
1626 // CodeView is enabled.
1627 def gdwarf : Flag<["-"], "gdwarf">, Alias<gdwarf_4>, Flags<[CoreOption]>;
1629 def gfull : Flag<["-"], "gfull">, Group<g_Group>;
1630 def gused : Flag<["-"], "gused">, Group<g_Group>;
1631 def gstabs : Joined<["-"], "gstabs">, Group<g_Group>, Flags<[Unsupported]>;
1632 def gcoff : Joined<["-"], "gcoff">, Group<g_Group>, Flags<[Unsupported]>;
1633 def gxcoff : Joined<["-"], "gxcoff">, Group<g_Group>, Flags<[Unsupported]>;
1634 def gvms : Joined<["-"], "gvms">, Group<g_Group>, Flags<[Unsupported]>;
1635 def gtoggle : Flag<["-"], "gtoggle">, Group<g_flags_Group>, Flags<[Unsupported]>;
1636 def grecord_gcc_switches : Flag<["-"], "grecord-gcc-switches">, Group<g_flags_Group>;
1637 def gno_record_gcc_switches : Flag<["-"], "gno-record-gcc-switches">,
1638 Group<g_flags_Group>;
1639 def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>;
1640 def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>;
1641 def gcolumn_info : Flag<["-"], "gcolumn-info">, Group<g_flags_Group>, Flags<[CoreOption]>;
1642 def gno_column_info : Flag<["-"], "gno-column-info">, Group<g_flags_Group>, Flags<[CoreOption]>;
1643 def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>;
1644 def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group<g_flags_Group>, Flags<[CC1Option]>;
1645 def gdwarf_aranges : Flag<["-"], "gdwarf-aranges">, Group<g_flags_Group>;
1646 def gmodules : Flag <["-"], "gmodules">, Group<gN_Group>,
1647 HelpText<"Generate debug info with external references to clang modules"
1648 " or precompiled headers">;
1649 def gz : Flag<["-"], "gz">, Group<g_flags_Group>,
1650 HelpText<"DWARF debug sections compression type">;
1651 def gz_EQ : Joined<["-"], "gz=">, Group<g_flags_Group>,
1652 HelpText<"DWARF debug sections compression type">;
1653 def headerpad__max__install__names : Joined<["-"], "headerpad_max_install_names">;
1654 def help : Flag<["-", "--"], "help">, Flags<[CC1Option,CC1AsOption]>,
1655 HelpText<"Display available options">;
1656 def index_header_map : Flag<["-"], "index-header-map">, Flags<[CC1Option]>,
1657 HelpText<"Make the next included directory (-I or -F) an indexer header map">;
1658 def idirafter : JoinedOrSeparate<["-"], "idirafter">, Group<clang_i_Group>, Flags<[CC1Option]>,
1659 HelpText<"Add directory to AFTER include search path">;
1660 def iframework : JoinedOrSeparate<["-"], "iframework">, Group<clang_i_Group>, Flags<[CC1Option]>,
1661 HelpText<"Add directory to SYSTEM framework search path">;
1662 def iframeworkwithsysroot : JoinedOrSeparate<["-"], "iframeworkwithsysroot">,
1663 Group<clang_i_Group>,
1664 HelpText<"Add directory to SYSTEM framework search path, "
1665 "absolute paths are relative to -isysroot">,
1666 MetaVarName<"<directory>">, Flags<[CC1Option]>;
1667 def imacros : JoinedOrSeparate<["-", "--"], "imacros">, Group<clang_i_Group>, Flags<[CC1Option]>,
1668 HelpText<"Include macros from file before parsing">, MetaVarName<"<file>">;
1669 def image__base : Separate<["-"], "image_base">;
1670 def include_ : JoinedOrSeparate<["-", "--"], "include">, Group<clang_i_Group>, EnumName<"include">,
1671 MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>;
1672 def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>,
1673 HelpText<"Include precompiled header file">, MetaVarName<"<file>">;
1674 def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>,
1675 HelpText<"Whether to build a relocatable precompiled header">;
1676 def verify_pch : Flag<["-"], "verify-pch">, Group<Action_Group>, Flags<[CC1Option]>,
1677 HelpText<"Load and verify that a pre-compiled header file is not stale">;
1678 def init : Separate<["-"], "init">;
1679 def install__name : Separate<["-"], "install_name">;
1680 def iprefix : JoinedOrSeparate<["-"], "iprefix">, Group<clang_i_Group>, Flags<[CC1Option]>,
1681 HelpText<"Set the -iwithprefix/-iwithprefixbefore prefix">, MetaVarName<"<dir>">;
1682 def iquote : JoinedOrSeparate<["-"], "iquote">, Group<clang_i_Group>, Flags<[CC1Option]>,
1683 HelpText<"Add directory to QUOTE include search path">, MetaVarName<"<directory>">;
1684 def isysroot : JoinedOrSeparate<["-"], "isysroot">, Group<clang_i_Group>, Flags<[CC1Option]>,
1685 HelpText<"Set the system root directory (usually /)">, MetaVarName<"<dir>">;
1686 def isystem : JoinedOrSeparate<["-"], "isystem">, Group<clang_i_Group>,
1688 HelpText<"Add directory to SYSTEM include search path">, MetaVarName<"<directory>">;
1689 def isystem_after : JoinedOrSeparate<["-"], "isystem-after">,
1690 Group<clang_i_Group>, Flags<[DriverOption]>, MetaVarName<"<directory>">,
1691 HelpText<"Add directory to end of the SYSTEM include search path">;
1692 def iwithprefixbefore : JoinedOrSeparate<["-"], "iwithprefixbefore">, Group<clang_i_Group>,
1693 HelpText<"Set directory to include search path with prefix">, MetaVarName<"<dir>">,
1695 def iwithprefix : JoinedOrSeparate<["-"], "iwithprefix">, Group<clang_i_Group>, Flags<[CC1Option]>,
1696 HelpText<"Set directory to SYSTEM include search path with prefix">, MetaVarName<"<dir>">;
1697 def iwithsysroot : JoinedOrSeparate<["-"], "iwithsysroot">, Group<clang_i_Group>,
1698 HelpText<"Add directory to SYSTEM include search path, "
1699 "absolute paths are relative to -isysroot">, MetaVarName<"<directory>">,
1701 def ivfsoverlay : JoinedOrSeparate<["-"], "ivfsoverlay">, Group<clang_i_Group>, Flags<[CC1Option]>,
1702 HelpText<"Overlay the virtual filesystem described by file over the real file system">;
1703 def i : Joined<["-"], "i">, Group<i_Group>;
1704 def keep__private__externs : Flag<["-"], "keep_private_externs">;
1705 def l : JoinedOrSeparate<["-"], "l">, Flags<[LinkerInput, RenderJoined]>,
1707 def lazy__framework : Separate<["-"], "lazy_framework">, Flags<[LinkerInput]>;
1708 def lazy__library : Separate<["-"], "lazy_library">, Flags<[LinkerInput]>;
1709 def mlittle_endian : Flag<["-"], "mlittle-endian">, Flags<[DriverOption]>;
1710 def EL : Flag<["-"], "EL">, Alias<mlittle_endian>;
1711 def mbig_endian : Flag<["-"], "mbig-endian">, Flags<[DriverOption]>;
1712 def EB : Flag<["-"], "EB">, Alias<mbig_endian>;
1713 def m16 : Flag<["-"], "m16">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
1714 def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
1715 def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
1716 HelpText<"Enable hexagon-qdsp6 backward compatibility">;
1717 def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
1718 def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
1719 def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
1720 def miamcu : Flag<["-"], "miamcu">, Group<m_Group>, Flags<[DriverOption, CoreOption]>,
1721 HelpText<"Use Intel MCU ABI">;
1722 def mno_iamcu : Flag<["-"], "mno-iamcu">, Group<m_Group>, Flags<[DriverOption, CoreOption]>;
1723 def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>;
1724 def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>;
1725 def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>;
1726 def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Group>;
1727 def mlong_calls : Flag<["-"], "mlong-calls">, Group<m_Group>,
1728 HelpText<"Generate branches with extended addressability, usually via indirect jumps.">;
1729 def mno_long_calls : Flag<["-"], "mno-long-calls">, Group<m_Group>,
1730 HelpText<"Restore the default behaviour of not generating long calls">;
1731 def mexecute_only : Flag<["-"], "mexecute-only">, Group<m_arm_Features_Group>,
1732 HelpText<"Disallow generation of data access to code sections (ARM only)">;
1733 def mno_execute_only : Flag<["-"], "mno-execute-only">, Group<m_arm_Features_Group>,
1734 HelpText<"Allow generation of data access to code sections (ARM only)">;
1735 def mtp_mode_EQ : Joined<["-"], "mtp=">, Group<m_arm_Features_Group>, Values<"soft, cp15">,
1736 HelpText<"Read thread pointer from coprocessor register (ARM only)">;
1737 def mpure_code : Flag<["-"], "mpure-code">, Alias<mexecute_only>; // Alias for GCC compatibility
1738 def mno_pure_code : Flag<["-"], "mno-pure-code">, Alias<mno_execute_only>;
1739 def mtvos_version_min_EQ : Joined<["-"], "mtvos-version-min=">, Group<m_Group>;
1740 def mappletvos_version_min_EQ : Joined<["-"], "mappletvos-version-min=">, Alias<mtvos_version_min_EQ>;
1741 def mtvos_simulator_version_min_EQ : Joined<["-"], "mtvos-simulator-version-min=">;
1742 def mappletvsimulator_version_min_EQ : Joined<["-"], "mappletvsimulator-version-min=">, Alias<mtvos_simulator_version_min_EQ>;
1743 def mwatchos_version_min_EQ : Joined<["-"], "mwatchos-version-min=">, Group<m_Group>;
1744 def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">;
1745 def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias<mwatchos_simulator_version_min_EQ>;
1746 def march_EQ : Joined<["-"], "march=">, Group<m_Group>;
1747 def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[DriverOption]>;
1748 def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>;
1749 def mimplicit_it_EQ : Joined<["-"], "mimplicit-it=">, Group<m_Group>;
1750 def mdefault_build_attributes : Joined<["-"], "mdefault-build-attributes">, Group<m_Group>;
1751 def mno_default_build_attributes : Joined<["-"], "mno-default-build-attributes">, Group<m_Group>;
1752 def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>;
1753 def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[DriverOption]>;
1754 def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[DriverOption]>;
1755 def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[DriverOption]>;
1756 def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[DriverOption]>;
1757 def mthreads : Joined<["-"], "mthreads">, Group<m_Group>, Flags<[DriverOption]>;
1758 def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>;
1759 def mmcu_EQ : Joined<["-"], "mmcu=">, Group<m_Group>;
1760 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
1761 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
1762 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
1763 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
1764 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
1765 def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>,
1766 HelpText<"Align doubles to two words in structs (x86 only)">;
1767 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">;
1768 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
1769 def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
1770 def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>;
1771 def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>, Flags<[CC1Option]>,
1772 HelpText<"Enable merging of globals">;
1773 def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>;
1774 def miphoneos_version_min_EQ : Joined<["-"], "miphoneos-version-min=">, Group<m_Group>;
1775 def mios_version_min_EQ : Joined<["-"], "mios-version-min=">,
1776 Alias<miphoneos_version_min_EQ>, HelpText<"Set iOS deployment target">;
1777 def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">;
1778 def miphonesimulator_version_min_EQ : Joined<["-"], "miphonesimulator-version-min=">, Alias<mios_simulator_version_min_EQ>;
1779 def mkernel : Flag<["-"], "mkernel">, Group<m_Group>;
1780 def mlinker_version_EQ : Joined<["-"], "mlinker-version=">,
1781 Flags<[DriverOption]>;
1782 def mllvm : Separate<["-"], "mllvm">, Flags<[CC1Option,CC1AsOption,CoreOption]>,
1783 HelpText<"Additional arguments to forward to LLVM's option processing">;
1784 def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">,
1785 Group<m_Group>, HelpText<"Set Mac OS X deployment target">;
1786 def mmacos_version_min_EQ : Joined<["-"], "mmacos-version-min=">,
1787 Group<m_Group>, Alias<mmacosx_version_min_EQ>;
1788 def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>,
1789 HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">;
1790 def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>,
1791 HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">;
1792 def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>,
1793 HelpText<"Force realign the stack at entry to every function">;
1794 def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>,
1795 HelpText<"Set the stack alignment">;
1796 def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>,
1797 HelpText<"Set the stack probe size">;
1798 def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,
1799 HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">;
1800 def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>,
1801 HelpText<"Set EABI type, e.g. 4, 5 or gnu (default depends on triple)">, Values<"default,4,5,gnu">;
1803 def mno_constant_cfstrings : Flag<["-"], "mno-constant-cfstrings">, Group<m_Group>;
1804 def mno_global_merge : Flag<["-"], "mno-global-merge">, Group<m_Group>, Flags<[CC1Option]>,
1805 HelpText<"Disable merging of globals">;
1806 def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">,
1807 Alias<fno_pascal_strings>;
1808 def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>;
1809 def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>;
1810 def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>;
1811 def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>;
1812 def mno_stackrealign : Flag<["-"], "mno-stackrealign">, Group<m_Group>;
1814 def munaligned_access : Flag<["-"], "munaligned-access">, Group<m_arm_Features_Group>,
1815 HelpText<"Allow memory accesses to be unaligned (AArch32/AArch64 only)">;
1816 def mno_unaligned_access : Flag<["-"], "mno-unaligned-access">, Group<m_arm_Features_Group>,
1817 HelpText<"Force all memory accesses to be aligned (AArch32/AArch64 only)">;
1818 def mstrict_align : Flag<["-"], "mstrict-align">, Alias<mno_unaligned_access>, Flags<[CC1Option,HelpHidden]>,
1819 HelpText<"Force all memory accesses to be aligned (same as mno-unaligned-access)">;
1820 def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_arm_Features_Group>;
1821 def mrestrict_it: Flag<["-"], "mrestrict-it">, Group<m_arm_Features_Group>,
1822 HelpText<"Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.">;
1823 def mno_restrict_it: Flag<["-"], "mno-restrict-it">, Group<m_arm_Features_Group>,
1824 HelpText<"Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode">;
1825 def marm : Flag<["-"], "marm">, Alias<mno_thumb>;
1826 def ffixed_r9 : Flag<["-"], "ffixed-r9">, Group<m_arm_Features_Group>,
1827 HelpText<"Reserve the r9 register (ARM only)">;
1828 def mno_movt : Flag<["-"], "mno-movt">, Group<m_arm_Features_Group>,
1829 HelpText<"Disallow use of movt/movw pairs (ARM only)">;
1830 def mcrc : Flag<["-"], "mcrc">, Group<m_arm_Features_Group>,
1831 HelpText<"Allow use of CRC instructions (ARM only)">;
1832 def mnocrc : Flag<["-"], "mnocrc">, Group<m_arm_Features_Group>,
1833 HelpText<"Disallow use of CRC instructions (ARM only)">;
1834 def mno_neg_immediates: Flag<["-"], "mno-neg-immediates">, Group<m_arm_Features_Group>,
1835 HelpText<"Disallow converting instructions with negative immediates to their negation or inversion.">;
1837 def mgeneral_regs_only : Flag<["-"], "mgeneral-regs-only">, Group<m_aarch64_Features_Group>,
1838 HelpText<"Generate code which only uses the general purpose registers (AArch64 only)">;
1839 def mfix_cortex_a53_835769 : Flag<["-"], "mfix-cortex-a53-835769">,
1840 Group<m_aarch64_Features_Group>,
1841 HelpText<"Workaround Cortex-A53 erratum 835769 (AArch64 only)">;
1842 def mno_fix_cortex_a53_835769 : Flag<["-"], "mno-fix-cortex-a53-835769">,
1843 Group<m_aarch64_Features_Group>,
1844 HelpText<"Don't workaround Cortex-A53 erratum 835769 (AArch64 only)">;
1845 def ffixed_x18 : Flag<["-"], "ffixed-x18">, Group<m_aarch64_Features_Group>,
1846 HelpText<"Reserve the x18 register (AArch64 only)">;
1848 def msimd128 : Flag<["-"], "msimd128">, Group<m_wasm_Features_Group>;
1849 def mno_simd128 : Flag<["-"], "mno-simd128">, Group<m_wasm_Features_Group>;
1850 def mnontrapping_fptoint : Flag<["-"], "mnontrapping-fptoint">, Group<m_wasm_Features_Group>;
1851 def mno_nontrapping_fptoint : Flag<["-"], "mno-nontrapping-fptoint">, Group<m_wasm_Features_Group>;
1853 def mamdgpu_debugger_abi : Joined<["-"], "mamdgpu-debugger-abi=">,
1854 Flags<[HelpHidden]>,
1856 HelpText<"Generate additional code for specified <version> of debugger ABI (AMDGPU only)">,
1857 MetaVarName<"<version>">;
1858 def mxnack : Flag<["-"], "mxnack">, Group<m_amdgpu_Features_Group>,
1859 HelpText<"Enable XNACK (AMDGPU only)">;
1860 def mno_xnack : Flag<["-"], "mno-xnack">, Group<m_amdgpu_Features_Group>,
1861 HelpText<"Disable XNACK (AMDGPU only)">;
1863 def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[DriverOption]>;
1864 def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[DriverOption]>;
1865 def maltivec : Flag<["-"], "maltivec">, Group<m_ppc_Features_Group>;
1866 def mno_altivec : Flag<["-"], "mno-altivec">, Group<m_ppc_Features_Group>;
1867 def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>;
1868 def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>;
1869 def mpower8_vector : Flag<["-"], "mpower8-vector">,
1870 Group<m_ppc_Features_Group>;
1871 def mno_power8_vector : Flag<["-"], "mno-power8-vector">,
1872 Group<m_ppc_Features_Group>;
1873 def mpower9_vector : Flag<["-"], "mpower9-vector">,
1874 Group<m_ppc_Features_Group>;
1875 def mno_power9_vector : Flag<["-"], "mno-power9-vector">,
1876 Group<m_ppc_Features_Group>;
1877 def mpower8_crypto : Flag<["-"], "mcrypto">,
1878 Group<m_ppc_Features_Group>;
1879 def mnopower8_crypto : Flag<["-"], "mno-crypto">,
1880 Group<m_ppc_Features_Group>;
1881 def mdirect_move : Flag<["-"], "mdirect-move">,
1882 Group<m_ppc_Features_Group>;
1883 def mnodirect_move : Flag<["-"], "mno-direct-move">,
1884 Group<m_ppc_Features_Group>;
1885 def mhtm : Flag<["-"], "mhtm">, Group<m_ppc_Features_Group>;
1886 def mno_htm : Flag<["-"], "mno-htm">, Group<m_ppc_Features_Group>;
1887 def mfprnd : Flag<["-"], "mfprnd">, Group<m_ppc_Features_Group>;
1888 def mno_fprnd : Flag<["-"], "mno-fprnd">, Group<m_ppc_Features_Group>;
1889 def mcmpb : Flag<["-"], "mcmpb">, Group<m_ppc_Features_Group>;
1890 def mno_cmpb : Flag<["-"], "mno-cmpb">, Group<m_ppc_Features_Group>;
1891 def misel : Flag<["-"], "misel">, Group<m_ppc_Features_Group>;
1892 def mno_isel : Flag<["-"], "mno-isel">, Group<m_ppc_Features_Group>;
1893 def mmfocrf : Flag<["-"], "mmfocrf">, Group<m_ppc_Features_Group>;
1894 def mmfcrf : Flag<["-"], "mmfcrf">, Alias<mmfocrf>;
1895 def mno_mfocrf : Flag<["-"], "mno-mfocrf">, Group<m_ppc_Features_Group>;
1896 def mno_mfcrf : Flag<["-"], "mno-mfcrf">, Alias<mno_mfocrf>;
1897 def mpopcntd : Flag<["-"], "mpopcntd">, Group<m_ppc_Features_Group>;
1898 def mno_popcntd : Flag<["-"], "mno-popcntd">, Group<m_ppc_Features_Group>;
1899 def mqpx : Flag<["-"], "mqpx">, Group<m_ppc_Features_Group>;
1900 def mno_qpx : Flag<["-"], "mno-qpx">, Group<m_ppc_Features_Group>;
1901 def mcrbits : Flag<["-"], "mcrbits">, Group<m_ppc_Features_Group>;
1902 def mno_crbits : Flag<["-"], "mno-crbits">, Group<m_ppc_Features_Group>;
1903 def minvariant_function_descriptors :
1904 Flag<["-"], "minvariant-function-descriptors">, Group<m_ppc_Features_Group>;
1905 def mno_invariant_function_descriptors :
1906 Flag<["-"], "mno-invariant-function-descriptors">,
1907 Group<m_ppc_Features_Group>;
1908 def mfloat128: Flag<["-"], "mfloat128">,
1909 Group<m_ppc_Features_Group>;
1910 def mno_float128 : Flag<["-"], "mno-float128">,
1911 Group<m_ppc_Features_Group>;
1912 def mlongcall: Flag<["-"], "mlongcall">,
1913 Group<m_ppc_Features_Group>;
1914 def mno_longcall : Flag<["-"], "mno-longcall">,
1915 Group<m_ppc_Features_Group>;
1917 def mvx : Flag<["-"], "mvx">, Group<m_Group>;
1918 def mno_vx : Flag<["-"], "mno-vx">, Group<m_Group>;
1920 def fzvector : Flag<["-"], "fzvector">, Group<f_Group>, Flags<[CC1Option]>,
1921 HelpText<"Enable System z vector language extension">;
1922 def fno_zvector : Flag<["-"], "fno-zvector">, Group<f_Group>,
1924 def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>;
1925 def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>;
1927 def mbackchain : Flag<["-"], "mbackchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
1928 HelpText<"Link stack frames through backchain on System Z">;
1929 def mno_backchain : Flag<["-"], "mno-backchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>;
1931 def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>;
1932 def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>;
1933 def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>,
1934 HelpText<"Omit frame pointer setup for leaf functions">, Flags<[CC1Option]>;
1935 def moslib_EQ : Joined<["-"], "moslib=">, Group<m_Group>;
1936 def mpascal_strings : Flag<["-"], "mpascal-strings">, Alias<fpascal_strings>;
1937 def mred_zone : Flag<["-"], "mred-zone">, Group<m_Group>;
1938 def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>;
1939 def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>,
1940 HelpText<"(integrated-as) Relax all machine instructions">;
1941 def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group<m_Group>,
1942 Flags<[CC1Option,CC1AsOption]>,
1943 HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">;
1944 def mno_incremental_linker_compatible : Flag<["-"], "mno-incremental-linker-compatible">, Group<m_Group>,
1945 HelpText<"(integrated-as) Emit an object file which cannot be used with an incremental linker">;
1946 def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>,
1947 HelpText<"Make StdCall calling convention the default">;
1948 def msmall_data_threshold_EQ : Joined <["-"], "msmall-data-threshold=">,
1949 Group<m_Group>, Alias<G>;
1950 def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>,
1951 HelpText<"Use software floating point">;
1952 def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>,
1953 HelpText<"Don't generate implicit floating point instructions">;
1954 def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>;
1955 def mrecip : Flag<["-"], "mrecip">, Group<m_Group>;
1956 def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>;
1957 def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>,
1958 HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">;
1959 def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>,
1961 HelpText<"Use copy relocations support for PIE builds">;
1962 def mno_pie_copy_relocations : Flag<["-"], "mno-pie-copy-relocations">, Group<m_Group>;
1963 def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86 only)">,
1964 Flags<[CC1Option]>, Group<m_Group>;
1965 def mips16 : Flag<["-"], "mips16">, Group<m_Group>;
1966 def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_Group>;
1967 def mmicromips : Flag<["-"], "mmicromips">, Group<m_Group>;
1968 def mno_micromips : Flag<["-"], "mno-micromips">, Group<m_Group>;
1969 def mxgot : Flag<["-"], "mxgot">, Group<m_Group>;
1970 def mno_xgot : Flag<["-"], "mno-xgot">, Group<m_Group>;
1971 def mldc1_sdc1 : Flag<["-"], "mldc1-sdc1">, Group<m_Group>;
1972 def mno_ldc1_sdc1 : Flag<["-"], "mno-ldc1-sdc1">, Group<m_Group>;
1973 def mcheck_zero_division : Flag<["-"], "mcheck-zero-division">, Group<m_Group>;
1974 def mno_check_zero_division : Flag<["-"], "mno-check-zero-division">,
1976 def mcompact_branches_EQ : Joined<["-"], "mcompact-branches=">, Group<m_Group>;
1977 def mbranch_likely : Flag<["-"], "mbranch-likely">, Group<m_Group>,
1979 def mno_branch_likely : Flag<["-"], "mno-branch-likely">, Group<m_Group>,
1981 def mdsp : Flag<["-"], "mdsp">, Group<m_Group>;
1982 def mno_dsp : Flag<["-"], "mno-dsp">, Group<m_Group>;
1983 def mdspr2 : Flag<["-"], "mdspr2">, Group<m_Group>;
1984 def mno_dspr2 : Flag<["-"], "mno-dspr2">, Group<m_Group>;
1985 def msingle_float : Flag<["-"], "msingle-float">, Group<m_Group>;
1986 def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_Group>;
1987 def mmadd4 : Flag<["-"], "mmadd4">, Group<m_Group>,
1988 HelpText<"Enable the generation of 4-operand madd.s, madd.d and related instructions.">;
1989 def mno_madd4 : Flag<["-"], "mno-madd4">, Group<m_Group>,
1990 HelpText<"Disable the generation of 4-operand madd.s, madd.d and related instructions.">;
1991 def mmsa : Flag<["-"], "mmsa">, Group<m_Group>,
1992 HelpText<"Enable MSA ASE (MIPS only)">;
1993 def mno_msa : Flag<["-"], "mno-msa">, Group<m_Group>,
1994 HelpText<"Disable MSA ASE (MIPS only)">;
1995 def mmt : Flag<["-"], "mmt">, Group<m_Group>,
1996 HelpText<"Enable MT ASE (MIPS only)">;
1997 def mno_mt : Flag<["-"], "mno-mt">, Group<m_Group>,
1998 HelpText<"Disable MT ASE (MIPS only)">;
1999 def mfp64 : Flag<["-"], "mfp64">, Group<m_Group>,
2000 HelpText<"Use 64-bit floating point registers (MIPS only)">;
2001 def mfp32 : Flag<["-"], "mfp32">, Group<m_Group>,
2002 HelpText<"Use 32-bit floating point registers (MIPS only)">;
2003 def mgpopt : Flag<["-"], "mgpopt">, Group<m_Group>,
2004 HelpText<"Use GP relative accesses for symbols known to be in a small"
2005 " data section (MIPS)">;
2006 def mno_gpopt : Flag<["-"], "mno-gpopt">, Group<m_Group>,
2007 HelpText<"Do not use GP relative accesses for symbols known to be in a small"
2008 " data section (MIPS)">;
2009 def mlocal_sdata : Flag<["-"], "mlocal-sdata">, Group<m_Group>,
2010 HelpText<"Extend the -G behaviour to object local data (MIPS)">;
2011 def mno_local_sdata : Flag<["-"], "mno-local-sdata">, Group<m_Group>,
2012 HelpText<"Do not extend the -G behaviour to object local data (MIPS)">;
2013 def mextern_sdata : Flag<["-"], "mextern-sdata">, Group<m_Group>,
2014 HelpText<"Assume that externally defined data is in the small data if it"
2015 " meets the -G <size> threshold (MIPS)">;
2016 def mno_extern_sdata : Flag<["-"], "mno-extern-sdata">, Group<m_Group>,
2017 HelpText<"Do not assume that externally defined data is in the small data if"
2018 " it meets the -G <size> threshold (MIPS)">;
2019 def membedded_data : Flag<["-"], "membedded-data">, Group<m_Group>,
2020 HelpText<"Place constants in the .rodata section instead of the .sdata "
2021 "section even if they meet the -G <size> threshold (MIPS)">;
2022 def mno_embedded_data : Flag<["-"], "mno-embedded-data">, Group<m_Group>,
2023 HelpText<"Do not place constants in the .rodata section instead of the "
2024 ".sdata if they meet the -G <size> threshold (MIPS)">;
2025 def mnan_EQ : Joined<["-"], "mnan=">, Group<m_Group>;
2026 def mabs_EQ : Joined<["-"], "mabs=">, Group<m_Group>;
2027 def mabicalls : Flag<["-"], "mabicalls">, Group<m_Group>,
2028 HelpText<"Enable SVR4-style position-independent code (Mips only)">;
2029 def mno_abicalls : Flag<["-"], "mno-abicalls">, Group<m_Group>,
2030 HelpText<"Disable SVR4-style position-independent code (Mips only)">;
2031 def mips1 : Flag<["-"], "mips1">,
2032 Alias<march_EQ>, AliasArgs<["mips1"]>,
2033 HelpText<"Equivalent to -march=mips1">, Flags<[HelpHidden]>;
2034 def mips2 : Flag<["-"], "mips2">,
2035 Alias<march_EQ>, AliasArgs<["mips2"]>,
2036 HelpText<"Equivalent to -march=mips2">, Flags<[HelpHidden]>;
2037 def mips3 : Flag<["-"], "mips3">,
2038 Alias<march_EQ>, AliasArgs<["mips3"]>,
2039 HelpText<"Equivalent to -march=mips3">, Flags<[HelpHidden]>;
2040 def mips4 : Flag<["-"], "mips4">,
2041 Alias<march_EQ>, AliasArgs<["mips4"]>,
2042 HelpText<"Equivalent to -march=mips4">, Flags<[HelpHidden]>;
2043 def mips5 : Flag<["-"], "mips5">,
2044 Alias<march_EQ>, AliasArgs<["mips5"]>,
2045 HelpText<"Equivalent to -march=mips5">, Flags<[HelpHidden]>;
2046 def mips32 : Flag<["-"], "mips32">,
2047 Alias<march_EQ>, AliasArgs<["mips32"]>,
2048 HelpText<"Equivalent to -march=mips32">, Flags<[HelpHidden]>;
2049 def mips32r2 : Flag<["-"], "mips32r2">,
2050 Alias<march_EQ>, AliasArgs<["mips32r2"]>,
2051 HelpText<"Equivalent to -march=mips32r2">, Flags<[HelpHidden]>;
2052 def mips32r3 : Flag<["-"], "mips32r3">,
2053 Alias<march_EQ>, AliasArgs<["mips32r3"]>,
2054 HelpText<"Equivalent to -march=mips32r3">, Flags<[HelpHidden]>;
2055 def mips32r5 : Flag<["-"], "mips32r5">,
2056 Alias<march_EQ>, AliasArgs<["mips32r5"]>,
2057 HelpText<"Equivalent to -march=mips32r5">, Flags<[HelpHidden]>;
2058 def mips32r6 : Flag<["-"], "mips32r6">,
2059 Alias<march_EQ>, AliasArgs<["mips32r6"]>,
2060 HelpText<"Equivalent to -march=mips32r6">, Flags<[HelpHidden]>;
2061 def mips64 : Flag<["-"], "mips64">,
2062 Alias<march_EQ>, AliasArgs<["mips64"]>,
2063 HelpText<"Equivalent to -march=mips64">, Flags<[HelpHidden]>;
2064 def mips64r2 : Flag<["-"], "mips64r2">,
2065 Alias<march_EQ>, AliasArgs<["mips64r2"]>,
2066 HelpText<"Equivalent to -march=mips64r2">, Flags<[HelpHidden]>;
2067 def mips64r3 : Flag<["-"], "mips64r3">,
2068 Alias<march_EQ>, AliasArgs<["mips64r3"]>,
2069 HelpText<"Equivalent to -march=mips64r3">, Flags<[HelpHidden]>;
2070 def mips64r5 : Flag<["-"], "mips64r5">,
2071 Alias<march_EQ>, AliasArgs<["mips64r5"]>,
2072 HelpText<"Equivalent to -march=mips64r5">, Flags<[HelpHidden]>;
2073 def mips64r6 : Flag<["-"], "mips64r6">,
2074 Alias<march_EQ>, AliasArgs<["mips64r6"]>,
2075 HelpText<"Equivalent to -march=mips64r6">, Flags<[HelpHidden]>;
2076 def mfpxx : Flag<["-"], "mfpxx">, Group<m_Group>,
2077 HelpText<"Avoid FPU mode dependent operations when used with the O32 ABI">,
2078 Flags<[HelpHidden]>;
2079 def modd_spreg : Flag<["-"], "modd-spreg">, Group<m_Group>,
2080 HelpText<"Enable odd single-precision floating point registers">,
2081 Flags<[HelpHidden]>;
2082 def mno_odd_spreg : Flag<["-"], "mno-odd-spreg">, Group<m_Group>,
2083 HelpText<"Disable odd single-precision floating point registers">,
2084 Flags<[HelpHidden]>;
2085 def mglibc : Flag<["-"], "mglibc">, Group<m_libc_Group>, Flags<[HelpHidden]>;
2086 def muclibc : Flag<["-"], "muclibc">, Group<m_libc_Group>, Flags<[HelpHidden]>;
2087 def module_file_info : Flag<["-"], "module-file-info">, Flags<[DriverOption,CC1Option]>, Group<Action_Group>,
2088 HelpText<"Provide information about a particular module file">;
2089 def mthumb : Flag<["-"], "mthumb">, Group<m_Group>;
2090 def mtune_EQ : Joined<["-"], "mtune=">, Group<m_Group>;
2091 def multi__module : Flag<["-"], "multi_module">;
2092 def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
2093 def multiply__defined : Separate<["-"], "multiply_defined">;
2094 def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
2095 def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden]>,
2096 HelpText<"Use relative instead of canonical paths">;
2097 def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
2098 def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
2099 def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
2100 def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
2101 def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>,
2102 HelpText<"Disable builtin #include directories">;
2103 def nocudainc : Flag<["-"], "nocudainc">;
2104 def nocudalib : Flag<["-"], "nocudalib">;
2105 def nodefaultlibs : Flag<["-"], "nodefaultlibs">;
2106 def nofixprebinding : Flag<["-"], "nofixprebinding">;
2107 def nolibc : Flag<["-"], "nolibc">;
2108 def nomultidefs : Flag<["-"], "nomultidefs">;
2109 def nopie : Flag<["-"], "nopie">;
2110 def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
2111 def noprebind : Flag<["-"], "noprebind">;
2112 def noseglinkedit : Flag<["-"], "noseglinkedit">;
2113 def nostartfiles : Flag<["-"], "nostartfiles">;
2114 def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
2115 def nostdlibinc : Flag<["-"], "nostdlibinc">;
2116 def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
2117 HelpText<"Disable standard #include directories for the C++ standard library">;
2118 def nostdlib : Flag<["-"], "nostdlib">;
2119 def nostdlibxx : Flag<["-"], "nostdlib++">;
2120 def object : Flag<["-"], "object">;
2121 def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
2122 HelpText<"Write output to <file>">, MetaVarName<"<file>">;
2123 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
2124 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
2125 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>;
2126 def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>;
2127 def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
2128 def pipe : Flag<["-", "--"], "pipe">,
2129 HelpText<"Use pipes between commands, when possible">;
2130 def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
2131 def prebind : Flag<["-"], "prebind">;
2132 def preload : Flag<["-"], "preload">;
2133 def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
2134 HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;
2135 def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>,
2136 HelpText<"Enable Objective-C Ivar layout bitmap print trace">;
2137 def print_libgcc_file_name : Flag<["-", "--"], "print-libgcc-file-name">,
2138 HelpText<"Print the library path for the currently used compiler runtime "
2139 "library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")">;
2140 def print_multi_directory : Flag<["-", "--"], "print-multi-directory">;
2141 def print_multi_lib : Flag<["-", "--"], "print-multi-lib">;
2142 def print_multi_os_directory : Flag<["-", "--"], "print-multi-os-directory">,
2143 Flags<[Unsupported]>;
2144 def print_prog_name_EQ : Joined<["-", "--"], "print-prog-name=">,
2145 HelpText<"Print the full program path of <name>">, MetaVarName<"<name>">;
2146 def print_resource_dir : Flag<["-", "--"], "print-resource-dir">,
2147 HelpText<"Print the resource directory pathname">;
2148 def print_search_dirs : Flag<["-", "--"], "print-search-dirs">,
2149 HelpText<"Print the paths used for finding libraries and programs">;
2150 def private__bundle : Flag<["-"], "private_bundle">;
2151 def pthreads : Flag<["-"], "pthreads">;
2152 def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>,
2153 HelpText<"Support POSIX threads in generated code">;
2154 def no_pthread : Flag<["-"], "no-pthread">, Flags<[CC1Option]>;
2155 def p : Flag<["-"], "p">;
2156 def pie : Flag<["-"], "pie">;
2157 def read__only__relocs : Separate<["-"], "read_only_relocs">;
2158 def remap : Flag<["-"], "remap">;
2159 def rewrite_objc : Flag<["-"], "rewrite-objc">, Flags<[DriverOption,CC1Option]>,
2160 HelpText<"Rewrite Objective-C source to C++">, Group<Action_Group>;
2161 def rewrite_legacy_objc : Flag<["-"], "rewrite-legacy-objc">, Flags<[DriverOption]>,
2162 HelpText<"Rewrite Legacy Objective-C source to C++">;
2163 def rdynamic : Flag<["-"], "rdynamic">;
2164 def resource_dir : Separate<["-"], "resource-dir">,
2165 Flags<[DriverOption, CC1Option, CoreOption, HelpHidden]>,
2166 HelpText<"The directory which holds the compiler resource files">;
2167 def resource_dir_EQ : Joined<["-"], "resource-dir=">, Flags<[DriverOption, CoreOption]>,
2168 Alias<resource_dir>;
2169 def rpath : Separate<["-"], "rpath">, Flags<[LinkerInput]>, Group<Link_Group>;
2170 def rtlib_EQ : Joined<["-", "--"], "rtlib=">,
2171 HelpText<"Compiler runtime library to use">;
2172 def frtlib_add_rpath: Flag<["-"], "frtlib-add-rpath">, Flags<[NoArgumentUnused]>,
2173 HelpText<"Add -rpath with architecture-specific resource directory to the linker flags">;
2174 def fno_rtlib_add_rpath: Flag<["-"], "fno-rtlib-add-rpath">, Flags<[NoArgumentUnused]>,
2175 HelpText<"Do not add -rpath with architecture-specific resource directory to the linker flags">;
2176 def r : Flag<["-"], "r">, Flags<[LinkerInput,NoArgumentUnused]>,
2178 def save_temps_EQ : Joined<["-", "--"], "save-temps=">, Flags<[DriverOption]>,
2179 HelpText<"Save intermediate compilation results.">;
2180 def save_temps : Flag<["-", "--"], "save-temps">, Flags<[DriverOption]>,
2181 Alias<save_temps_EQ>, AliasArgs<["cwd"]>,
2182 HelpText<"Save intermediate compilation results">;
2183 def save_stats_EQ : Joined<["-", "--"], "save-stats=">, Flags<[DriverOption]>,
2184 HelpText<"Save llvm statistics.">;
2185 def save_stats : Flag<["-", "--"], "save-stats">, Flags<[DriverOption]>,
2186 Alias<save_stats_EQ>, AliasArgs<["cwd"]>,
2187 HelpText<"Save llvm statistics.">;
2188 def via_file_asm : Flag<["-", "--"], "via-file-asm">, InternalDebugOpt,
2189 HelpText<"Write assembly to file for input to assemble jobs">;
2190 def sectalign : MultiArg<["-"], "sectalign", 3>;
2191 def sectcreate : MultiArg<["-"], "sectcreate", 3>;
2192 def sectobjectsymbols : MultiArg<["-"], "sectobjectsymbols", 2>;
2193 def sectorder : MultiArg<["-"], "sectorder", 3>;
2194 def seg1addr : JoinedOrSeparate<["-"], "seg1addr">;
2195 def seg__addr__table__filename : Separate<["-"], "seg_addr_table_filename">;
2196 def seg__addr__table : Separate<["-"], "seg_addr_table">;
2197 def segaddr : MultiArg<["-"], "segaddr", 2>;
2198 def segcreate : MultiArg<["-"], "segcreate", 3>;
2199 def seglinkedit : Flag<["-"], "seglinkedit">;
2200 def segprot : MultiArg<["-"], "segprot", 3>;
2201 def segs__read__only__addr : Separate<["-"], "segs_read_only_addr">;
2202 def segs__read__write__addr : Separate<["-"], "segs_read_write_addr">;
2203 def segs__read__ : Joined<["-"], "segs_read_">;
2204 def shared_libgcc : Flag<["-"], "shared-libgcc">;
2205 def shared : Flag<["-", "--"], "shared">;
2206 def single__module : Flag<["-"], "single_module">;
2207 def specs_EQ : Joined<["-", "--"], "specs=">;
2208 def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
2209 def static_libgcc : Flag<["-"], "static-libgcc">;
2210 def static_libstdcxx : Flag<["-"], "static-libstdc++">;
2211 def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
2212 def std_default_EQ : Joined<["-"], "std-default=">;
2213 def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
2214 Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
2216 const char *Values =
2217 #define LANGSTANDARD(id, name, lang, desc, features) name ","
2218 #define LANGSTANDARD_ALIAS(id, alias) alias ","
2219 #include "clang/Frontend/LangStandards.def"
2222 def stdlib_EQ : Joined<["-", "--"], "stdlib=">, Flags<[CC1Option]>,
2223 HelpText<"C++ standard library to use">, Values<"libc++,libstdc++,platform">;
2224 def sub__library : JoinedOrSeparate<["-"], "sub_library">;
2225 def sub__umbrella : JoinedOrSeparate<["-"], "sub_umbrella">;
2226 def system_header_prefix : Joined<["--"], "system-header-prefix=">,
2227 Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
2228 HelpText<"Treat all #include paths starting with <prefix> as including a "
2230 def : Separate<["--"], "system-header-prefix">, Alias<system_header_prefix>;
2231 def no_system_header_prefix : Joined<["--"], "no-system-header-prefix=">,
2232 Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
2233 HelpText<"Treat all #include paths starting with <prefix> as not including a "
2235 def : Separate<["--"], "no-system-header-prefix">, Alias<no_system_header_prefix>;
2236 def s : Flag<["-"], "s">, Group<Link_Group>;
2237 def target : Joined<["--"], "target=">, Flags<[DriverOption, CoreOption]>,
2238 HelpText<"Generate code for the given target">;
2239 def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[DriverOption]>,
2240 HelpText<"Use the gcc toolchain at the given directory">;
2241 def time : Flag<["-"], "time">,
2242 HelpText<"Time individual commands">;
2243 def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>,
2244 HelpText<"Enable some traditional CPP emulation">;
2245 def traditional : Flag<["-", "--"], "traditional">;
2246 def trigraphs : Flag<["-", "--"], "trigraphs">, Alias<ftrigraphs>,
2247 HelpText<"Process trigraph sequences">;
2248 def twolevel__namespace__hints : Flag<["-"], "twolevel_namespace_hints">;
2249 def twolevel__namespace : Flag<["-"], "twolevel_namespace">;
2250 def t : Flag<["-"], "t">, Group<Link_Group>;
2251 def umbrella : Separate<["-"], "umbrella">;
2252 def undefined : JoinedOrSeparate<["-"], "undefined">, Group<u_Group>;
2253 def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>,
2254 HelpText<"undef all system defines">;
2255 def unexported__symbols__list : Separate<["-"], "unexported_symbols_list">;
2256 def u : JoinedOrSeparate<["-"], "u">, Group<u_Group>;
2257 def v : Flag<["-"], "v">, Flags<[CC1Option, CoreOption]>,
2258 HelpText<"Show commands to run and use verbose output">;
2259 def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[DriverOption]>,
2260 HelpText<"Verify the binary representation of debug output">;
2261 def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>;
2262 def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>;
2263 def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>;
2264 def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">;
2265 def whatsloaded : Flag<["-"], "whatsloaded">;
2266 def whyload : Flag<["-"], "whyload">;
2267 def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>;
2268 def x : JoinedOrSeparate<["-"], "x">, Flags<[DriverOption,CC1Option]>,
2269 HelpText<"Treat subsequent input files as having type <language>">,
2270 MetaVarName<"<language>">;
2271 def y : Joined<["-"], "y">;
2273 def fintegrated_as : Flag<["-"], "fintegrated-as">, Flags<[DriverOption]>,
2274 Group<f_Group>, HelpText<"Enable the integrated assembler">;
2275 def fno_integrated_as : Flag<["-"], "fno-integrated-as">,
2276 Flags<[CC1Option, DriverOption]>, Group<f_Group>,
2277 HelpText<"Disable the integrated assembler">;
2278 def : Flag<["-"], "integrated-as">, Alias<fintegrated_as>, Flags<[DriverOption]>;
2279 def : Flag<["-"], "no-integrated-as">, Alias<fno_integrated_as>,
2280 Flags<[CC1Option, DriverOption]>;
2282 def working_directory : JoinedOrSeparate<["-"], "working-directory">, Flags<[CC1Option]>,
2283 HelpText<"Resolve file paths relative to the specified directory">;
2284 def working_directory_EQ : Joined<["-"], "working-directory=">, Flags<[CC1Option]>,
2285 Alias<working_directory>;
2287 // Double dash options, which are usually an alias for one of the previous
2290 def _mhwdiv_EQ : Joined<["--"], "mhwdiv=">, Alias<mhwdiv_EQ>;
2291 def _mhwdiv : Separate<["--"], "mhwdiv">, Alias<mhwdiv_EQ>;
2292 def _CLASSPATH_EQ : Joined<["--"], "CLASSPATH=">, Alias<fclasspath_EQ>;
2293 def _CLASSPATH : Separate<["--"], "CLASSPATH">, Alias<fclasspath_EQ>;
2294 def _all_warnings : Flag<["--"], "all-warnings">, Alias<Wall>;
2295 def _analyze_auto : Flag<["--"], "analyze-auto">, Flags<[DriverOption]>;
2296 def _analyzer_no_default_checks : Flag<["--"], "analyzer-no-default-checks">, Flags<[DriverOption]>;
2297 def _analyzer_output : JoinedOrSeparate<["--"], "analyzer-output">, Flags<[DriverOption]>,
2298 HelpText<"Static analyzer report output format (html|plist|plist-multi-file|plist-html|text).">;
2299 def _analyze : Flag<["--"], "analyze">, Flags<[DriverOption, CoreOption]>,
2300 HelpText<"Run the static analyzer">;
2301 def _assemble : Flag<["--"], "assemble">, Alias<S>;
2302 def _assert_EQ : Joined<["--"], "assert=">, Alias<A>;
2303 def _assert : Separate<["--"], "assert">, Alias<A>;
2304 def _bootclasspath_EQ : Joined<["--"], "bootclasspath=">, Alias<fbootclasspath_EQ>;
2305 def _bootclasspath : Separate<["--"], "bootclasspath">, Alias<fbootclasspath_EQ>;
2306 def _classpath_EQ : Joined<["--"], "classpath=">, Alias<fclasspath_EQ>;
2307 def _classpath : Separate<["--"], "classpath">, Alias<fclasspath_EQ>;
2308 def _comments_in_macros : Flag<["--"], "comments-in-macros">, Alias<CC>;
2309 def _comments : Flag<["--"], "comments">, Alias<C>;
2310 def _compile : Flag<["--"], "compile">, Alias<c>;
2311 def _constant_cfstrings : Flag<["--"], "constant-cfstrings">;
2312 def _debug_EQ : Joined<["--"], "debug=">, Alias<g_Flag>;
2313 def _debug : Flag<["--"], "debug">, Alias<g_Flag>;
2314 def _define_macro_EQ : Joined<["--"], "define-macro=">, Alias<D>;
2315 def _define_macro : Separate<["--"], "define-macro">, Alias<D>;
2316 def _dependencies : Flag<["--"], "dependencies">, Alias<M>;
2317 def _dyld_prefix_EQ : Joined<["--"], "dyld-prefix=">;
2318 def _dyld_prefix : Separate<["--"], "dyld-prefix">, Alias<_dyld_prefix_EQ>;
2319 def _encoding_EQ : Joined<["--"], "encoding=">, Alias<fencoding_EQ>;
2320 def _encoding : Separate<["--"], "encoding">, Alias<fencoding_EQ>;
2321 def _entry : Flag<["--"], "entry">, Alias<e>;
2322 def _extdirs_EQ : Joined<["--"], "extdirs=">, Alias<fextdirs_EQ>;
2323 def _extdirs : Separate<["--"], "extdirs">, Alias<fextdirs_EQ>;
2324 def _extra_warnings : Flag<["--"], "extra-warnings">, Alias<W_Joined>;
2325 def _for_linker_EQ : Joined<["--"], "for-linker=">, Alias<Xlinker>;
2326 def _for_linker : Separate<["--"], "for-linker">, Alias<Xlinker>;
2327 def _force_link_EQ : Joined<["--"], "force-link=">, Alias<u>;
2328 def _force_link : Separate<["--"], "force-link">, Alias<u>;
2329 def _help_hidden : Flag<["--"], "help-hidden">;
2330 def _imacros_EQ : Joined<["--"], "imacros=">, Alias<imacros>;
2331 def _include_barrier : Flag<["--"], "include-barrier">, Alias<I_>;
2332 def _include_directory_after_EQ : Joined<["--"], "include-directory-after=">, Alias<idirafter>;
2333 def _include_directory_after : Separate<["--"], "include-directory-after">, Alias<idirafter>;
2334 def _include_directory_EQ : Joined<["--"], "include-directory=">, Alias<I>;
2335 def _include_directory : Separate<["--"], "include-directory">, Alias<I>;
2336 def _include_prefix_EQ : Joined<["--"], "include-prefix=">, Alias<iprefix>;
2337 def _include_prefix : Separate<["--"], "include-prefix">, Alias<iprefix>;
2338 def _include_with_prefix_after_EQ : Joined<["--"], "include-with-prefix-after=">, Alias<iwithprefix>;
2339 def _include_with_prefix_after : Separate<["--"], "include-with-prefix-after">, Alias<iwithprefix>;
2340 def _include_with_prefix_before_EQ : Joined<["--"], "include-with-prefix-before=">, Alias<iwithprefixbefore>;
2341 def _include_with_prefix_before : Separate<["--"], "include-with-prefix-before">, Alias<iwithprefixbefore>;
2342 def _include_with_prefix_EQ : Joined<["--"], "include-with-prefix=">, Alias<iwithprefix>;
2343 def _include_with_prefix : Separate<["--"], "include-with-prefix">, Alias<iwithprefix>;
2344 def _include_EQ : Joined<["--"], "include=">, Alias<include_>;
2345 def _language_EQ : Joined<["--"], "language=">, Alias<x>;
2346 def _language : Separate<["--"], "language">, Alias<x>;
2347 def _library_directory_EQ : Joined<["--"], "library-directory=">, Alias<L>;
2348 def _library_directory : Separate<["--"], "library-directory">, Alias<L>;
2349 def _no_line_commands : Flag<["--"], "no-line-commands">, Alias<P>;
2350 def _no_standard_includes : Flag<["--"], "no-standard-includes">, Alias<nostdinc>;
2351 def _no_standard_libraries : Flag<["--"], "no-standard-libraries">, Alias<nostdlib>;
2352 def _no_undefined : Flag<["--"], "no-undefined">, Flags<[LinkerInput]>;
2353 def _no_warnings : Flag<["--"], "no-warnings">, Alias<w>;
2354 def _optimize_EQ : Joined<["--"], "optimize=">, Alias<O>;
2355 def _optimize : Flag<["--"], "optimize">, Alias<O>;
2356 def _output_class_directory_EQ : Joined<["--"], "output-class-directory=">, Alias<foutput_class_dir_EQ>;
2357 def _output_class_directory : Separate<["--"], "output-class-directory">, Alias<foutput_class_dir_EQ>;
2358 def _output_EQ : Joined<["--"], "output=">, Alias<o>;
2359 def _output : Separate<["--"], "output">, Alias<o>;
2360 def _param : Separate<["--"], "param">, Group<CompileOnly_Group>;
2361 def _param_EQ : Joined<["--"], "param=">, Alias<_param>;
2362 def _precompile : Flag<["--"], "precompile">, Flags<[DriverOption]>,
2363 Group<Action_Group>, HelpText<"Only precompile the input">;
2364 def _prefix_EQ : Joined<["--"], "prefix=">, Alias<B>;
2365 def _prefix : Separate<["--"], "prefix">, Alias<B>;
2366 def _preprocess : Flag<["--"], "preprocess">, Alias<E>;
2367 def _print_diagnostic_categories : Flag<["--"], "print-diagnostic-categories">;
2368 def _print_file_name : Separate<["--"], "print-file-name">, Alias<print_file_name_EQ>;
2369 def _print_missing_file_dependencies : Flag<["--"], "print-missing-file-dependencies">, Alias<MG>;
2370 def _print_prog_name : Separate<["--"], "print-prog-name">, Alias<print_prog_name_EQ>;
2371 def _profile_blocks : Flag<["--"], "profile-blocks">, Alias<a>;
2372 def _profile : Flag<["--"], "profile">, Alias<p>;
2373 def _resource_EQ : Joined<["--"], "resource=">, Alias<fcompile_resource_EQ>;
2374 def _resource : Separate<["--"], "resource">, Alias<fcompile_resource_EQ>;
2375 def _rtlib : Separate<["--"], "rtlib">, Alias<rtlib_EQ>;
2376 def _serialize_diags : Separate<["-", "--"], "serialize-diagnostics">, Flags<[DriverOption]>,
2377 HelpText<"Serialize compiler diagnostics to a file">;
2378 // We give --version different semantics from -version.
2379 def _version : Flag<["--"], "version">, Flags<[CoreOption, CC1Option]>,
2380 HelpText<"Print version information">;
2381 def _signed_char : Flag<["--"], "signed-char">, Alias<fsigned_char>;
2382 def _std : Separate<["--"], "std">, Alias<std_EQ>;
2383 def _stdlib : Separate<["--"], "stdlib">, Alias<stdlib_EQ>;
2384 def _sysroot_EQ : Joined<["--"], "sysroot=">;
2385 def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>;
2386 def _target_help : Flag<["--"], "target-help">;
2387 def _trace_includes : Flag<["--"], "trace-includes">, Alias<H>;
2388 def _undefine_macro_EQ : Joined<["--"], "undefine-macro=">, Alias<U>;
2389 def _undefine_macro : Separate<["--"], "undefine-macro">, Alias<U>;
2390 def _unsigned_char : Flag<["--"], "unsigned-char">, Alias<funsigned_char>;
2391 def _user_dependencies : Flag<["--"], "user-dependencies">, Alias<MM>;
2392 def _verbose : Flag<["--"], "verbose">, Alias<v>;
2393 def _warn__EQ : Joined<["--"], "warn-=">, Alias<W_Joined>;
2394 def _warn_ : Joined<["--"], "warn-">, Alias<W_Joined>;
2395 def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>;
2396 def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>;
2397 def _ : Joined<["--"], "">, Flags<[Unsupported]>;
2399 def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">, Group<m_hexagon_Features_Group>;
2400 def mv4 : Flag<["-"], "mv4">, Group<m_hexagon_Features_Group>,
2401 Alias<mcpu_EQ>, AliasArgs<["hexagonv4"]>;
2402 def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<mcpu_EQ>,
2403 AliasArgs<["hexagonv5"]>;
2404 def mv55 : Flag<["-"], "mv55">, Group<m_hexagon_Features_Group>,
2405 Alias<mcpu_EQ>, AliasArgs<["hexagonv55"]>;
2406 def mv60 : Flag<["-"], "mv60">, Group<m_hexagon_Features_Group>,
2407 Alias<mcpu_EQ>, AliasArgs<["hexagonv60"]>;
2408 def mv62 : Flag<["-"], "mv62">, Group<m_hexagon_Features_Group>,
2409 Alias<mcpu_EQ>, AliasArgs<["hexagonv62"]>;
2410 def mv65 : Flag<["-"], "mv65">, Group<m_hexagon_Features_Group>,
2411 Alias<mcpu_EQ>, AliasArgs<["hexagonv65"]>;
2412 def mhexagon_hvx : Flag<[ "-" ], "mhvx">,
2413 Group<m_hexagon_Features_HVX_Group>,
2414 HelpText<"Enable Hexagon Vector eXtensions">;
2415 def mhexagon_hvx_EQ : Joined<[ "-" ], "mhvx=">,
2416 Group<m_hexagon_Features_HVX_Group>,
2417 HelpText<"Enable Hexagon Vector eXtensions">;
2418 def mno_hexagon_hvx : Flag<[ "-" ], "mno-hvx">,
2419 Group<m_hexagon_Features_HVX_Group>,
2420 HelpText<"Disable Hexagon Vector eXtensions">;
2421 def mhexagon_hvx_length_EQ : Joined<[ "-" ], "mhvx-length=">,
2422 Group<m_hexagon_Features_HVX_Group>,
2423 HelpText<"Set Hexagon Vector Length">, Values<"64B,128B">;
2424 // hvx-double deprecrated flag.
2425 def mhexagon_hvx_double : Flag<[ "-" ], "mhvx-double">,
2426 Group<m_hexagon_Features_HVX_Group>,
2427 HelpText<"Enable Hexagon Double Vector eXtensions">;
2428 def mno_hexagon_hvx_double
2429 : Flag<[ "-" ], "mno-hvx-double">,
2430 Group<m_hexagon_Features_HVX_Group>,
2431 HelpText<"Disable Hexagon Double Vector eXtensions">;
2434 // X86 feature flags
2435 def mx87 : Flag<["-"], "mx87">, Group<m_x86_Features_Group>;
2436 def mno_x87 : Flag<["-"], "mno-x87">, Group<m_x86_Features_Group>;
2437 def m80387 : Flag<["-"], "m80387">, Alias<mx87>;
2438 def mno_80387 : Flag<["-"], "mno-80387">, Alias<mno_x87>;
2439 def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>;
2440 def mno_mmx : Flag<["-"], "mno-mmx">, Group<m_x86_Features_Group>;
2441 def m3dnow : Flag<["-"], "m3dnow">, Group<m_x86_Features_Group>;
2442 def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>;
2443 def m3dnowa : Flag<["-"], "m3dnowa">, Group<m_x86_Features_Group>;
2444 def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>;
2445 def msse : Flag<["-"], "msse">, Group<m_x86_Features_Group>;
2446 def mno_sse : Flag<["-"], "mno-sse">, Group<m_x86_Features_Group>;
2447 def msse2 : Flag<["-"], "msse2">, Group<m_x86_Features_Group>;
2448 def mno_sse2 : Flag<["-"], "mno-sse2">, Group<m_x86_Features_Group>;
2449 def msse3 : Flag<["-"], "msse3">, Group<m_x86_Features_Group>;
2450 def mno_sse3 : Flag<["-"], "mno-sse3">, Group<m_x86_Features_Group>;
2451 def mssse3 : Flag<["-"], "mssse3">, Group<m_x86_Features_Group>;
2452 def mno_ssse3 : Flag<["-"], "mno-ssse3">, Group<m_x86_Features_Group>;
2453 def msse4_1 : Flag<["-"], "msse4.1">, Group<m_x86_Features_Group>;
2454 def mno_sse4_1 : Flag<["-"], "mno-sse4.1">, Group<m_x86_Features_Group>;
2455 def msse4_2 : Flag<["-"], "msse4.2">, Group<m_x86_Features_Group>;
2456 def mno_sse4_2 : Flag<["-"], "mno-sse4.2">, Group<m_x86_Features_Group>;
2457 def msse4 : Flag<["-"], "msse4">, Alias<msse4_2>;
2458 // -mno-sse4 turns off sse4.1 which has the effect of turning off everything
2459 // later than 4.1. -msse4 turns on 4.2 which has the effect of turning on
2460 // everything earlier than 4.2.
2461 def mno_sse4 : Flag<["-"], "mno-sse4">, Alias<mno_sse4_1>;
2462 def msse4a : Flag<["-"], "msse4a">, Group<m_x86_Features_Group>;
2463 def mno_sse4a : Flag<["-"], "mno-sse4a">, Group<m_x86_Features_Group>;
2464 def mavx : Flag<["-"], "mavx">, Group<m_x86_Features_Group>;
2465 def mno_avx : Flag<["-"], "mno-avx">, Group<m_x86_Features_Group>;
2466 def mavx2 : Flag<["-"], "mavx2">, Group<m_x86_Features_Group>;
2467 def mno_avx2 : Flag<["-"], "mno-avx2">, Group<m_x86_Features_Group>;
2468 def mavx512f : Flag<["-"], "mavx512f">, Group<m_x86_Features_Group>;
2469 def mno_avx512f : Flag<["-"], "mno-avx512f">, Group<m_x86_Features_Group>;
2470 def mavx512bitalg : Flag<["-"], "mavx512bitalg">, Group<m_x86_Features_Group>;
2471 def mno_avx512bitalg : Flag<["-"], "mno-avx512bitalg">, Group<m_x86_Features_Group>;
2472 def mavx512bw : Flag<["-"], "mavx512bw">, Group<m_x86_Features_Group>;
2473 def mno_avx512bw : Flag<["-"], "mno-avx512bw">, Group<m_x86_Features_Group>;
2474 def mavx512cd : Flag<["-"], "mavx512cd">, Group<m_x86_Features_Group>;
2475 def mno_avx512cd : Flag<["-"], "mno-avx512cd">, Group<m_x86_Features_Group>;
2476 def mavx512dq : Flag<["-"], "mavx512dq">, Group<m_x86_Features_Group>;
2477 def mno_avx512dq : Flag<["-"], "mno-avx512dq">, Group<m_x86_Features_Group>;
2478 def mavx512er : Flag<["-"], "mavx512er">, Group<m_x86_Features_Group>;
2479 def mno_avx512er : Flag<["-"], "mno-avx512er">, Group<m_x86_Features_Group>;
2480 def mavx512ifma : Flag<["-"], "mavx512ifma">, Group<m_x86_Features_Group>;
2481 def mno_avx512ifma : Flag<["-"], "mno-avx512ifma">, Group<m_x86_Features_Group>;
2482 def mavx512pf : Flag<["-"], "mavx512pf">, Group<m_x86_Features_Group>;
2483 def mno_avx512pf : Flag<["-"], "mno-avx512pf">, Group<m_x86_Features_Group>;
2484 def mavx512vbmi : Flag<["-"], "mavx512vbmi">, Group<m_x86_Features_Group>;
2485 def mno_avx512vbmi : Flag<["-"], "mno-avx512vbmi">, Group<m_x86_Features_Group>;
2486 def mavx512vbmi2 : Flag<["-"], "mavx512vbmi2">, Group<m_x86_Features_Group>;
2487 def mno_avx512vbmi2 : Flag<["-"], "mno-avx512vbmi2">, Group<m_x86_Features_Group>;
2488 def mavx512vl : Flag<["-"], "mavx512vl">, Group<m_x86_Features_Group>;
2489 def mno_avx512vl : Flag<["-"], "mno-avx512vl">, Group<m_x86_Features_Group>;
2490 def mavx512vnni : Flag<["-"], "mavx512vnni">, Group<m_x86_Features_Group>;
2491 def mno_avx512vnni : Flag<["-"], "mno-avx512vnni">, Group<m_x86_Features_Group>;
2492 def mavx512vpopcntdq : Flag<["-"], "mavx512vpopcntdq">, Group<m_x86_Features_Group>;
2493 def mno_avx512vpopcntdq : Flag<["-"], "mno-avx512vpopcntdq">, Group<m_x86_Features_Group>;
2494 def madx : Flag<["-"], "madx">, Group<m_x86_Features_Group>;
2495 def mno_adx : Flag<["-"], "mno-adx">, Group<m_x86_Features_Group>;
2496 def maes : Flag<["-"], "maes">, Group<m_x86_Features_Group>;
2497 def mno_aes : Flag<["-"], "mno-aes">, Group<m_x86_Features_Group>;
2498 def mbmi : Flag<["-"], "mbmi">, Group<m_x86_Features_Group>;
2499 def mno_bmi : Flag<["-"], "mno-bmi">, Group<m_x86_Features_Group>;
2500 def mbmi2 : Flag<["-"], "mbmi2">, Group<m_x86_Features_Group>;
2501 def mno_bmi2 : Flag<["-"], "mno-bmi2">, Group<m_x86_Features_Group>;
2502 def mclflushopt : Flag<["-"], "mclflushopt">, Group<m_x86_Features_Group>;
2503 def mno_clflushopt : Flag<["-"], "mno-clflushopt">, Group<m_x86_Features_Group>;
2504 def mclwb : Flag<["-"], "mclwb">, Group<m_x86_Features_Group>;
2505 def mno_clwb : Flag<["-"], "mno-clwb">, Group<m_x86_Features_Group>;
2506 def mclzero : Flag<["-"], "mclzero">, Group<m_x86_Features_Group>;
2507 def mno_clzero : Flag<["-"], "mno-clzero">, Group<m_x86_Features_Group>;
2508 def mcx16 : Flag<["-"], "mcx16">, Group<m_x86_Features_Group>;
2509 def mno_cx16 : Flag<["-"], "mno-cx16">, Group<m_x86_Features_Group>;
2510 def mf16c : Flag<["-"], "mf16c">, Group<m_x86_Features_Group>;
2511 def mno_f16c : Flag<["-"], "mno-f16c">, Group<m_x86_Features_Group>;
2512 def mfma : Flag<["-"], "mfma">, Group<m_x86_Features_Group>;
2513 def mno_fma : Flag<["-"], "mno-fma">, Group<m_x86_Features_Group>;
2514 def mfma4 : Flag<["-"], "mfma4">, Group<m_x86_Features_Group>;
2515 def mno_fma4 : Flag<["-"], "mno-fma4">, Group<m_x86_Features_Group>;
2516 def mfsgsbase : Flag<["-"], "mfsgsbase">, Group<m_x86_Features_Group>;
2517 def mno_fsgsbase : Flag<["-"], "mno-fsgsbase">, Group<m_x86_Features_Group>;
2518 def mfxsr : Flag<["-"], "mfxsr">, Group<m_x86_Features_Group>;
2519 def mno_fxsr : Flag<["-"], "mno-fxsr">, Group<m_x86_Features_Group>;
2520 def mgfni : Flag<["-"], "mgfni">, Group<m_x86_Features_Group>;
2521 def mno_gfni : Flag<["-"], "mno-gfni">, Group<m_x86_Features_Group>;
2522 def mlwp : Flag<["-"], "mlwp">, Group<m_x86_Features_Group>;
2523 def mno_lwp : Flag<["-"], "mno-lwp">, Group<m_x86_Features_Group>;
2524 def mlzcnt : Flag<["-"], "mlzcnt">, Group<m_x86_Features_Group>;
2525 def mno_lzcnt : Flag<["-"], "mno-lzcnt">, Group<m_x86_Features_Group>;
2526 def mmovbe : Flag<["-"], "mmovbe">, Group<m_x86_Features_Group>;
2527 def mno_movbe : Flag<["-"], "mno-movbe">, Group<m_x86_Features_Group>;
2528 def mmpx : Flag<["-"], "mmpx">, Group<m_x86_Features_Group>;
2529 def mno_mpx : Flag<["-"], "mno-mpx">, Group<m_x86_Features_Group>;
2530 def mmwaitx : Flag<["-"], "mmwaitx">, Group<m_x86_Features_Group>;
2531 def mno_mwaitx : Flag<["-"], "mno-mwaitx">, Group<m_x86_Features_Group>;
2532 def mpku : Flag<["-"], "mpku">, Group<m_x86_Features_Group>;
2533 def mno_pku : Flag<["-"], "mno-pku">, Group<m_x86_Features_Group>;
2534 def mpclmul : Flag<["-"], "mpclmul">, Group<m_x86_Features_Group>;
2535 def mno_pclmul : Flag<["-"], "mno-pclmul">, Group<m_x86_Features_Group>;
2536 def mpopcnt : Flag<["-"], "mpopcnt">, Group<m_x86_Features_Group>;
2537 def mno_popcnt : Flag<["-"], "mno-popcnt">, Group<m_x86_Features_Group>;
2538 def mprefetchwt1 : Flag<["-"], "mprefetchwt1">, Group<m_x86_Features_Group>;
2539 def mno_prefetchwt1 : Flag<["-"], "mno-prefetchwt1">, Group<m_x86_Features_Group>;
2540 def mprfchw : Flag<["-"], "mprfchw">, Group<m_x86_Features_Group>;
2541 def mno_prfchw : Flag<["-"], "mno-prfchw">, Group<m_x86_Features_Group>;
2542 def mrdrnd : Flag<["-"], "mrdrnd">, Group<m_x86_Features_Group>;
2543 def mno_rdrnd : Flag<["-"], "mno-rdrnd">, Group<m_x86_Features_Group>;
2544 def mrtm : Flag<["-"], "mrtm">, Group<m_x86_Features_Group>;
2545 def mno_rtm : Flag<["-"], "mno-rtm">, Group<m_x86_Features_Group>;
2546 def mrdseed : Flag<["-"], "mrdseed">, Group<m_x86_Features_Group>;
2547 def mno_rdseed : Flag<["-"], "mno-rdseed">, Group<m_x86_Features_Group>;
2548 def msgx : Flag<["-"], "msgx">, Group<m_x86_Features_Group>;
2549 def mno_sgx : Flag<["-"], "mno-sgx">, Group<m_x86_Features_Group>;
2550 def msha : Flag<["-"], "msha">, Group<m_x86_Features_Group>;
2551 def mno_sha : Flag<["-"], "mno-sha">, Group<m_x86_Features_Group>;
2552 def mtbm : Flag<["-"], "mtbm">, Group<m_x86_Features_Group>;
2553 def mno_tbm : Flag<["-"], "mno-tbm">, Group<m_x86_Features_Group>;
2554 def mvaes : Flag<["-"], "mvaes">, Group<m_x86_Features_Group>;
2555 def mno_vaes : Flag<["-"], "mno-vaes">, Group<m_x86_Features_Group>;
2556 def mvpclmulqdq : Flag<["-"], "mvpclmulqdq">, Group<m_x86_Features_Group>;
2557 def mno_vpclmulqdq : Flag<["-"], "mno-vpclmulqdq">, Group<m_x86_Features_Group>;
2558 def mxop : Flag<["-"], "mxop">, Group<m_x86_Features_Group>;
2559 def mno_xop : Flag<["-"], "mno-xop">, Group<m_x86_Features_Group>;
2560 def mxsave : Flag<["-"], "mxsave">, Group<m_x86_Features_Group>;
2561 def mno_xsave : Flag<["-"], "mno-xsave">, Group<m_x86_Features_Group>;
2562 def mxsavec : Flag<["-"], "mxsavec">, Group<m_x86_Features_Group>;
2563 def mno_xsavec : Flag<["-"], "mno-xsavec">, Group<m_x86_Features_Group>;
2564 def mxsaveopt : Flag<["-"], "mxsaveopt">, Group<m_x86_Features_Group>;
2565 def mno_xsaveopt : Flag<["-"], "mno-xsaveopt">, Group<m_x86_Features_Group>;
2566 def mxsaves : Flag<["-"], "mxsaves">, Group<m_x86_Features_Group>;
2567 def mno_xsaves : Flag<["-"], "mno-xsaves">, Group<m_x86_Features_Group>;
2568 def mshstk : Flag<["-"], "mshstk">, Group<m_x86_Features_Group>;
2569 def mno_shstk : Flag<["-"], "mno-shstk">, Group<m_x86_Features_Group>;
2570 def mibt : Flag<["-"], "mibt">, Group<m_x86_Features_Group>;
2571 def mno_ibt : Flag<["-"], "mno-ibt">, Group<m_x86_Features_Group>;
2573 // These are legacy user-facing driver-level option spellings. They are always
2574 // aliases for options that are spelled using the more common Unix / GNU flag
2575 // style of double-dash and equals-joined flags.
2576 def gcc_toolchain_legacy_spelling : Separate<["-"], "gcc-toolchain">, Alias<gcc_toolchain>;
2577 def target_legacy_spelling : Separate<["-"], "target">, Alias<target>;
2579 // Special internal option to handle -Xlinker --no-demangle.
2580 def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">,
2581 Flags<[Unsupported, NoArgumentUnused]>;
2583 // Special internal option to allow forwarding arbitrary arguments to linker.
2584 def Zlinker_input : Separate<["-"], "Zlinker-input">,
2585 Flags<[Unsupported, NoArgumentUnused]>;
2587 // Reserved library options.
2588 def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">,
2589 Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
2590 def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">,
2591 Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
2594 // FIXME: multiclasess produce suffixes, not prefixes. This is fine for now
2595 // since it is only used in ignored options.
2596 multiclass BooleanFFlag<string name> {
2597 def _f : Flag<["-"], "f"#name>;
2598 def _fno : Flag<["-"], "fno-"#name>;
2601 defm : BooleanFFlag<"keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
2603 def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<f_Group>;
2605 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>, Flags<[CoreOption]>;
2607 defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
2608 def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_gcc_optimization_f_Group>;
2609 defm align_labels : BooleanFFlag<"align-labels">, Group<clang_ignored_gcc_optimization_f_Group>;
2610 def falign_labels_EQ : Joined<["-"], "falign-labels=">, Group<clang_ignored_gcc_optimization_f_Group>;
2611 defm align_loops : BooleanFFlag<"align-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
2612 def falign_loops_EQ : Joined<["-"], "falign-loops=">, Group<clang_ignored_gcc_optimization_f_Group>;
2613 defm align_jumps : BooleanFFlag<"align-jumps">, Group<clang_ignored_gcc_optimization_f_Group>;
2614 def falign_jumps_EQ : Joined<["-"], "falign-jumps=">, Group<clang_ignored_gcc_optimization_f_Group>;
2616 // FIXME: This option should be supported and wired up to our diognostics, but
2617 // ignore it for now to avoid breaking builds that use it.
2618 def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>;
2620 defm fcheck_new : BooleanFFlag<"check-new">, Group<clang_ignored_f_Group>;
2621 defm caller_saves : BooleanFFlag<"caller-saves">, Group<clang_ignored_gcc_optimization_f_Group>;
2622 defm reorder_blocks : BooleanFFlag<"reorder-blocks">, Group<clang_ignored_gcc_optimization_f_Group>;
2623 defm eliminate_unused_debug_types : BooleanFFlag<"eliminate-unused-debug-types">, Group<clang_ignored_f_Group>;
2624 defm branch_count_reg : BooleanFFlag<"branch-count-reg">, Group<clang_ignored_gcc_optimization_f_Group>;
2625 defm default_inline : BooleanFFlag<"default-inline">, Group<clang_ignored_gcc_optimization_f_Group>;
2626 defm delete_null_pointer_checks : BooleanFFlag<"delete-null-pointer-checks">,
2627 Group<clang_ignored_gcc_optimization_f_Group>;
2628 defm fat_lto_objects : BooleanFFlag<"fat-lto-objects">, Group<clang_ignored_gcc_optimization_f_Group>;
2629 defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_gcc_optimization_f_Group>;
2630 defm friend_injection : BooleanFFlag<"friend-injection">, Group<clang_ignored_f_Group>;
2631 defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>;
2632 defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_gcc_optimization_f_Group>;
2633 defm gcse_after_reload: BooleanFFlag<"gcse-after-reload">, Group<clang_ignored_gcc_optimization_f_Group>;
2634 defm gcse_las: BooleanFFlag<"gcse-las">, Group<clang_ignored_gcc_optimization_f_Group>;
2635 defm gcse_sm: BooleanFFlag<"gcse-sm">, Group<clang_ignored_gcc_optimization_f_Group>;
2636 defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>;
2637 defm ident : BooleanFFlag<"ident">, Group<clang_ignored_f_Group>;
2638 defm implicit_templates : BooleanFFlag<"implicit-templates">, Group<clang_ignored_f_Group>;
2639 defm implement_inlines : BooleanFFlag<"implement-inlines">, Group<clang_ignored_f_Group>;
2640 defm merge_constants : BooleanFFlag<"merge-constants">, Group<clang_ignored_gcc_optimization_f_Group>;
2641 defm modulo_sched : BooleanFFlag<"modulo-sched">, Group<clang_ignored_gcc_optimization_f_Group>;
2642 defm modulo_sched_allow_regmoves : BooleanFFlag<"modulo-sched-allow-regmoves">,
2643 Group<clang_ignored_gcc_optimization_f_Group>;
2644 defm inline_functions_called_once : BooleanFFlag<"inline-functions-called-once">,
2645 Group<clang_ignored_gcc_optimization_f_Group>;
2646 def finline_limit_EQ : Joined<["-"], "finline-limit=">, Group<clang_ignored_gcc_optimization_f_Group>;
2647 defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>;
2648 defm inline_small_functions : BooleanFFlag<"inline-small-functions">,
2649 Group<clang_ignored_gcc_optimization_f_Group>;
2650 defm ipa_cp : BooleanFFlag<"ipa-cp">,
2651 Group<clang_ignored_gcc_optimization_f_Group>;
2652 defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>;
2653 defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>;
2654 defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
2655 defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>;
2656 defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_gcc_optimization_f_Group>;
2657 defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>;
2658 defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>;
2659 defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_gcc_optimization_f_Group>;
2660 defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>;
2661 defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>;
2662 defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_optimization_f_Group>;
2663 defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>;
2664 defm rename_registers : BooleanFFlag<"rename-registers">, Group<clang_ignored_gcc_optimization_f_Group>;
2665 defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>;
2666 defm rounding_math : BooleanFFlag<"rounding-math">, Group<clang_ignored_gcc_optimization_f_Group>;
2667 defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_gcc_optimization_f_Group>;
2668 defm schedule_insns2 : BooleanFFlag<"schedule-insns2">, Group<clang_ignored_gcc_optimization_f_Group>;
2669 defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>;
2670 defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_gcc_optimization_f_Group>;
2671 defm single_precision_constant : BooleanFFlag<"single-precision-constant">,
2672 Group<clang_ignored_gcc_optimization_f_Group>;
2673 defm spec_constr_count : BooleanFFlag<"spec-constr-count">, Group<clang_ignored_f_Group>;
2674 defm stack_check : BooleanFFlag<"stack-check">, Group<clang_ignored_f_Group>;
2675 defm strength_reduce :
2676 BooleanFFlag<"strength-reduce">, Group<clang_ignored_gcc_optimization_f_Group>;
2677 defm tls_model : BooleanFFlag<"tls-model">, Group<clang_ignored_f_Group>;
2678 defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_gcc_optimization_f_Group>;
2679 defm tree_dce : BooleanFFlag<"tree-dce">, Group<clang_ignored_gcc_optimization_f_Group>;
2680 defm tree_loop_im : BooleanFFlag<"tree_loop_im">, Group<clang_ignored_gcc_optimization_f_Group>;
2681 defm tree_loop_ivcanon : BooleanFFlag<"tree_loop_ivcanon">, Group<clang_ignored_gcc_optimization_f_Group>;
2682 defm tree_loop_linear : BooleanFFlag<"tree_loop_linear">, Group<clang_ignored_gcc_optimization_f_Group>;
2683 defm tree_salias : BooleanFFlag<"tree-salias">, Group<clang_ignored_f_Group>;
2684 defm tree_ter : BooleanFFlag<"tree-ter">, Group<clang_ignored_gcc_optimization_f_Group>;
2685 defm tree_vectorizer_verbose : BooleanFFlag<"tree-vectorizer-verbose">, Group<clang_ignored_f_Group>;
2686 defm tree_vrp : BooleanFFlag<"tree-vrp">, Group<clang_ignored_gcc_optimization_f_Group>;
2687 defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
2688 defm unsafe_loop_optimizations : BooleanFFlag<"unsafe-loop-optimizations">,
2689 Group<clang_ignored_gcc_optimization_f_Group>;
2690 defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
2691 defm use_linker_plugin : BooleanFFlag<"use-linker-plugin">, Group<clang_ignored_gcc_optimization_f_Group>;
2692 defm vect_cost_model : BooleanFFlag<"vect-cost-model">, Group<clang_ignored_gcc_optimization_f_Group>;
2693 defm variable_expansion_in_unroller : BooleanFFlag<"variable-expansion-in-unroller">,
2694 Group<clang_ignored_gcc_optimization_f_Group>;
2695 defm web : BooleanFFlag<"web">, Group<clang_ignored_gcc_optimization_f_Group>;
2696 defm whole_program : BooleanFFlag<"whole-program">, Group<clang_ignored_gcc_optimization_f_Group>;
2697 defm devirtualize : BooleanFFlag<"devirtualize">, Group<clang_ignored_gcc_optimization_f_Group>;
2698 defm devirtualize_speculatively : BooleanFFlag<"devirtualize-speculatively">,
2699 Group<clang_ignored_gcc_optimization_f_Group>;
2701 // Generic gfortran options.
2702 def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>;
2703 def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Group<gfortran_Group>;
2704 def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>;
2705 def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>;
2706 def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>;
2708 // "f" options with values for gfortran.
2709 def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>;
2710 def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>;
2711 def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>;
2712 def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>;
2713 def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<gfortran_Group>;
2714 def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>;
2715 def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>;
2716 def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>;
2717 def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>;
2718 def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>;
2719 def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>;
2720 def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>;
2721 def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>;
2722 def fmax_stack_var_size_EQ : Joined<["-"], "fmax-stack-var-size=">, Group<gfortran_Group>;
2723 def fmax_subrecord_length_EQ : Joined<["-"], "fmax-subrecord-length=">, Group<gfortran_Group>;
2724 def frecord_marker_EQ : Joined<["-"], "frecord-marker=">, Group<gfortran_Group>;
2726 // "f" flags for gfortran.
2727 defm aggressive_function_elimination : BooleanFFlag<"aggressive-function-elimination">, Group<gfortran_Group>;
2728 defm align_commons : BooleanFFlag<"align-commons">, Group<gfortran_Group>;
2729 defm all_intrinsics : BooleanFFlag<"all-intrinsics">, Group<gfortran_Group>;
2730 defm automatic : BooleanFFlag<"automatic">, Group<gfortran_Group>;
2731 defm backslash : BooleanFFlag<"backslash">, Group<gfortran_Group>;
2732 defm backtrace : BooleanFFlag<"backtrace">, Group<gfortran_Group>;
2733 defm bounds_check : BooleanFFlag<"bounds-check">, Group<gfortran_Group>;
2734 defm check_array_temporaries : BooleanFFlag<"check-array-temporaries">, Group<gfortran_Group>;
2735 defm cray_pointer : BooleanFFlag<"cray-pointer">, Group<gfortran_Group>;
2736 defm d_lines_as_code : BooleanFFlag<"d-lines-as-code">, Group<gfortran_Group>;
2737 defm d_lines_as_comments : BooleanFFlag<"d-lines-as-comments">, Group<gfortran_Group>;
2738 defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>;
2739 defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>;
2740 defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>;
2741 defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>;
2742 defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>;
2743 defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>;
2744 defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>;
2745 defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>;
2746 defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>;
2747 defm fixed_form : BooleanFFlag<"fixed-form">, Group<gfortran_Group>;
2748 defm free_form : BooleanFFlag<"free-form">, Group<gfortran_Group>;
2749 defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>;
2750 defm implicit_none : BooleanFFlag<"implicit-none">, Group<gfortran_Group>;
2751 defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>;
2752 defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>;
2753 defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>;
2754 defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>;
2755 defm module_private : BooleanFFlag<"module-private">, Group<gfortran_Group>;
2756 defm pack_derived : BooleanFFlag<"pack-derived">, Group<gfortran_Group>;
2757 defm protect_parens : BooleanFFlag<"protect-parens">, Group<gfortran_Group>;
2758 defm range_check : BooleanFFlag<"range-check">, Group<gfortran_Group>;
2759 defm real_4_real_10 : BooleanFFlag<"real-4-real-10">, Group<gfortran_Group>;
2760 defm real_4_real_16 : BooleanFFlag<"real-4-real-16">, Group<gfortran_Group>;
2761 defm real_4_real_8 : BooleanFFlag<"real-4-real-8">, Group<gfortran_Group>;
2762 defm real_8_real_10 : BooleanFFlag<"real-8-real-10">, Group<gfortran_Group>;
2763 defm real_8_real_16 : BooleanFFlag<"real-8-real-16">, Group<gfortran_Group>;
2764 defm real_8_real_4 : BooleanFFlag<"real-8-real-4">, Group<gfortran_Group>;
2765 defm realloc_lhs : BooleanFFlag<"realloc-lhs">, Group<gfortran_Group>;
2766 defm recursive : BooleanFFlag<"recursive">, Group<gfortran_Group>;
2767 defm repack_arrays : BooleanFFlag<"repack-arrays">, Group<gfortran_Group>;
2768 defm second_underscore : BooleanFFlag<"second-underscore">, Group<gfortran_Group>;
2769 defm sign_zero : BooleanFFlag<"sign-zero">, Group<gfortran_Group>;
2770 defm stack_arrays : BooleanFFlag<"stack-arrays">, Group<gfortran_Group>;
2771 defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>;
2772 defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>;
2775 include "CC1Options.td"
2777 include "CLCompatOptions.td"