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

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