contrib/llvm/tools/clang/include/clang/Driver/Options.td

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