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

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