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