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