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