contrib/llvm-project/clang/include/clang/Driver/Options.td

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