1//===--- Options.td - Options for clang -----------------------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file defines the options accepted by clang. 10// 11//===----------------------------------------------------------------------===// 12 13// Include the common option parsing interfaces. 14include "llvm/Option/OptParser.td" 15 16///////// 17// Flags 18 19// The option is a "driver"-only option, and should not be forwarded to other 20// tools via `-Xarch` options. 21def NoXarchOption : OptionFlag; 22 23// LinkerInput - The option is a linker input. 24def LinkerInput : OptionFlag; 25 26// NoArgumentUnused - Don't report argument unused warnings for this option; this 27// is useful for options like -static or -dynamic which a user may always end up 28// passing, even if the platform defaults to (or only supports) that option. 29def NoArgumentUnused : OptionFlag; 30 31// Unsupported - The option is unsupported, and the driver will reject command 32// lines that use it. 33def Unsupported : OptionFlag; 34 35// Ignored - The option is unsupported, and the driver will silently ignore it. 36def Ignored : OptionFlag; 37 38// CoreOption - This is considered a "core" Clang option, available in both 39// clang and clang-cl modes. 40def CoreOption : OptionFlag; 41 42// CLOption - This is a cl.exe compatibility option. Options with this flag 43// are made available when the driver is running in CL compatibility mode. 44def CLOption : OptionFlag; 45 46// CC1Option - This option should be accepted by clang -cc1. 47def CC1Option : OptionFlag; 48 49// CC1AsOption - This option should be accepted by clang -cc1as. 50def CC1AsOption : OptionFlag; 51 52// NoDriverOption - This option should not be accepted by the driver. 53def NoDriverOption : OptionFlag; 54 55// If an option affects linking, but has a primary group (so Link_Group cannot 56// be used), add this flag. 57def LinkOption : OptionFlag; 58 59// FlangOption - This is considered a "core" Flang option, available in 60// flang mode. 61def FlangOption : OptionFlag; 62 63// FlangOnlyOption - This option should only be used by Flang (i.e. it is not 64// available for Clang) 65def FlangOnlyOption : OptionFlag; 66 67// FC1Option - This option should be accepted by flang -fc1. 68def FC1Option : OptionFlag; 69 70// A short name to show in documentation. The name will be interpreted as rST. 71class DocName<string name> { string DocName = name; } 72 73// A brief description to show in documentation, interpreted as rST. 74class DocBrief<code descr> { code DocBrief = descr; } 75 76// Indicates that this group should be flattened into its parent when generating 77// documentation. 78class DocFlatten { bit DocFlatten = 1; } 79 80// Indicates that this warning is ignored, but accepted with a warning for 81// GCC compatibility. 82class IgnoredGCCCompat : Flags<[HelpHidden]> {} 83 84///////// 85// Groups 86 87def Action_Group : OptionGroup<"<action group>">, DocName<"Actions">, 88 DocBrief<[{The action to perform on the input.}]>; 89 90// Meta-group for options which are only used for compilation, 91// and not linking etc. 92def CompileOnly_Group : OptionGroup<"<CompileOnly group>">, 93 DocName<"Compilation flags">, DocBrief<[{ 94Flags controlling the behavior of Clang during compilation. These flags have 95no effect during actions that do not perform compilation.}]>; 96 97def Preprocessor_Group : OptionGroup<"<Preprocessor group>">, 98 Group<CompileOnly_Group>, 99 DocName<"Preprocessor flags">, DocBrief<[{ 100Flags controlling the behavior of the Clang preprocessor.}]>; 101 102def IncludePath_Group : OptionGroup<"<I/i group>">, Group<Preprocessor_Group>, 103 DocName<"Include path management">, 104 DocBrief<[{ 105Flags controlling how ``#include``\s are resolved to files.}]>; 106 107def I_Group : OptionGroup<"<I group>">, Group<IncludePath_Group>, DocFlatten; 108def i_Group : OptionGroup<"<i group>">, Group<IncludePath_Group>, DocFlatten; 109def clang_i_Group : OptionGroup<"<clang i group>">, Group<i_Group>, DocFlatten; 110 111def M_Group : OptionGroup<"<M group>">, Group<Preprocessor_Group>, 112 DocName<"Dependency file generation">, DocBrief<[{ 113Flags controlling generation of a dependency file for ``make``-like build 114systems.}]>; 115 116def d_Group : OptionGroup<"<d group>">, Group<Preprocessor_Group>, 117 DocName<"Dumping preprocessor state">, DocBrief<[{ 118Flags allowing the state of the preprocessor to be dumped in various ways.}]>; 119 120def Diag_Group : OptionGroup<"<W/R group>">, Group<CompileOnly_Group>, 121 DocName<"Diagnostic flags">, DocBrief<[{ 122Flags controlling which warnings, errors, and remarks Clang will generate. 123See the :doc:`full list of warning and remark flags <DiagnosticsReference>`.}]>; 124 125def R_Group : OptionGroup<"<R group>">, Group<Diag_Group>, DocFlatten; 126def R_value_Group : OptionGroup<"<R (with value) group>">, Group<R_Group>, 127 DocFlatten; 128def W_Group : OptionGroup<"<W group>">, Group<Diag_Group>, DocFlatten; 129def W_value_Group : OptionGroup<"<W (with value) group>">, Group<W_Group>, 130 DocFlatten; 131 132def f_Group : OptionGroup<"<f group>">, Group<CompileOnly_Group>, 133 DocName<"Target-independent compilation options">; 134 135def f_clang_Group : OptionGroup<"<f (clang-only) group>">, 136 Group<CompileOnly_Group>, DocFlatten; 137def pedantic_Group : OptionGroup<"<pedantic group>">, Group<f_Group>, 138 DocFlatten; 139def opencl_Group : OptionGroup<"<opencl group>">, Group<f_Group>, 140 DocName<"OpenCL flags">; 141 142def sycl_Group : OptionGroup<"<SYCL group>">, Group<f_Group>, 143 DocName<"SYCL flags">; 144 145def m_Group : OptionGroup<"<m group>">, Group<CompileOnly_Group>, 146 DocName<"Target-dependent compilation options">; 147 148// Feature groups - these take command line options that correspond directly to 149// target specific features and can be translated directly from command line 150// options. 151def m_aarch64_Features_Group : OptionGroup<"<aarch64 features group>">, 152 Group<m_Group>, DocName<"AARCH64">; 153def m_amdgpu_Features_Group : OptionGroup<"<amdgpu features group>">, 154 Group<m_Group>, DocName<"AMDGPU">; 155def m_arm_Features_Group : OptionGroup<"<arm features group>">, 156 Group<m_Group>, DocName<"ARM">; 157def m_hexagon_Features_Group : OptionGroup<"<hexagon features group>">, 158 Group<m_Group>, DocName<"Hexagon">; 159// The features added by this group will not be added to target features. 160// These are explicitly handled. 161def m_hexagon_Features_HVX_Group : OptionGroup<"<hexagon features group>">, 162 Group<m_Group>, DocName<"Hexagon">; 163def m_mips_Features_Group : OptionGroup<"<mips features group>">, 164 Group<m_Group>, DocName<"MIPS">; 165def m_ppc_Features_Group : OptionGroup<"<ppc features group>">, 166 Group<m_Group>, DocName<"PowerPC">; 167def m_wasm_Features_Group : OptionGroup<"<wasm features group>">, 168 Group<m_Group>, DocName<"WebAssembly">; 169// The features added by this group will not be added to target features. 170// These are explicitly handled. 171def m_wasm_Features_Driver_Group : OptionGroup<"<wasm driver features group>">, 172 Group<m_Group>, DocName<"WebAssembly Driver">; 173def m_x86_Features_Group : OptionGroup<"<x86 features group>">, 174 Group<m_Group>, Flags<[CoreOption]>, DocName<"X86">; 175def m_riscv_Features_Group : OptionGroup<"<riscv features group>">, 176 Group<m_Group>, DocName<"RISCV">; 177 178def m_libc_Group : OptionGroup<"<m libc group>">, Group<m_mips_Features_Group>, 179 Flags<[HelpHidden]>; 180 181def O_Group : OptionGroup<"<O group>">, Group<CompileOnly_Group>, 182 DocName<"Optimization level">, DocBrief<[{ 183Flags controlling how much optimization should be performed.}]>; 184 185def DebugInfo_Group : OptionGroup<"<g group>">, Group<CompileOnly_Group>, 186 DocName<"Debug information generation">, DocBrief<[{ 187Flags controlling how much and what kind of debug information should be 188generated.}]>; 189 190def g_Group : OptionGroup<"<g group>">, Group<DebugInfo_Group>, 191 DocName<"Kind and level of debug information">; 192def gN_Group : OptionGroup<"<gN group>">, Group<g_Group>, 193 DocName<"Debug level">; 194def ggdbN_Group : OptionGroup<"<ggdbN group>">, Group<gN_Group>, DocFlatten; 195def gTune_Group : OptionGroup<"<gTune group>">, Group<g_Group>, 196 DocName<"Debugger to tune debug information for">; 197def g_flags_Group : OptionGroup<"<g flags group>">, Group<DebugInfo_Group>, 198 DocName<"Debug information flags">; 199 200def StaticAnalyzer_Group : OptionGroup<"<Static analyzer group>">, 201 DocName<"Static analyzer flags">, DocBrief<[{ 202Flags controlling the behavior of the Clang Static Analyzer.}]>; 203 204// gfortran options that we recognize in the driver and pass along when 205// invoking GCC to compile Fortran code. 206def gfortran_Group : OptionGroup<"<gfortran group>">, 207 DocName<"Fortran compilation flags">, DocBrief<[{ 208Flags that will be passed onto the ``gfortran`` compiler when Clang is given 209a Fortran input.}]>; 210 211def Link_Group : OptionGroup<"<T/e/s/t/u group>">, DocName<"Linker flags">, 212 DocBrief<[{Flags that are passed on to the linker}]>; 213def T_Group : OptionGroup<"<T group>">, Group<Link_Group>, DocFlatten; 214def u_Group : OptionGroup<"<u group>">, Group<Link_Group>, DocFlatten; 215 216def reserved_lib_Group : OptionGroup<"<reserved libs group>">, 217 Flags<[Unsupported]>; 218 219// Temporary groups for clang options which we know we don't support, 220// but don't want to verbosely warn the user about. 221def clang_ignored_f_Group : OptionGroup<"<clang ignored f group>">, 222 Group<f_Group>, Flags<[Ignored]>; 223def clang_ignored_m_Group : OptionGroup<"<clang ignored m group>">, 224 Group<m_Group>, Flags<[Ignored]>; 225 226// Group for clang options in the process of deprecation. 227// Please include the version that deprecated the flag as comment to allow 228// easier garbage collection. 229def clang_ignored_legacy_options_Group : OptionGroup<"<clang legacy flags>">, 230 Group<f_Group>, Flags<[Ignored]>; 231 232// Retired with clang-5.0 233def : Flag<["-"], "fslp-vectorize-aggressive">, Group<clang_ignored_legacy_options_Group>; 234def : Flag<["-"], "fno-slp-vectorize-aggressive">, Group<clang_ignored_legacy_options_Group>; 235 236// Retired with clang-10.0. Previously controlled X86 MPX ISA. 237def mmpx : Flag<["-"], "mmpx">, Group<clang_ignored_legacy_options_Group>; 238def mno_mpx : Flag<["-"], "mno-mpx">, Group<clang_ignored_legacy_options_Group>; 239 240// Group that ignores all gcc optimizations that won't be implemented 241def clang_ignored_gcc_optimization_f_Group : OptionGroup< 242 "<clang_ignored_gcc_optimization_f_Group>">, Group<f_Group>, Flags<[Ignored]>; 243 244class DiagnosticOpts<string base> 245 : KeyPathAndMacro<"DiagnosticOpts->", base, "DIAG_"> {} 246class LangOpts<string base> 247 : KeyPathAndMacro<"LangOpts->", base, "LANG_"> {} 248class TargetOpts<string base> 249 : KeyPathAndMacro<"TargetOpts->", base> {} 250class FrontendOpts<string base> 251 : KeyPathAndMacro<"FrontendOpts.", base> {} 252class PreprocessorOutputOpts<string base> 253 : KeyPathAndMacro<"PreprocessorOutputOpts.", base> {} 254class DependencyOutputOpts<string base> 255 : KeyPathAndMacro<"DependencyOutputOpts.", base> {} 256class CodeGenOpts<string base> 257 : KeyPathAndMacro<"CodeGenOpts.", base, "CODEGEN_"> {} 258class HeaderSearchOpts<string base> 259 : KeyPathAndMacro<"HeaderSearchOpts->", base> {} 260class PreprocessorOpts<string base> 261 : KeyPathAndMacro<"PreprocessorOpts->", base> {} 262class FileSystemOpts<string base> 263 : KeyPathAndMacro<"FileSystemOpts.", base> {} 264class AnalyzerOpts<string base> 265 : KeyPathAndMacro<"AnalyzerOpts->", base> {} 266class MigratorOpts<string base> 267 : KeyPathAndMacro<"MigratorOpts.", base> {} 268 269// A boolean option which is opt-in in CC1. The positive option exists in CC1 and 270// Args.hasArg(OPT_ffoo) is used to check that the flag is enabled. 271// This is useful if the option is usually disabled. 272multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="", 273 string help="", list<OptionFlag> flags=[], 274 KeyPathAndMacro kpm = EmptyKPM, 275 list<string> enablers = []> { 276 def f#NAME : Flag<["-"], "f"#name>, Flags<!listconcat([CC1Option], flags)>, 277 Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>, 278 MarshallingInfoFlag<kpm, "false">, 279 ImpliedByAnyOf<enablers, "true">; 280 def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<flags>, 281 Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>; 282} 283 284// A boolean option which is opt-out in CC1. The negative option exists in CC1 and 285// Args.hasArg(OPT_fno_foo) is used to check that the flag is disabled. 286multiclass OptOutFFlag<string name, string pos_prefix, string neg_prefix, 287 string help="", list<OptionFlag> flags=[], 288 KeyPathAndMacro kpm = EmptyKPM, 289 list<string> disablers = []> { 290 def f#NAME : Flag<["-"], "f"#name>, Flags<flags>, 291 Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>; 292 def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<!listconcat([CC1Option], flags)>, 293 Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>, 294 MarshallingInfoFlag<kpm, "false">, 295 ImpliedByAnyOf<disablers, "true">; 296} 297 298//===----------------------------------------------------------------------===// 299// BoolOption 300//===----------------------------------------------------------------------===// 301 302// The default value of a marshalled key path. 303class Default<code value> { code Value = value; } 304 305// Convenience variables for boolean defaults. 306def DefaultTrue : Default<"true"> {} 307def DefaultFalse : Default<"false"> {} 308 309// The value set to the key path when the flag is present on the command line. 310class Set<bit value> { bit Value = value; } 311def SetTrue : Set<true> {} 312def SetFalse : Set<false> {} 313 314// Definition of single command line flag. This is an implementation detail, use 315// SetTrueBy or SetFalseBy instead. 316class FlagDef<bit polarity, bit value, list<OptionFlag> option_flags, 317 string help, list<code> implied_by_expressions = []> { 318 // The polarity. Besides spelling, this also decides whether the TableGen 319 // record will be prefixed with "no_". 320 bit Polarity = polarity; 321 322 // The value assigned to key path when the flag is present on command line. 323 bit Value = value; 324 325 // OptionFlags that control visibility of the flag in different tools. 326 list<OptionFlag> OptionFlags = option_flags; 327 328 // The help text associated with the flag. 329 string Help = help; 330 331 // List of expressions that, when true, imply this flag. 332 list<code> ImpliedBy = implied_by_expressions; 333} 334 335// Additional information to be appended to both positive and negative flag. 336class BothFlags<list<OptionFlag> option_flags, string help = ""> { 337 list<OptionFlag> OptionFlags = option_flags; 338 string Help = help; 339} 340 341// Functor that appends the suffix to the base flag definition. 342class ApplySuffix<FlagDef flag, BothFlags suffix> { 343 FlagDef Result 344 = FlagDef<flag.Polarity, flag.Value, 345 !listconcat(flag.OptionFlags, suffix.OptionFlags), 346 !strconcat(flag.Help, suffix.Help), flag.ImpliedBy>; 347} 348 349// Definition of the command line flag with positive spelling, e.g. "-ffoo". 350class PosFlag<Set value, list<OptionFlag> flags = [], string help = "", 351 list<code> implied_by_expressions = []> 352 : FlagDef<true, value.Value, flags, help, implied_by_expressions> {} 353 354// Definition of the command line flag with negative spelling, e.g. "-fno-foo". 355class NegFlag<Set value, list<OptionFlag> flags = [], string help = "", 356 list<code> implied_by_expressions = []> 357 : FlagDef<false, value.Value, flags, help, implied_by_expressions> {} 358 359// Expanded FlagDef that's convenient for creation of TableGen records. 360class FlagDefExpanded<FlagDef flag, string prefix, string name, string spelling> 361 : FlagDef<flag.Polarity, flag.Value, flag.OptionFlags, flag.Help, 362 flag.ImpliedBy> { 363 // Name of the TableGen record. 364 string RecordName = prefix#!cond(flag.Polarity : "", true : "no_")#name; 365 366 // Spelling of the flag. 367 string Spelling = prefix#!cond(flag.Polarity : "", true : "no-")#spelling; 368 369 // Can the flag be implied by another flag? 370 bit CanBeImplied = !not(!empty(flag.ImpliedBy)); 371 372 // C++ code that will be assigned to the keypath when the flag is present. 373 code ValueAsCode = !cond(flag.Value : "true", true: "false"); 374} 375 376// TableGen record for a single marshalled flag. 377class MarshalledFlagRec<FlagDefExpanded flag, FlagDefExpanded other, 378 FlagDefExpanded implied, KeyPathAndMacro kpm, 379 Default default> 380 : Flag<["-"], flag.Spelling>, Flags<flag.OptionFlags>, HelpText<flag.Help>, 381 MarshallingInfoBooleanFlag<kpm, default.Value, flag.ValueAsCode, 382 flag.RecordName, other.ValueAsCode, 383 other.RecordName>, 384 ImpliedByAnyOf<implied.ImpliedBy, implied.ValueAsCode> {} 385 386// Generates TableGen records for two command line flags that control the same 387// key path via the marshalling infrastructure. 388// Names of the records consist of the specified prefix, "no_" for the negative 389// flag, and NAME. 390multiclass BoolOption<string prefix = "", string spelling_base, 391 KeyPathAndMacro kpm, Default default, 392 FlagDef flag1_base, FlagDef flag2_base, 393 BothFlags suffix = BothFlags<[], "">> { 394 defvar flag1 = FlagDefExpanded<ApplySuffix<flag1_base, suffix>.Result, prefix, 395 NAME, spelling_base>; 396 397 defvar flag2 = FlagDefExpanded<ApplySuffix<flag2_base, suffix>.Result, prefix, 398 NAME, spelling_base>; 399 400 // TODO: Assert that the flags have different polarity. 401 // TODO: Assert that the flags have different value. 402 // TODO: Assert that only one of the flags can be implied. 403 404 defvar implied = !cond(flag1.CanBeImplied: flag1, true: flag2); 405 406 def flag1.RecordName : MarshalledFlagRec<flag1, flag2, implied, kpm, default>; 407 def flag2.RecordName : MarshalledFlagRec<flag2, flag1, implied, kpm, default>; 408} 409 410/// Creates a BoolOption where both of the flags are prefixed with "f", are in 411/// the Group<f_Group>. 412multiclass BoolFOption<string flag_base, KeyPathAndMacro kpm, 413 Default default, FlagDef flag1, FlagDef flag2, 414 BothFlags both = BothFlags<[], "">> { 415 defm NAME : BoolOption<"f", flag_base, kpm, default, flag1, flag2, both>, 416 Group<f_Group>; 417} 418 419// Creates a BoolOption where both of the flags are prefixed with "g" and have 420// the Group<g_Group>. 421multiclass BoolGOption<string flag_base, KeyPathAndMacro kpm, 422 Default default, FlagDef flag1, FlagDef flag2, 423 BothFlags both = BothFlags<[], "">> { 424 defm NAME : BoolOption<"g", flag_base, kpm, default, flag1, flag2, both>, 425 Group<g_Group>; 426} 427 428// FIXME: Diagnose if target does not support protected visibility. 429class MarshallingInfoVisibility<KeyPathAndMacro kpm, code default> 430 : MarshallingInfoString<kpm, default>, 431 Values<"default,hidden,internal,protected">, 432 NormalizedValues<["DefaultVisibility", "HiddenVisibility", 433 "HiddenVisibility", "ProtectedVisibility"]>, 434 AutoNormalizeEnum {} 435 436// Key paths that are constant during parsing of options with the same key path prefix. 437defvar cplusplus = LangOpts<"CPlusPlus">; 438defvar c99 = LangOpts<"C99">; 439defvar lang_std = LangOpts<"LangStd">; 440defvar open_cl = LangOpts<"OpenCL">; 441defvar render_script = LangOpts<"RenderScript">; 442defvar hip = LangOpts<"HIP">; 443defvar gnu_mode = LangOpts<"GNUMode">; 444 445defvar std = !strconcat("LangStandard::getLangStandardForKind(", lang_std.KeyPath, ")"); 446 447///////// 448// Options 449 450// The internal option ID must be a valid C++ identifier and results in a 451// clang::driver::options::OPT_XX enum constant for XX. 452// 453// We want to unambiguously be able to refer to options from the driver source 454// code, for this reason the option name is mangled into an ID. This mangling 455// isn't guaranteed to have an inverse, but for practical purposes it does. 456// 457// The mangling scheme is to ignore the leading '-', and perform the following 458// substitutions: 459// _ => __ 460// - => _ 461// / => _SLASH 462// # => _HASH 463// ? => _QUESTION 464// , => _COMMA 465// = => _EQ 466// C++ => CXX 467// . => _ 468 469// Developer Driver Options 470 471def internal_Group : OptionGroup<"<clang internal options>">, Flags<[HelpHidden]>; 472def internal_driver_Group : OptionGroup<"<clang driver internal options>">, 473 Group<internal_Group>, HelpText<"DRIVER OPTIONS">; 474def internal_debug_Group : 475 OptionGroup<"<clang debug/development internal options>">, 476 Group<internal_Group>, HelpText<"DEBUG/DEVELOPMENT OPTIONS">; 477 478class InternalDriverOpt : Group<internal_driver_Group>, 479 Flags<[NoXarchOption, HelpHidden]>; 480def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>, 481 Flags<[CoreOption, NoXarchOption, HelpHidden]>, 482 HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', or 'cl'">; 483def rsp_quoting : Joined<["--"], "rsp-quoting=">, Group<internal_driver_Group>, 484 Flags<[CoreOption, NoXarchOption, HelpHidden]>, 485 HelpText<"Set the rsp quoting to either 'posix', or 'windows'">; 486def ccc_gcc_name : Separate<["-"], "ccc-gcc-name">, InternalDriverOpt, 487 HelpText<"Name for native GCC compiler">, 488 MetaVarName<"<gcc-path>">; 489 490class InternalDebugOpt : Group<internal_debug_Group>, 491 Flags<[NoXarchOption, HelpHidden, CoreOption]>; 492def ccc_install_dir : Separate<["-"], "ccc-install-dir">, InternalDebugOpt, 493 HelpText<"Simulate installation in the given directory">; 494def ccc_print_phases : Flag<["-"], "ccc-print-phases">, InternalDebugOpt, 495 HelpText<"Dump list of actions to perform">; 496def ccc_print_bindings : Flag<["-"], "ccc-print-bindings">, InternalDebugOpt, 497 HelpText<"Show bindings of tools to actions">; 498 499def ccc_arcmt_check : Flag<["-"], "ccc-arcmt-check">, InternalDriverOpt, 500 HelpText<"Check for ARC migration issues that need manual handling">; 501def ccc_arcmt_modify : Flag<["-"], "ccc-arcmt-modify">, InternalDriverOpt, 502 HelpText<"Apply modifications to files to conform to ARC">; 503def ccc_arcmt_migrate : Separate<["-"], "ccc-arcmt-migrate">, InternalDriverOpt, 504 HelpText<"Apply modifications and produces temporary files that conform to ARC">; 505def arcmt_migrate_report_output : Separate<["-"], "arcmt-migrate-report-output">, 506 HelpText<"Output path for the plist report">, Flags<[CC1Option]>, 507 MarshallingInfoString<FrontendOpts<"ARCMTMigrateReportOut">>; 508def arcmt_migrate_emit_arc_errors : Flag<["-"], "arcmt-migrate-emit-errors">, 509 HelpText<"Emit ARC errors even if the migrator can fix them">, Flags<[CC1Option]>, 510 MarshallingInfoFlag<FrontendOpts<"ARCMTMigrateEmitARCErrors">>; 511def gen_reproducer: Flag<["-"], "gen-reproducer">, InternalDebugOpt, 512 HelpText<"Auto-generates preprocessed source files and a reproduction script">; 513def gen_cdb_fragment_path: Separate<["-"], "gen-cdb-fragment-path">, InternalDebugOpt, 514 HelpText<"Emit a compilation database fragment to the specified directory">; 515 516def _migrate : Flag<["--"], "migrate">, Flags<[NoXarchOption]>, 517 HelpText<"Run the migrator">; 518def ccc_objcmt_migrate : Separate<["-"], "ccc-objcmt-migrate">, 519 InternalDriverOpt, 520 HelpText<"Apply modifications and produces temporary files to migrate to " 521 "modern ObjC syntax">; 522 523def objcmt_migrate_literals : Flag<["-"], "objcmt-migrate-literals">, Flags<[CC1Option]>, 524 HelpText<"Enable migration to modern ObjC literals">, 525 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_Literals">; 526def objcmt_migrate_subscripting : Flag<["-"], "objcmt-migrate-subscripting">, Flags<[CC1Option]>, 527 HelpText<"Enable migration to modern ObjC subscripting">, 528 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_Subscripting">; 529def objcmt_migrate_property : Flag<["-"], "objcmt-migrate-property">, Flags<[CC1Option]>, 530 HelpText<"Enable migration to modern ObjC property">, 531 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_Property">; 532def objcmt_migrate_all : Flag<["-"], "objcmt-migrate-all">, Flags<[CC1Option]>, 533 HelpText<"Enable migration to modern ObjC">, 534 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_MigrateDecls">; 535def objcmt_migrate_readonly_property : Flag<["-"], "objcmt-migrate-readonly-property">, Flags<[CC1Option]>, 536 HelpText<"Enable migration to modern ObjC readonly property">, 537 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_ReadonlyProperty">; 538def objcmt_migrate_readwrite_property : Flag<["-"], "objcmt-migrate-readwrite-property">, Flags<[CC1Option]>, 539 HelpText<"Enable migration to modern ObjC readwrite property">, 540 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_ReadwriteProperty">; 541def objcmt_migrate_property_dot_syntax : Flag<["-"], "objcmt-migrate-property-dot-syntax">, Flags<[CC1Option]>, 542 HelpText<"Enable migration of setter/getter messages to property-dot syntax">, 543 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_PropertyDotSyntax">; 544def objcmt_migrate_annotation : Flag<["-"], "objcmt-migrate-annotation">, Flags<[CC1Option]>, 545 HelpText<"Enable migration to property and method annotations">, 546 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_Annotation">; 547def objcmt_migrate_instancetype : Flag<["-"], "objcmt-migrate-instancetype">, Flags<[CC1Option]>, 548 HelpText<"Enable migration to infer instancetype for method result type">, 549 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_Instancetype">; 550def objcmt_migrate_nsmacros : Flag<["-"], "objcmt-migrate-ns-macros">, Flags<[CC1Option]>, 551 HelpText<"Enable migration to NS_ENUM/NS_OPTIONS macros">, 552 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_NsMacros">; 553def objcmt_migrate_protocol_conformance : Flag<["-"], "objcmt-migrate-protocol-conformance">, Flags<[CC1Option]>, 554 HelpText<"Enable migration to add protocol conformance on classes">, 555 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_ProtocolConformance">; 556def objcmt_atomic_property : Flag<["-"], "objcmt-atomic-property">, Flags<[CC1Option]>, 557 HelpText<"Make migration to 'atomic' properties">, 558 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_AtomicProperty">; 559def objcmt_returns_innerpointer_property : Flag<["-"], "objcmt-returns-innerpointer-property">, Flags<[CC1Option]>, 560 HelpText<"Enable migration to annotate property with NS_RETURNS_INNER_POINTER">, 561 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_ReturnsInnerPointerProperty">; 562def objcmt_ns_nonatomic_iosonly: Flag<["-"], "objcmt-ns-nonatomic-iosonly">, Flags<[CC1Option]>, 563 HelpText<"Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute">, 564 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty">; 565def objcmt_migrate_designated_init : Flag<["-"], "objcmt-migrate-designated-init">, Flags<[CC1Option]>, 566 HelpText<"Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods">, 567 MarshallingInfoBitfieldFlag<FrontendOpts<"ObjCMTAction">, "FrontendOptions::ObjCMT_DesignatedInitializer">; 568 569def objcmt_whitelist_dir_path: Joined<["-"], "objcmt-whitelist-dir-path=">, Flags<[CC1Option]>, 570 HelpText<"Only modify files with a filename contained in the provided directory path">, 571 MarshallingInfoString<FrontendOpts<"ObjCMTWhiteListPath">>; 572// The misspelt "white-list" [sic] alias is due for removal. 573def : Joined<["-"], "objcmt-white-list-dir-path=">, Flags<[CC1Option]>, 574 Alias<objcmt_whitelist_dir_path>; 575 576// Make sure all other -ccc- options are rejected. 577def ccc_ : Joined<["-"], "ccc-">, Group<internal_Group>, Flags<[Unsupported]>; 578 579// Standard Options 580 581def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[NoXarchOption, CoreOption, FlangOption]>, 582 HelpText<"Print (but do not run) the commands to run for this compilation">; 583def _DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>, 584 Flags<[NoXarchOption, CoreOption]>; 585def A : JoinedOrSeparate<["-"], "A">, Flags<[RenderJoined]>, Group<gfortran_Group>; 586def B : JoinedOrSeparate<["-"], "B">, MetaVarName<"<dir>">, 587 HelpText<"Add <dir> to search path for binaries and object files used implicitly">; 588def CC : Flag<["-"], "CC">, Flags<[CC1Option]>, Group<Preprocessor_Group>, 589 HelpText<"Include comments from within macros in preprocessed output">, 590 MarshallingInfoFlag<PreprocessorOutputOpts<"ShowMacroComments">>; 591def C : Flag<["-"], "C">, Flags<[CC1Option]>, Group<Preprocessor_Group>, 592 HelpText<"Include comments in preprocessed output">, 593 MarshallingInfoFlag<PreprocessorOutputOpts<"ShowComments">>; 594def D : JoinedOrSeparate<["-"], "D">, Group<Preprocessor_Group>, 595 Flags<[CC1Option, FlangOption, FC1Option]>, MetaVarName<"<macro>=<value>">, 596 HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">; 597def E : Flag<["-"], "E">, Flags<[NoXarchOption,CC1Option, FlangOption, FC1Option]>, Group<Action_Group>, 598 HelpText<"Only run the preprocessor">; 599def F : JoinedOrSeparate<["-"], "F">, Flags<[RenderJoined,CC1Option]>, 600 HelpText<"Add directory to framework include search path">; 601def G : JoinedOrSeparate<["-"], "G">, Flags<[NoXarchOption]>, Group<m_Group>, 602 MetaVarName<"<size>">, HelpText<"Put objects of at most <size> bytes " 603 "into small data section (MIPS / Hexagon)">; 604def G_EQ : Joined<["-"], "G=">, Flags<[NoXarchOption]>, Group<m_Group>, Alias<G>; 605def H : Flag<["-"], "H">, Flags<[CC1Option]>, Group<Preprocessor_Group>, 606 HelpText<"Show header includes and nesting depth">, 607 MarshallingInfoFlag<DependencyOutputOpts<"ShowHeaderIncludes">>; 608def I_ : Flag<["-"], "I-">, Group<I_Group>, 609 HelpText<"Restrict all prior -I flags to double-quoted inclusion and " 610 "remove current directory from include path">; 611def I : JoinedOrSeparate<["-"], "I">, Group<I_Group>, 612 Flags<[CC1Option,CC1AsOption,FlangOption,FC1Option]>, MetaVarName<"<dir>">, 613 HelpText<"Add directory to the end of the list of include search paths">, 614 DocBrief<[{Add directory to include search path. For C++ inputs, if 615there are multiple -I options, these directories are searched 616in the order they are given before the standard system directories 617are searched. If the same directory is in the SYSTEM include search 618paths, for example if also specified with -isystem, the -I option 619will be ignored}]>; 620def L : JoinedOrSeparate<["-"], "L">, Flags<[RenderJoined]>, Group<Link_Group>, 621 MetaVarName<"<dir>">, HelpText<"Add directory to library search path">; 622def MD : Flag<["-"], "MD">, Group<M_Group>, 623 HelpText<"Write a depfile containing user and system headers">; 624def MMD : Flag<["-"], "MMD">, Group<M_Group>, 625 HelpText<"Write a depfile containing user headers">; 626def M : Flag<["-"], "M">, Group<M_Group>, 627 HelpText<"Like -MD, but also implies -E and writes to stdout by default">; 628def MM : Flag<["-"], "MM">, Group<M_Group>, 629 HelpText<"Like -MMD, but also implies -E and writes to stdout by default">; 630def MF : JoinedOrSeparate<["-"], "MF">, Group<M_Group>, 631 HelpText<"Write depfile output from -MMD, -MD, -MM, or -M to <file>">, 632 MetaVarName<"<file>">; 633def MG : Flag<["-"], "MG">, Group<M_Group>, Flags<[CC1Option]>, 634 HelpText<"Add missing headers to depfile">, 635 MarshallingInfoFlag<DependencyOutputOpts<"AddMissingHeaderDeps">>; 636def MJ : JoinedOrSeparate<["-"], "MJ">, Group<M_Group>, 637 HelpText<"Write a compilation database entry per input">; 638def MP : Flag<["-"], "MP">, Group<M_Group>, Flags<[CC1Option]>, 639 HelpText<"Create phony target for each dependency (other than main file)">, 640 MarshallingInfoFlag<DependencyOutputOpts<"UsePhonyTargets">>; 641def MQ : JoinedOrSeparate<["-"], "MQ">, Group<M_Group>, Flags<[CC1Option]>, 642 HelpText<"Specify name of main file output to quote in depfile">; 643def MT : JoinedOrSeparate<["-"], "MT">, Group<M_Group>, Flags<[CC1Option]>, 644 HelpText<"Specify name of main file output in depfile">, 645 MarshallingInfoStringVector<DependencyOutputOpts<"Targets">>; 646def MV : Flag<["-"], "MV">, Group<M_Group>, Flags<[CC1Option]>, 647 HelpText<"Use NMake/Jom format for the depfile">, 648 MarshallingInfoFlag<DependencyOutputOpts<"OutputFormat">, "DependencyOutputFormat::Make">, 649 Normalizer<"makeFlagToValueNormalizer(DependencyOutputFormat::NMake)">; 650def Mach : Flag<["-"], "Mach">, Group<Link_Group>; 651def O0 : Flag<["-"], "O0">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>; 652def O4 : Flag<["-"], "O4">, Group<O_Group>, Flags<[CC1Option, HelpHidden]>; 653def ObjCXX : Flag<["-"], "ObjC++">, Flags<[NoXarchOption]>, 654 HelpText<"Treat source input files as Objective-C++ inputs">; 655def ObjC : Flag<["-"], "ObjC">, Flags<[NoXarchOption]>, 656 HelpText<"Treat source input files as Objective-C inputs">; 657def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>; 658def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["1"]>; 659def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>; 660def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>, 661 HelpText<"Disable linemarker output in -E mode">, 662 MarshallingInfoNegativeFlag<PreprocessorOutputOpts<"ShowLineMarkers">>; 663def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>, 664 HelpText<"Emit metadata containing compiler name and version">; 665def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>, 666 HelpText<"Do not emit metadata containing compiler name and version">; 667def : Flag<["-"], "fident">, Group<f_Group>, Alias<Qy>, Flags<[CC1Option]>; 668def : Flag<["-"], "fno-ident">, Group<f_Group>, Alias<Qn>, Flags<[CC1Option]>; 669def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[NoXarchOption, CoreOption]>, 670 HelpText<"Don't emit warning for unused driver arguments">; 671def Q : Flag<["-"], "Q">, IgnoredGCCCompat; 672def Rpass_EQ : Joined<["-"], "Rpass=">, Group<R_value_Group>, Flags<[CC1Option]>, 673 HelpText<"Report transformations performed by optimization passes whose " 674 "name matches the given POSIX regular expression">; 675def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">, Group<R_value_Group>, 676 Flags<[CC1Option]>, 677 HelpText<"Report missed transformations by optimization passes whose " 678 "name matches the given POSIX regular expression">; 679def Rpass_analysis_EQ : Joined<["-"], "Rpass-analysis=">, Group<R_value_Group>, 680 Flags<[CC1Option]>, 681 HelpText<"Report transformation analysis from optimization passes whose " 682 "name matches the given POSIX regular expression">; 683def R_Joined : Joined<["-"], "R">, Group<R_Group>, Flags<[CC1Option, CoreOption]>, 684 MetaVarName<"<remark>">, HelpText<"Enable the specified remark">; 685def S : Flag<["-"], "S">, Flags<[NoXarchOption,CC1Option]>, Group<Action_Group>, 686 HelpText<"Only run preprocess and compilation steps">; 687def Tbss : JoinedOrSeparate<["-"], "Tbss">, Group<T_Group>, 688 MetaVarName<"<addr>">, HelpText<"Set starting address of BSS to <addr>">; 689def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>, 690 MetaVarName<"<addr>">, HelpText<"Set starting address of DATA to <addr>">; 691def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>, 692 MetaVarName<"<addr>">, HelpText<"Set starting address of TEXT to <addr>">; 693def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>, 694 MetaVarName<"<script>">, HelpText<"Specify <script> as linker script">; 695def U : JoinedOrSeparate<["-"], "U">, Group<Preprocessor_Group>, 696 Flags<[CC1Option, FlangOption, FC1Option]>, MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">; 697def V : JoinedOrSeparate<["-"], "V">, Flags<[NoXarchOption, Unsupported]>; 698def Wa_COMMA : CommaJoined<["-"], "Wa,">, 699 HelpText<"Pass the comma separated arguments in <arg> to the assembler">, 700 MetaVarName<"<arg>">; 701def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>; 702def WCL4 : Flag<["-"], "WCL4">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>; 703def Wdeprecated : Flag<["-"], "Wdeprecated">, Group<W_Group>, Flags<[CC1Option]>, 704 HelpText<"Enable warnings for deprecated constructs and define __DEPRECATED">; 705def Wno_deprecated : Flag<["-"], "Wno-deprecated">, Group<W_Group>, Flags<[CC1Option]>; 706def Wl_COMMA : CommaJoined<["-"], "Wl,">, Flags<[LinkerInput, RenderAsInput]>, 707 HelpText<"Pass the comma separated arguments in <arg> to the linker">, 708 MetaVarName<"<arg>">, Group<Link_Group>; 709// FIXME: This is broken; these should not be Joined arguments. 710def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Group<W_Group>, 711 Flags<[CC1Option]>; 712def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>, 713 Flags<[CC1Option]>; 714def Wp_COMMA : CommaJoined<["-"], "Wp,">, 715 HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">, 716 MetaVarName<"<arg>">, Group<Preprocessor_Group>; 717def Wundef_prefix_EQ : CommaJoined<["-"], "Wundef-prefix=">, Group<W_value_Group>, 718 Flags<[CC1Option, CoreOption, HelpHidden]>, MetaVarName<"<arg>">, 719 HelpText<"Enable warnings for undefined macros with a prefix in the comma separated list <arg>">, 720 MarshallingInfoStringVector<DiagnosticOpts<"UndefPrefixes">>; 721def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>; 722def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>; 723def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>, 724 MetaVarName<"<warning>">, HelpText<"Enable the specified warning">; 725def Xanalyzer : Separate<["-"], "Xanalyzer">, 726 HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">, 727 Group<StaticAnalyzer_Group>; 728def Xarch__ : JoinedAndSeparate<["-"], "Xarch_">, Flags<[NoXarchOption]>; 729def Xarch_host : Separate<["-"], "Xarch_host">, Flags<[NoXarchOption]>, 730 HelpText<"Pass <arg> to the CUDA/HIP host compilation">, MetaVarName<"<arg>">; 731def Xarch_device : Separate<["-"], "Xarch_device">, Flags<[NoXarchOption]>, 732 HelpText<"Pass <arg> to the CUDA/HIP device compilation">, MetaVarName<"<arg>">; 733def Xassembler : Separate<["-"], "Xassembler">, 734 HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">, 735 Group<CompileOnly_Group>; 736def Xclang : Separate<["-"], "Xclang">, 737 HelpText<"Pass <arg> to the clang compiler">, MetaVarName<"<arg>">, 738 Flags<[NoXarchOption, CoreOption]>, Group<CompileOnly_Group>; 739def Xcuda_fatbinary : Separate<["-"], "Xcuda-fatbinary">, 740 HelpText<"Pass <arg> to fatbinary invocation">, MetaVarName<"<arg>">; 741def Xcuda_ptxas : Separate<["-"], "Xcuda-ptxas">, 742 HelpText<"Pass <arg> to the ptxas assembler">, MetaVarName<"<arg>">; 743def Xopenmp_target : Separate<["-"], "Xopenmp-target">, 744 HelpText<"Pass <arg> to the target offloading toolchain.">, MetaVarName<"<arg>">; 745def Xopenmp_target_EQ : JoinedAndSeparate<["-"], "Xopenmp-target=">, 746 HelpText<"Pass <arg> to the target offloading toolchain identified by <triple>.">, 747 MetaVarName<"<triple> <arg>">; 748def z : Separate<["-"], "z">, Flags<[LinkerInput, RenderAsInput]>, 749 HelpText<"Pass -z <arg> to the linker">, MetaVarName<"<arg>">, 750 Group<Link_Group>; 751def Xlinker : Separate<["-"], "Xlinker">, Flags<[LinkerInput, RenderAsInput]>, 752 HelpText<"Pass <arg> to the linker">, MetaVarName<"<arg>">, 753 Group<Link_Group>; 754def Xpreprocessor : Separate<["-"], "Xpreprocessor">, Group<Preprocessor_Group>, 755 HelpText<"Pass <arg> to the preprocessor">, MetaVarName<"<arg>">; 756def X_Flag : Flag<["-"], "X">, Group<Link_Group>; 757def X_Joined : Joined<["-"], "X">, IgnoredGCCCompat; 758def Z_Flag : Flag<["-"], "Z">, Group<Link_Group>; 759// FIXME: All we do with this is reject it. Remove. 760def Z_Joined : Joined<["-"], "Z">; 761def all__load : Flag<["-"], "all_load">; 762def allowable__client : Separate<["-"], "allowable_client">; 763def ansi : Flag<["-", "--"], "ansi">, Group<CompileOnly_Group>; 764def arch__errors__fatal : Flag<["-"], "arch_errors_fatal">; 765def arch : Separate<["-"], "arch">, Flags<[NoXarchOption]>; 766def arch__only : Separate<["-"], "arch_only">; 767def a : Joined<["-"], "a">; 768def autocomplete : Joined<["--"], "autocomplete=">; 769def bind__at__load : Flag<["-"], "bind_at_load">; 770def bundle__loader : Separate<["-"], "bundle_loader">; 771def bundle : Flag<["-"], "bundle">; 772def b : JoinedOrSeparate<["-"], "b">, Flags<[Unsupported]>; 773def cl_opt_disable : Flag<["-"], "cl-opt-disable">, Group<opencl_Group>, Flags<[CC1Option]>, 774 HelpText<"OpenCL only. This option disables all optimizations. By default optimizations are enabled.">; 775def cl_strict_aliasing : Flag<["-"], "cl-strict-aliasing">, Group<opencl_Group>, Flags<[CC1Option]>, 776 HelpText<"OpenCL only. This option is added for compatibility with OpenCL 1.0.">; 777def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group<opencl_Group>, Flags<[CC1Option]>, 778 HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">, 779 MarshallingInfoFlag<LangOpts<"SinglePrecisionConstants">>; 780def cl_finite_math_only : Flag<["-"], "cl-finite-math-only">, Group<opencl_Group>, Flags<[CC1Option]>, 781 HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">, 782 MarshallingInfoFlag<LangOpts<"CLFiniteMathOnly">>; 783def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_Group>, Flags<[CC1Option]>, 784 HelpText<"OpenCL only. Generate kernel argument metadata.">, 785 MarshallingInfoFlag<CodeGenOpts<"EmitOpenCLArgMetadata">>; 786def cl_unsafe_math_optimizations : Flag<["-"], "cl-unsafe-math-optimizations">, Group<opencl_Group>, Flags<[CC1Option]>, 787 HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.">, 788 MarshallingInfoFlag<LangOpts<"CLUnsafeMath">>; 789def cl_fast_relaxed_math : Flag<["-"], "cl-fast-relaxed-math">, Group<opencl_Group>, Flags<[CC1Option]>, 790 HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.">, 791 MarshallingInfoFlag<LangOpts<"FastRelaxedMath">>; 792def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC1Option]>, 793 HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">, 794 MarshallingInfoFlag<CodeGenOpts<"LessPreciseFPMAD">>, 795 ImpliedByAnyOf<[cl_unsafe_math_optimizations.KeyPath, cl_fast_relaxed_math.KeyPath]>; 796def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>, 797 HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">, 798 MarshallingInfoFlag<LangOpts<"CLNoSignedZero">>; 799def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>, 800 HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.0,CL1.0,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,cl3.0,CL3.0,clc++,CLC++">; 801def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>, 802 HelpText<"OpenCL only. Allow denormals to be flushed to zero.">; 803def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>, 804 HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">, 805 MarshallingInfoFlag<CodeGenOpts<"CorrectlyRoundedDivSqrt">>; 806def cl_uniform_work_group_size : Flag<["-"], "cl-uniform-work-group-size">, Group<opencl_Group>, Flags<[CC1Option]>, 807 HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">, 808 MarshallingInfoFlag<CodeGenOpts<"UniformWGSize">>; 809def client__name : JoinedOrSeparate<["-"], "client_name">; 810def combine : Flag<["-", "--"], "combine">, Flags<[NoXarchOption, Unsupported]>; 811def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">; 812def config : Separate<["--"], "config">, Flags<[NoXarchOption]>, 813 HelpText<"Specifies configuration file">; 814def config_system_dir_EQ : Joined<["--"], "config-system-dir=">, Flags<[NoXarchOption, HelpHidden]>, 815 HelpText<"System directory for configuration files">; 816def config_user_dir_EQ : Joined<["--"], "config-user-dir=">, Flags<[NoXarchOption, HelpHidden]>, 817 HelpText<"User directory for configuration files">; 818def coverage : Flag<["-", "--"], "coverage">, Group<Link_Group>, Flags<[CoreOption]>; 819def cpp_precomp : Flag<["-"], "cpp-precomp">, Group<clang_ignored_f_Group>; 820def current__version : JoinedOrSeparate<["-"], "current_version">; 821def cxx_isystem : JoinedOrSeparate<["-"], "cxx-isystem">, Group<clang_i_Group>, 822 HelpText<"Add directory to the C++ SYSTEM include search path">, Flags<[CC1Option]>, 823 MetaVarName<"<directory>">; 824def c : Flag<["-"], "c">, Flags<[NoXarchOption, FlangOption]>, Group<Action_Group>, 825 HelpText<"Only run preprocess, compile, and assemble steps">; 826def fconvergent_functions : Flag<["-"], "fconvergent-functions">, Group<f_Group>, Flags<[CC1Option]>, 827 HelpText<"Assume functions may be convergent">; 828 829def gpu_use_aux_triple_only : Flag<["--"], "gpu-use-aux-triple-only">, 830 InternalDriverOpt, HelpText<"Prepare '-aux-triple' only without populating " 831 "'-aux-target-cpu' and '-aux-target-feature'.">; 832def cuda_device_only : Flag<["--"], "cuda-device-only">, 833 HelpText<"Compile CUDA code for device only">; 834def cuda_host_only : Flag<["--"], "cuda-host-only">, 835 HelpText<"Compile CUDA code for host only. Has no effect on non-CUDA " 836 "compilations.">; 837def cuda_compile_host_device : Flag<["--"], "cuda-compile-host-device">, 838 HelpText<"Compile CUDA code for both host and device (default). Has no " 839 "effect on non-CUDA compilations.">; 840def cuda_include_ptx_EQ : Joined<["--"], "cuda-include-ptx=">, Flags<[NoXarchOption]>, 841 HelpText<"Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.">; 842def no_cuda_include_ptx_EQ : Joined<["--"], "no-cuda-include-ptx=">, Flags<[NoXarchOption]>, 843 HelpText<"Do not include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.">; 844def offload_arch_EQ : Joined<["--"], "offload-arch=">, Flags<[NoXarchOption]>, 845 HelpText<"CUDA offloading device architecture (e.g. sm_35), or HIP offloading target ID in the form of a " 846 "device architecture followed by target ID features delimited by a colon. Each target ID feature " 847 "is a pre-defined string followed by a plus or minus sign (e.g. gfx908:xnack+:sramecc-). May be " 848 "specified more than once.">; 849def cuda_gpu_arch_EQ : Joined<["--"], "cuda-gpu-arch=">, Flags<[NoXarchOption]>, 850 Alias<offload_arch_EQ>; 851def hip_link : Flag<["--"], "hip-link">, 852 HelpText<"Link clang-offload-bundler bundles for HIP">; 853def no_offload_arch_EQ : Joined<["--"], "no-offload-arch=">, Flags<[NoXarchOption]>, 854 HelpText<"Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. " 855 "'all' resets the list to its default value.">; 856def emit_static_lib : Flag<["--"], "emit-static-lib">, 857 HelpText<"Enable linker job to emit a static library.">; 858def no_cuda_gpu_arch_EQ : Joined<["--"], "no-cuda-gpu-arch=">, Flags<[NoXarchOption]>, 859 Alias<no_offload_arch_EQ>; 860def cuda_noopt_device_debug : Flag<["--"], "cuda-noopt-device-debug">, 861 HelpText<"Enable device-side debug info generation. Disables ptxas optimizations.">; 862def no_cuda_version_check : Flag<["--"], "no-cuda-version-check">, 863 HelpText<"Don't error out if the detected version of the CUDA install is " 864 "too low for the requested CUDA gpu architecture.">; 865def no_cuda_noopt_device_debug : Flag<["--"], "no-cuda-noopt-device-debug">; 866def cuda_path_EQ : Joined<["--"], "cuda-path=">, Group<i_Group>, 867 HelpText<"CUDA installation path">; 868def cuda_path_ignore_env : Flag<["--"], "cuda-path-ignore-env">, Group<i_Group>, 869 HelpText<"Ignore environment variables to detect CUDA installation">; 870def ptxas_path_EQ : Joined<["--"], "ptxas-path=">, Group<i_Group>, 871 HelpText<"Path to ptxas (used for compiling CUDA code)">; 872def fcuda_flush_denormals_to_zero : Flag<["-"], "fcuda-flush-denormals-to-zero">, 873 HelpText<"Flush denormal floating point values to zero in CUDA device mode.">; 874def fno_cuda_flush_denormals_to_zero : Flag<["-"], "fno-cuda-flush-denormals-to-zero">; 875defm gpu_rdc : BoolFOption<"gpu-rdc", 876 LangOpts<"GPURelocatableDeviceCode">, DefaultFalse, 877 PosFlag<SetTrue, [CC1Option], "Generate relocatable device code, also known as separate compilation mode">, 878 NegFlag<SetFalse>>; 879def : Flag<["-"], "fcuda-rdc">, Alias<fgpu_rdc>; 880def : Flag<["-"], "fno-cuda-rdc">, Alias<fno_gpu_rdc>; 881defm cuda_short_ptr : OptInFFlag<"cuda-short-ptr", 882 "Use 32-bit pointers for accessing const/local/shared address spaces", "", "", 883 [], TargetOpts<"NVPTXUseShortPointers">>; 884def rocm_path_EQ : Joined<["--"], "rocm-path=">, Group<i_Group>, 885 HelpText<"ROCm installation path, used for finding and automatically linking required bitcode libraries.">; 886def rocm_device_lib_path_EQ : Joined<["--"], "rocm-device-lib-path=">, Group<Link_Group>, 887 HelpText<"ROCm device library path. Alternative to rocm-path.">; 888def : Joined<["--"], "hip-device-lib-path=">, Alias<rocm_device_lib_path_EQ>; 889def hip_device_lib_EQ : Joined<["--"], "hip-device-lib=">, Group<Link_Group>, 890 HelpText<"HIP device library">; 891def hip_version_EQ : Joined<["--"], "hip-version=">, 892 HelpText<"HIP version in the format of major.minor.patch">; 893def fhip_dump_offload_linker_script : Flag<["-"], "fhip-dump-offload-linker-script">, 894 Group<f_Group>, Flags<[NoArgumentUnused, HelpHidden]>; 895defm hip_new_launch_api : BoolFOption<"hip-new-launch-api", 896 LangOpts<"HIPUseNewLaunchAPI">, DefaultFalse, 897 PosFlag<SetTrue, [CC1Option], "Use">, NegFlag<SetFalse, [], "Don't use">, 898 BothFlags<[], " new kernel launching API for HIP">>; 899defm gpu_allow_device_init : BoolFOption<"gpu-allow-device-init", 900 LangOpts<"GPUAllowDeviceInit">, DefaultFalse, 901 PosFlag<SetTrue, [CC1Option], "Allow">, NegFlag<SetFalse, [], "Don't allow">, 902 BothFlags<[], " device side init function in HIP">>, 903 ShouldParseIf<hip.KeyPath>; 904defm gpu_defer_diag : BoolFOption<"gpu-defer-diag", 905 LangOpts<"GPUDeferDiag">, DefaultFalse, 906 PosFlag<SetTrue, [CC1Option], "Defer">, NegFlag<SetFalse, [], "Don't defer">, 907 BothFlags<[], " host/device related diagnostic messages for CUDA/HIP">>; 908defm gpu_exclude_wrong_side_overloads : BoolFOption<"gpu-exclude-wrong-side-overloads", 909 LangOpts<"GPUExcludeWrongSideOverloads">, DefaultFalse, 910 PosFlag<SetTrue, [CC1Option], "Always exclude wrong side overloads">, 911 NegFlag<SetFalse, [], "Exclude wrong side overloads only if there are same side overloads">, 912 BothFlags<[HelpHidden], " in overloading resolution for CUDA/HIP">>; 913def gpu_max_threads_per_block_EQ : Joined<["--"], "gpu-max-threads-per-block=">, 914 Flags<[CC1Option]>, 915 HelpText<"Default max threads per block for kernel launch bounds for HIP">, 916 MarshallingInfoStringInt<LangOpts<"GPUMaxThreadsPerBlock">, "256">, 917 ShouldParseIf<hip.KeyPath>; 918def gpu_instrument_lib_EQ : Joined<["--"], "gpu-instrument-lib=">, 919 HelpText<"Instrument device library for HIP, which is a LLVM bitcode containing " 920 "__cyg_profile_func_enter and __cyg_profile_func_exit">; 921def libomptarget_nvptx_bc_path_EQ : Joined<["--"], "libomptarget-nvptx-bc-path=">, Group<i_Group>, 922 HelpText<"Path to libomptarget-nvptx bitcode library">; 923def dD : Flag<["-"], "dD">, Group<d_Group>, Flags<[CC1Option]>, 924 HelpText<"Print macro definitions in -E mode in addition to normal output">; 925def dI : Flag<["-"], "dI">, Group<d_Group>, Flags<[CC1Option]>, 926 HelpText<"Print include directives in -E mode in addition to normal output">, 927 MarshallingInfoFlag<PreprocessorOutputOpts<"ShowIncludeDirectives">>; 928def dM : Flag<["-"], "dM">, Group<d_Group>, Flags<[CC1Option]>, 929 HelpText<"Print macro definitions in -E mode instead of normal output">; 930def dead__strip : Flag<["-"], "dead_strip">; 931def dependency_file : Separate<["-"], "dependency-file">, Flags<[CC1Option]>, 932 HelpText<"Filename (or -) to write dependency output to">, 933 MarshallingInfoString<DependencyOutputOpts<"OutputFile">>; 934def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>, 935 HelpText<"Filename to write DOT-formatted header dependencies to">, 936 MarshallingInfoString<DependencyOutputOpts<"DOTOutputFile">>; 937def module_dependency_dir : Separate<["-"], "module-dependency-dir">, 938 Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">, 939 MarshallingInfoString<DependencyOutputOpts<"ModuleDependencyOutputDir">>; 940def dsym_dir : JoinedOrSeparate<["-"], "dsym-dir">, 941 Flags<[NoXarchOption, RenderAsInput]>, 942 HelpText<"Directory to output dSYM's (if any) to">, MetaVarName<"<dir>">; 943def dumpmachine : Flag<["-"], "dumpmachine">; 944def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>; 945def dumpversion : Flag<["-"], "dumpversion">; 946def dylib__file : Separate<["-"], "dylib_file">; 947def dylinker__install__name : JoinedOrSeparate<["-"], "dylinker_install_name">; 948def dylinker : Flag<["-"], "dylinker">; 949def dynamiclib : Flag<["-"], "dynamiclib">; 950def dynamic : Flag<["-"], "dynamic">, Flags<[NoArgumentUnused]>; 951def d_Flag : Flag<["-"], "d">, Group<d_Group>; 952def d_Joined : Joined<["-"], "d">, Group<d_Group>; 953def emit_ast : Flag<["-"], "emit-ast">, 954 HelpText<"Emit Clang AST files for source inputs">; 955def emit_llvm : Flag<["-"], "emit-llvm">, Flags<[CC1Option]>, Group<Action_Group>, 956 HelpText<"Use the LLVM representation for assembler and object files">; 957def emit_interface_stubs : Flag<["-"], "emit-interface-stubs">, Flags<[CC1Option]>, Group<Action_Group>, 958 HelpText<"Generate Interface Stub Files.">; 959def emit_merged_ifs : Flag<["-"], "emit-merged-ifs">, 960 Flags<[CC1Option]>, Group<Action_Group>, 961 HelpText<"Generate Interface Stub Files, emit merged text not binary.">; 962def interface_stub_version_EQ : JoinedOrSeparate<["-"], "interface-stub-version=">, Flags<[CC1Option]>; 963def exported__symbols__list : Separate<["-"], "exported_symbols_list">; 964def e : JoinedOrSeparate<["-"], "e">, Flags<[LinkerInput]>, Group<Link_Group>; 965def fmax_tokens_EQ : Joined<["-"], "fmax-tokens=">, Group<f_Group>, Flags<[CC1Option]>, 966 HelpText<"Max total number of preprocessed tokens for -Wmax-tokens.">, 967 MarshallingInfoStringInt<LangOpts<"MaxTokens">>; 968def fPIC : Flag<["-"], "fPIC">, Group<f_Group>; 969def fno_PIC : Flag<["-"], "fno-PIC">, Group<f_Group>; 970def fPIE : Flag<["-"], "fPIE">, Group<f_Group>; 971def fno_PIE : Flag<["-"], "fno-PIE">, Group<f_Group>; 972defm access_control : BoolFOption<"access-control", 973 LangOpts<"AccessControl">, DefaultTrue, 974 NegFlag<SetFalse, [CC1Option], "Disable C++ access control">, 975 PosFlag<SetTrue>>; 976def falign_functions : Flag<["-"], "falign-functions">, Group<f_Group>; 977def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<f_Group>; 978def fno_align_functions: Flag<["-"], "fno-align-functions">, Group<f_Group>; 979defm allow_editor_placeholders : BoolFOption<"allow-editor-placeholders", 980 LangOpts<"AllowEditorPlaceholders">, DefaultFalse, 981 PosFlag<SetTrue, [CC1Option], "Treat editor placeholders as valid source code">, 982 NegFlag<SetFalse>>; 983def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>; 984def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>, 985 HelpText<"Use Apple's kernel extensions ABI">, 986 MarshallingInfoFlag<LangOpts<"AppleKext">>; 987defm apple_pragma_pack : BoolFOption<"apple-pragma-pack", 988 LangOpts<"ApplePragmaPack">, DefaultFalse, 989 PosFlag<SetTrue, [CC1Option], "Enable Apple gcc-compatible #pragma pack handling">, 990 NegFlag<SetFalse>>; 991def fxl_pragma_pack : Flag<["-"], "fxl-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>, 992 HelpText<"Enable IBM XL #pragma pack handling">; 993def shared_libsan : Flag<["-"], "shared-libsan">, 994 HelpText<"Dynamically link the sanitizer runtime">; 995def static_libsan : Flag<["-"], "static-libsan">, 996 HelpText<"Statically link the sanitizer runtime">; 997def : Flag<["-"], "shared-libasan">, Alias<shared_libsan>; 998def fasm : Flag<["-"], "fasm">, Group<f_Group>; 999 1000defm asm_blocks : OptInFFlag<"asm-blocks", "">; 1001 1002def fassume_sane_operator_new : Flag<["-"], "fassume-sane-operator-new">, Group<f_Group>; 1003def fastcp : Flag<["-"], "fastcp">, Group<f_Group>; 1004def fastf : Flag<["-"], "fastf">, Group<f_Group>; 1005def fast : Flag<["-"], "fast">, Group<f_Group>; 1006def fasynchronous_unwind_tables : Flag<["-"], "fasynchronous-unwind-tables">, Group<f_Group>; 1007 1008def fdouble_square_bracket_attributes : Flag<[ "-" ], "fdouble-square-bracket-attributes">, 1009 Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, 1010 HelpText<"Enable '[[]]' attributes in all C and C++ language modes">; 1011def fno_double_square_bracket_attributes : Flag<[ "-" ], "fno-double-square-bracket-attributes">, 1012 Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, 1013 HelpText<"Disable '[[]]' attributes in all C and C++ language modes">; 1014 1015defm autolink : BoolFOption<"autolink", 1016 CodeGenOpts<"Autolink">, DefaultTrue, 1017 NegFlag<SetFalse, [CC1Option], "Disable generation of linker directives for automatic library linking">, 1018 PosFlag<SetTrue>>; 1019 1020// C++ Coroutines TS 1021defm coroutines_ts : OptInFFlag<"coroutines-ts", "Enable support for the C++ Coroutines TS">; 1022 1023def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">, 1024 Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">, 1025 HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">, 1026 Values<"off,all,bitcode,marker">, NormalizedValuesScope<"CodeGenOptions">, 1027 NormalizedValues<["Embed_Off", "Embed_All", "Embed_Bitcode", "Embed_Marker"]>, 1028 MarshallingInfoString<CodeGenOpts<"EmbedBitcode">, "Embed_Off">, AutoNormalizeEnum; 1029def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>, 1030 Alias<fembed_bitcode_EQ>, AliasArgs<["all"]>, 1031 HelpText<"Embed LLVM IR bitcode as data">; 1032def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">, 1033 Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>, 1034 HelpText<"Embed placeholder LLVM IR data as a marker">; 1035defm gnu_inline_asm : BoolFOption<"gnu-inline-asm", 1036 LangOpts<"GNUAsm">, DefaultTrue, 1037 NegFlag<SetFalse, [CC1Option], "Disable GNU style inline asm">, PosFlag<SetTrue>>; 1038 1039def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>, 1040 Flags<[CoreOption]>; 1041def fno_profile_sample_use : Flag<["-"], "fno-profile-sample-use">, Group<f_Group>, 1042 Flags<[CoreOption]>; 1043def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">, 1044 Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, 1045 HelpText<"Enable sample-based profile guided optimizations">, 1046 MarshallingInfoString<CodeGenOpts<"SampleProfileFile">>; 1047def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">, 1048 Group<f_Group>, Flags<[NoXarchOption, CC1Option]>, 1049 HelpText<"Specifies that the sample profile is accurate">, 1050 DocBrief<[{Specifies that the sample profile is accurate. If the sample 1051 profile is accurate, callsites without profile samples are marked 1052 as cold. Otherwise, treat callsites without profile samples as if 1053 we have no profile}]>, 1054 MarshallingInfoFlag<CodeGenOpts<"ProfileSampleAccurate">>; 1055def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">, 1056 Group<f_Group>, Flags<[NoXarchOption]>; 1057def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>, 1058 Alias<fprofile_sample_use>; 1059def fno_auto_profile : Flag<["-"], "fno-auto-profile">, Group<f_Group>, 1060 Alias<fno_profile_sample_use>; 1061def fauto_profile_EQ : Joined<["-"], "fauto-profile=">, 1062 Alias<fprofile_sample_use_EQ>; 1063def fauto_profile_accurate : Flag<["-"], "fauto-profile-accurate">, 1064 Group<f_Group>, Alias<fprofile_sample_accurate>; 1065def fno_auto_profile_accurate : Flag<["-"], "fno-auto-profile-accurate">, 1066 Group<f_Group>, Alias<fno_profile_sample_accurate>; 1067def fdebug_compilation_dir : Separate<["-"], "fdebug-compilation-dir">, 1068 Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>, 1069 HelpText<"The compilation directory to embed in the debug info.">, 1070 MarshallingInfoString<CodeGenOpts<"DebugCompilationDir">>; 1071def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">, 1072 Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>, 1073 Alias<fdebug_compilation_dir>; 1074defm debug_info_for_profiling : BoolFOption<"debug-info-for-profiling", 1075 CodeGenOpts<"DebugInfoForProfiling">, DefaultFalse, 1076 PosFlag<SetTrue, [CC1Option], "Emit extra debug info to make sample profile more accurate">, 1077 NegFlag<SetFalse>>; 1078def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">, 1079 Group<f_Group>, Flags<[CoreOption]>, 1080 HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">; 1081def fprofile_instr_generate_EQ : Joined<["-"], "fprofile-instr-generate=">, 1082 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<file>">, 1083 HelpText<"Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)">; 1084def fprofile_instr_use : Flag<["-"], "fprofile-instr-use">, Group<f_Group>, 1085 Flags<[CoreOption]>; 1086def fprofile_instr_use_EQ : Joined<["-"], "fprofile-instr-use=">, 1087 Group<f_Group>, Flags<[CoreOption]>, 1088 HelpText<"Use instrumentation data for profile-guided optimization">; 1089def fprofile_remapping_file_EQ : Joined<["-"], "fprofile-remapping-file=">, 1090 Group<f_Group>, Flags<[CC1Option, CoreOption]>, MetaVarName<"<file>">, 1091 HelpText<"Use the remappings described in <file> to match the profile data against names in the program">, 1092 MarshallingInfoString<CodeGenOpts<"ProfileRemappingFile">>; 1093def fprofile_remapping_file : Separate<["-"], "fprofile-remapping-file">, 1094 Group<f_Group>, Flags<[CoreOption]>, Alias<fprofile_remapping_file_EQ>; 1095defm coverage_mapping : BoolFOption<"coverage-mapping", 1096 CodeGenOpts<"CoverageMapping">, DefaultFalse, 1097 PosFlag<SetTrue, [CC1Option], "Generate coverage mapping to enable code coverage analysis">, 1098 NegFlag<SetFalse, [], "Disable code coverage analysis">, BothFlags<[CoreOption]>>; 1099def fprofile_generate : Flag<["-"], "fprofile-generate">, 1100 Group<f_Group>, Flags<[CoreOption]>, 1101 HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">; 1102def fprofile_generate_EQ : Joined<["-"], "fprofile-generate=">, 1103 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">, 1104 HelpText<"Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">; 1105def fcs_profile_generate : Flag<["-"], "fcs-profile-generate">, 1106 Group<f_Group>, Flags<[CoreOption]>, 1107 HelpText<"Generate instrumented code to collect context sensitive execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">; 1108def fcs_profile_generate_EQ : Joined<["-"], "fcs-profile-generate=">, 1109 Group<f_Group>, Flags<[CoreOption]>, MetaVarName<"<directory>">, 1110 HelpText<"Generate instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)">; 1111def fprofile_use : Flag<["-"], "fprofile-use">, Group<f_Group>, 1112 Alias<fprofile_instr_use>; 1113def fprofile_use_EQ : Joined<["-"], "fprofile-use=">, 1114 Group<f_Group>, Flags<[NoXarchOption]>, MetaVarName<"<pathname>">, 1115 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>.">; 1116def fno_profile_instr_generate : Flag<["-"], "fno-profile-instr-generate">, 1117 Group<f_Group>, Flags<[CoreOption]>, 1118 HelpText<"Disable generation of profile instrumentation.">; 1119def fno_profile_generate : Flag<["-"], "fno-profile-generate">, 1120 Group<f_Group>, Flags<[CoreOption]>, 1121 HelpText<"Disable generation of profile instrumentation.">; 1122def fno_profile_instr_use : Flag<["-"], "fno-profile-instr-use">, 1123 Group<f_Group>, Flags<[CoreOption]>, 1124 HelpText<"Disable using instrumentation data for profile-guided optimization">; 1125def fno_profile_use : Flag<["-"], "fno-profile-use">, 1126 Alias<fno_profile_instr_use>; 1127defm profile_arcs : BoolFOption<"profile-arcs", 1128 CodeGenOpts<"EmitGcovArcs">, DefaultFalse, 1129 PosFlag<SetTrue, [CC1Option, LinkOption]>, NegFlag<SetFalse>>; 1130defm test_coverage : BoolFOption<"test-coverage", 1131 CodeGenOpts<"EmitGcovNotes">, DefaultFalse, 1132 PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>>; 1133def fprofile_filter_files_EQ : Joined<["-"], "fprofile-filter-files=">, 1134 Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1135 HelpText<"Instrument only functions from files where names match any regex separated by a semi-colon">, 1136 MarshallingInfoString<CodeGenOpts<"ProfileFilterFiles">>, 1137 ShouldParseIf<!strconcat(fprofile_arcs.KeyPath, "||", ftest_coverage.KeyPath)>; 1138def fprofile_exclude_files_EQ : Joined<["-"], "fprofile-exclude-files=">, 1139 Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1140 HelpText<"Instrument only functions from files where names don't match all the regexes separated by a semi-colon">, 1141 MarshallingInfoString<CodeGenOpts<"ProfileExcludeFiles">>, 1142 ShouldParseIf<!strconcat(fprofile_arcs.KeyPath, "||", ftest_coverage.KeyPath)>; 1143def fprofile_update_EQ : Joined<["-"], "fprofile-update=">, 1144 Group<f_Group>, Flags<[CC1Option, CoreOption]>, Values<"atomic,prefer-atomic,single">, 1145 MetaVarName<"<method>">, HelpText<"Set update method of profile counters (atomic,prefer-atomic,single)">, 1146 MarshallingInfoFlag<CodeGenOpts<"AtomicProfileUpdate">>; 1147defm pseudo_probe_for_profiling : BoolFOption<"pseudo-probe-for-profiling", 1148 CodeGenOpts<"PseudoProbeForProfiling">, DefaultFalse, 1149 PosFlag<SetTrue, [], "Emit">, NegFlag<SetFalse, [], "Do not emit">, 1150 BothFlags<[NoXarchOption, CC1Option], " pseudo probes for sample profiling">>; 1151def forder_file_instrumentation : Flag<["-"], "forder-file-instrumentation">, 1152 Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1153 HelpText<"Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">; 1154def fprofile_list_EQ : Joined<["-"], "fprofile-list=">, 1155 Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1156 HelpText<"Filename defining the list of functions/files to instrument">, 1157 MarshallingInfoStringVector<LangOpts<"ProfileListFiles">>; 1158 1159defm addrsig : BoolFOption<"addrsig", 1160 CodeGenOpts<"Addrsig">, DefaultFalse, 1161 PosFlag<SetTrue, [CC1Option], "Emit">, NegFlag<SetFalse, [], "Don't emit">, 1162 BothFlags<[CoreOption], " an address-significance table">>; 1163defm blocks : OptInFFlag<"blocks", "Enable the 'blocks' language feature", "", "", [CoreOption]>; 1164def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>; 1165defm borland_extensions : BoolFOption<"borland-extensions", 1166 LangOpts<"Borland">, DefaultFalse, 1167 PosFlag<SetTrue, [CC1Option], "Accept non-standard constructs supported by the Borland compiler">, 1168 NegFlag<SetFalse>>; 1169def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>, Flags<[CoreOption]>; 1170def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>, 1171 Flags<[NoXarchOption]>, HelpText<"Load the clang builtins module map file.">; 1172defm caret_diagnostics : BoolFOption<"caret-diagnostics", 1173 DiagnosticOpts<"ShowCarets">, DefaultTrue, 1174 NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue>>; 1175def fclang_abi_compat_EQ : Joined<["-"], "fclang-abi-compat=">, Group<f_clang_Group>, 1176 Flags<[CC1Option]>, MetaVarName<"<version>">, Values<"<major>.<minor>,latest">, 1177 HelpText<"Attempt to match the ABI of Clang <version>">; 1178def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>; 1179defm color_diagnostics : OptInFFlag<"color-diagnostics", "Enable", "Disable", " colors in diagnostics", 1180 [CoreOption, FlangOption]>; 1181def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>, 1182 Flags<[CoreOption, NoXarchOption]>; 1183def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>; 1184def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>, 1185 Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">, 1186 MarshallingInfoFlag<DiagnosticOpts<"UseANSIEscapeCodes">>; 1187def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>, 1188 HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">, 1189 MetaVarName<"<arg>">, MarshallingInfoStringVector<LangOpts<"CommentOpts.BlockCommandNames">>; 1190def fparse_all_comments : Flag<["-"], "fparse-all-comments">, Group<f_clang_Group>, Flags<[CC1Option]>, 1191 MarshallingInfoFlag<LangOpts<"CommentOpts.ParseAllComments">>; 1192def frecord_command_line : Flag<["-"], "frecord-command-line">, 1193 Group<f_clang_Group>; 1194def fno_record_command_line : Flag<["-"], "fno-record-command-line">, 1195 Group<f_clang_Group>; 1196def : Flag<["-"], "frecord-gcc-switches">, Alias<frecord_command_line>; 1197def : Flag<["-"], "fno-record-gcc-switches">, Alias<fno_record_command_line>; 1198def fcommon : Flag<["-"], "fcommon">, Group<f_Group>, 1199 Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">, 1200 MarshallingInfoNegativeFlag<CodeGenOpts<"NoCommon">>; 1201def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>; 1202defm complete_member_pointers : BoolOption<"f", "complete-member-pointers", 1203 LangOpts<"CompleteMemberPointers">, DefaultFalse, 1204 PosFlag<SetTrue, [CC1Option], "Require">, NegFlag<SetFalse, [], "Do not require">, 1205 BothFlags<[CoreOption], " member pointer base types to be complete if they" 1206 " would be significant under the Microsoft ABI">>, 1207 Group<f_clang_Group>; 1208def fcf_runtime_abi_EQ : Joined<["-"], "fcf-runtime-abi=">, Group<f_Group>, 1209 Flags<[CC1Option]>, Values<"unspecified,standalone,objc,swift,swift-5.0,swift-4.2,swift-4.1">, 1210 NormalizedValuesScope<"LangOptions::CoreFoundationABI">, 1211 NormalizedValues<["ObjectiveC", "ObjectiveC", "ObjectiveC", "Swift5_0", "Swift5_0", "Swift4_2", "Swift4_1"]>, 1212 MarshallingInfoString<LangOpts<"CFRuntime">, "ObjectiveC">, AutoNormalizeEnum; 1213defm constant_cfstrings : BoolFOption<"constant-cfstrings", 1214 LangOpts<"NoConstantCFStrings">, DefaultFalse, 1215 NegFlag<SetTrue, [CC1Option], "Disable creation of CodeFoundation-type constant strings">, 1216 PosFlag<SetFalse>>; 1217def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>; 1218def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>; 1219def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>; 1220def fexperimental_new_constant_interpreter : Flag<["-"], "fexperimental-new-constant-interpreter">, Group<f_Group>, 1221 HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>, 1222 MarshallingInfoFlag<LangOpts<"EnableNewConstInterp">>; 1223def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">, 1224 Group<f_Group>; 1225def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>, 1226 HelpText<"Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash">; 1227def fcrash_diagnostics_dir : Joined<["-"], "fcrash-diagnostics-dir=">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>; 1228def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>; 1229defm cxx_exceptions: BoolFOption<"cxx-exceptions", 1230 LangOpts<"CXXExceptions">, DefaultFalse, 1231 PosFlag<SetTrue, [CC1Option], "Enable C++ exceptions">, NegFlag<SetFalse>>; 1232def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>, 1233 Flags<[NoXarchOption]>; 1234def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>; 1235def fdebug_pass_structure : Flag<["-"], "fdebug-pass-structure">, Group<f_Group>; 1236def fdepfile_entry : Joined<["-"], "fdepfile-entry=">, 1237 Group<f_clang_Group>, Flags<[CC1Option]>; 1238def fdiagnostics_fixit_info : Flag<["-"], "fdiagnostics-fixit-info">, Group<f_clang_Group>; 1239def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>, 1240 Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">, 1241 MarshallingInfoNegativeFlag<DiagnosticOpts<"ShowFixits">>; 1242def fdiagnostics_parseable_fixits : Flag<["-"], "fdiagnostics-parseable-fixits">, Group<f_clang_Group>, 1243 Flags<[CoreOption, CC1Option]>, HelpText<"Print fix-its in machine parseable form">, 1244 MarshallingInfoFlag<DiagnosticOpts<"ShowParseableFixits">>; 1245def fdiagnostics_print_source_range_info : Flag<["-"], "fdiagnostics-print-source-range-info">, 1246 Group<f_clang_Group>, Flags<[CC1Option]>, 1247 HelpText<"Print source range spans in numeric form">, 1248 MarshallingInfoFlag<DiagnosticOpts<"ShowSourceRanges">>; 1249defm diagnostics_show_hotness : BoolFOption<"diagnostics-show-hotness", 1250 CodeGenOpts<"DiagnosticsWithHotness">, DefaultFalse, 1251 PosFlag<SetTrue, [CC1Option], "Enable profile hotness information in diagnostic line">, 1252 NegFlag<SetFalse>>; 1253def fdiagnostics_hotness_threshold_EQ : Joined<["-"], "fdiagnostics-hotness-threshold=">, 1254 Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<value>">, 1255 HelpText<"Prevent optimization remarks from being output if they do not have at least this profile count. " 1256 "Use 'auto' to apply the threshold from profile summary">; 1257defm diagnostics_show_option : BoolFOption<"diagnostics-show-option", 1258 DiagnosticOpts<"ShowOptionNames">, DefaultTrue, 1259 NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue, [], "Print option name with mappable diagnostics">>; 1260defm diagnostics_show_note_include_stack : BoolFOption<"diagnostics-show-note-include-stack", 1261 DiagnosticOpts<"ShowNoteIncludeStack">, DefaultFalse, 1262 PosFlag<SetTrue, [], "Display include stacks for diagnostic notes">, 1263 NegFlag<SetFalse>, BothFlags<[CC1Option]>>; 1264def fdiagnostics_format_EQ : Joined<["-"], "fdiagnostics-format=">, Group<f_clang_Group>; 1265def fdiagnostics_show_category_EQ : Joined<["-"], "fdiagnostics-show-category=">, Group<f_clang_Group>; 1266def fdiagnostics_show_template_tree : Flag<["-"], "fdiagnostics-show-template-tree">, 1267 Group<f_Group>, Flags<[CC1Option]>, 1268 HelpText<"Print a template comparison tree for differing templates">, 1269 MarshallingInfoFlag<DiagnosticOpts<"ShowTemplateTree">>; 1270def fdeclspec : Flag<["-"], "fdeclspec">, Group<f_clang_Group>, 1271 HelpText<"Allow __declspec as a keyword">, Flags<[CC1Option]>; 1272def fdiscard_value_names : Flag<["-"], "fdiscard-value-names">, Group<f_clang_Group>, 1273 HelpText<"Discard value names in LLVM IR">, Flags<[NoXarchOption]>; 1274def fno_discard_value_names : Flag<["-"], "fno-discard-value-names">, Group<f_clang_Group>, 1275 HelpText<"Do not discard value names in LLVM IR">, Flags<[NoXarchOption]>; 1276def fdollars_in_identifiers : Flag<["-"], "fdollars-in-identifiers">, Group<f_Group>, 1277 HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>; 1278def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>; 1279def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>; 1280defm dwarf_directory_asm : BoolFOption<"dwarf-directory-asm", 1281 CodeGenOpts<"NoDwarfDirectoryAsm">, DefaultFalse, 1282 NegFlag<SetTrue, [CC1Option]>, PosFlag<SetFalse>>; 1283defm elide_constructors : BoolFOption<"elide-constructors", 1284 LangOpts<"ElideConstructors">, DefaultTrue, 1285 NegFlag<SetFalse, [CC1Option], "Disable C++ copy constructor elision">, 1286 PosFlag<SetTrue>>; 1287def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>, 1288 Flags<[CC1Option]>, 1289 HelpText<"Do not elide types when printing diagnostics">, 1290 MarshallingInfoNegativeFlag<DiagnosticOpts<"ElideType">>; 1291def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>; 1292defm eliminate_unused_debug_types : OptOutFFlag<"eliminate-unused-debug-types", 1293 "Do not emit ", "Emit ", " debug info for defined but unused types">; 1294def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>, 1295 HelpText<"Emit all declarations, even if unused">, 1296 MarshallingInfoFlag<LangOpts<"EmitAllDecls">>; 1297defm emulated_tls : BoolFOption<"emulated-tls", 1298 CodeGenOpts<"EmulatedTLS">, DefaultFalse, 1299 PosFlag<SetTrue, [CC1Option], "Use emutls functions to access thread_local variables">, 1300 NegFlag<SetFalse>, BothFlags<[CC1Option]>>; 1301def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>; 1302def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>; 1303defm exceptions : BoolFOption<"exceptions", 1304 LangOpts<"Exceptions">, DefaultFalse, 1305 PosFlag<SetTrue, [CC1Option], "Enable">, NegFlag<SetFalse, [], "Disable">, 1306 BothFlags<[], " support for exception handling">>; 1307def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>, 1308 HelpText<"Use DWARF style exceptions">; 1309def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>, 1310 HelpText<"Use SjLj style exceptions">; 1311def fseh_exceptions : Flag<["-"], "fseh-exceptions">, Group<f_Group>, 1312 HelpText<"Use SEH style exceptions">; 1313def fwasm_exceptions : Flag<["-"], "fwasm-exceptions">, Group<f_Group>, 1314 HelpText<"Use WebAssembly style exceptions">; 1315def exception_model : Separate<["-"], "exception-model">, 1316 Flags<[CC1Option, NoDriverOption]>, HelpText<"The exception model: dwarf|sjlj|seh|wasm">, 1317 Values<"dwarf,sjlj,seh,wasm">, 1318 NormalizedValuesScope<"llvm::ExceptionHandling">, 1319 NormalizedValues<["DwarfCFI", "SjLj", "WinEH", "Wasm"]>, 1320 MarshallingInfoString<LangOpts<"ExceptionHandling">, "None">, 1321 AutoNormalizeEnum; 1322def exception_model_EQ : Joined<["-"], "exception-model=">, 1323 Flags<[CC1Option, NoDriverOption]>, Alias<exception_model>; 1324def fignore_exceptions : Flag<["-"], "fignore-exceptions">, Group<f_Group>, Flags<[CC1Option]>, 1325 HelpText<"Enable support for ignoring exception handling constructs">, 1326 MarshallingInfoFlag<LangOpts<"IgnoreExceptions">>; 1327def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">, 1328 Group<clang_ignored_gcc_optimization_f_Group>; 1329def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>; 1330def : Flag<["-"], "fno-expensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>; 1331def fextdirs_EQ : Joined<["-"], "fextdirs=">, Group<f_Group>; 1332def : Flag<["-"], "fdefer-pop">, Group<clang_ignored_gcc_optimization_f_Group>; 1333def : Flag<["-"], "fno-defer-pop">, Group<clang_ignored_gcc_optimization_f_Group>; 1334def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>; 1335def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>; 1336def fhosted : Flag<["-"], "fhosted">, Group<f_Group>; 1337def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group<f_Group>, Flags<[CC1Option]>; 1338def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[NoXarchOption]>, 1339 HelpText<"Controls the semantics of floating-point calculations.">; 1340def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>, Flags<[CC1Option]>, 1341 HelpText<"Specifies the exception behavior of floating-point operations.">; 1342defm fast_math : OptInFFlag<"fast-math", "Allow aggressive, lossy floating-point optimizations", "", "", [], 1343 LangOpts<"FastMath">, [cl_fast_relaxed_math.KeyPath]>; 1344def menable_unsafe_fp_math : Flag<["-"], "menable-unsafe-fp-math">, Flags<[CC1Option]>, 1345 HelpText<"Allow unsafe floating-point math optimizations which may decrease precision">, 1346 MarshallingInfoFlag<LangOpts<"UnsafeFPMath">>, 1347 ImpliedByAnyOf<[cl_unsafe_math_optimizations.KeyPath, ffast_math.KeyPath]>; 1348defm math_errno : OptInFFlag<"math-errno", "Require math functions to indicate errors by setting errno">; 1349def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>, Flags<[CoreOption]>; 1350def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>; 1351def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>; 1352defm jump_tables : BoolFOption<"jump-tables", 1353 CodeGenOpts<"NoUseJumpTables">, DefaultFalse, 1354 NegFlag<SetTrue, [CC1Option], "Do not use">, PosFlag<SetFalse, [], "Use">, 1355 BothFlags<[], " jump tables for lowering switches">>; 1356defm force_enable_int128 : OptInFFlag<"force-enable-int128", "Enable", "Disable", " support for int128_t type", [], TargetOpts<"ForceEnableInt128">>; 1357defm keep_static_consts : BoolFOption<"keep-static-consts", 1358 CodeGenOpts<"KeepStaticConsts">, DefaultFalse, 1359 PosFlag<SetTrue, [CC1Option], "Keep">, NegFlag<SetFalse, [], "Don't keep">, 1360 BothFlags<[NoXarchOption], " static const variables if unused">>; 1361defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">; 1362defm cxx_static_destructors : BoolFOption<"c++-static-destructors", 1363 LangOpts<"RegisterStaticDestructors">, DefaultTrue, 1364 NegFlag<SetFalse, [CC1Option], "Disable C++ static destructor registration">, 1365 PosFlag<SetTrue>>; 1366def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>, 1367 Flags<[CC1Option]>, MarshallingInfoString<CodeGenOpts<"SymbolPartition">>; 1368 1369defm memory_profile : OptInFFlag<"memory-profile", "Enable", "Disable", " heap memory profiling">; 1370def fmemory_profile_EQ : Joined<["-"], "fmemory-profile=">, 1371 Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<directory>">, 1372 HelpText<"Enable heap memory profiling and dump results into <directory>">; 1373 1374// Begin sanitizer flags. These should all be core options exposed in all driver 1375// modes. 1376let Flags = [CC1Option, CoreOption] in { 1377 1378def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>, 1379 MetaVarName<"<check>">, 1380 HelpText<"Turn on runtime checks for various forms of undefined " 1381 "or suspicious behavior. See user manual for available checks">; 1382def fno_sanitize_EQ : CommaJoined<["-"], "fno-sanitize=">, Group<f_clang_Group>, 1383 Flags<[CoreOption, NoXarchOption]>; 1384def fsanitize_blacklist : Joined<["-"], "fsanitize-blacklist=">, 1385 Group<f_clang_Group>, 1386 HelpText<"Path to blacklist file for sanitizers">, 1387 MarshallingInfoStringVector<LangOpts<"SanitizerBlacklistFiles">>; 1388def fsanitize_system_blacklist : Joined<["-"], "fsanitize-system-blacklist=">, 1389 HelpText<"Path to system blacklist file for sanitizers">, 1390 Flags<[CC1Option]>; 1391def fno_sanitize_blacklist : Flag<["-"], "fno-sanitize-blacklist">, 1392 Group<f_clang_Group>, 1393 HelpText<"Don't use blacklist file for sanitizers">; 1394def fsanitize_coverage 1395 : CommaJoined<["-"], "fsanitize-coverage=">, 1396 Group<f_clang_Group>, 1397 HelpText<"Specify the type of coverage instrumentation for Sanitizers">; 1398def fno_sanitize_coverage 1399 : CommaJoined<["-"], "fno-sanitize-coverage=">, 1400 Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>, 1401 HelpText<"Disable specified features of coverage instrumentation for " 1402 "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,inline-bool-flag">; 1403def fsanitize_coverage_allowlist : Joined<["-"], "fsanitize-coverage-allowlist=">, 1404 Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>, 1405 HelpText<"Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones">, 1406 MarshallingInfoStringVector<CodeGenOpts<"SanitizeCoverageAllowlistFiles">>; 1407def : Joined<["-"], "fsanitize-coverage-whitelist=">, 1408 Group<f_clang_Group>, Flags<[CoreOption, HelpHidden]>, Alias<fsanitize_coverage_allowlist>, 1409 HelpText<"Deprecated, use -fsanitize-coverage-allowlist= instead">; 1410def fsanitize_coverage_blocklist : Joined<["-"], "fsanitize-coverage-blocklist=">, 1411 Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>, 1412 HelpText<"Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones">, 1413 MarshallingInfoStringVector<CodeGenOpts<"SanitizeCoverageBlocklistFiles">>; 1414def : Joined<["-"], "fsanitize-coverage-blacklist=">, 1415 Group<f_clang_Group>, Flags<[CoreOption, HelpHidden]>, Alias<fsanitize_coverage_blocklist>, 1416 HelpText<"Deprecated, use -fsanitize-coverage-blocklist= instead">; 1417def fsanitize_memory_track_origins_EQ : Joined<["-"], "fsanitize-memory-track-origins=">, 1418 Group<f_clang_Group>, 1419 HelpText<"Enable origins tracking in MemorySanitizer">, 1420 MarshallingInfoStringInt<CodeGenOpts<"SanitizeMemoryTrackOrigins">>; 1421def fsanitize_memory_track_origins : Flag<["-"], "fsanitize-memory-track-origins">, 1422 Group<f_clang_Group>, 1423 HelpText<"Enable origins tracking in MemorySanitizer">; 1424def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">, 1425 Group<f_clang_Group>, 1426 Flags<[CoreOption, NoXarchOption]>, 1427 HelpText<"Disable origins tracking in MemorySanitizer">; 1428defm sanitize_memory_use_after_dtor : BoolOption<"f", "sanitize-memory-use-after-dtor", 1429 CodeGenOpts<"SanitizeMemoryUseAfterDtor">, DefaultFalse, 1430 PosFlag<SetTrue, [CC1Option], "Enable">, NegFlag<SetFalse, [], "Disable">, 1431 BothFlags<[], " use-after-destroy detection in MemorySanitizer">>, 1432 Group<f_clang_Group>; 1433def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">, 1434 Group<f_clang_Group>, 1435 HelpText<"Level of field padding for AddressSanitizer">, 1436 MarshallingInfoStringInt<LangOpts<"SanitizeAddressFieldPadding">>; 1437defm sanitize_address_use_after_scope : BoolOption<"f", "sanitize-address-use-after-scope", 1438 CodeGenOpts<"SanitizeAddressUseAfterScope">, DefaultFalse, 1439 PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [CoreOption, NoXarchOption], "Disable">, 1440 BothFlags<[], " use-after-scope detection in AddressSanitizer">>, 1441 Group<f_clang_Group>; 1442defm sanitize_address_poison_custom_array_cookie : BoolOption<"f", "sanitize-address-poison-custom-array-cookie", 1443 CodeGenOpts<"SanitizeAddressPoisonCustomArrayCookie">, DefaultFalse, 1444 PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [], "Disable">, 1445 BothFlags<[], " poisoning array cookies when using custom operator new[] in AddressSanitizer">>, 1446 Group<f_clang_Group>; 1447def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">, 1448 Group<f_clang_Group>, HelpText<"Enable linker dead stripping of globals in AddressSanitizer">, 1449 MarshallingInfoFlag<CodeGenOpts<"SanitizeAddressGlobalsDeadStripping">, "false">; 1450defm sanitize_address_use_odr_indicator : BoolOption<"f", "sanitize-address-use-odr-indicator", 1451 CodeGenOpts<"SanitizeAddressUseOdrIndicator">, DefaultFalse, 1452 PosFlag<SetTrue, [], "Enable ODR indicator globals to avoid false ODR violation" 1453 " reports in partially sanitized programs at the cost of an increase in binary size">, 1454 NegFlag<SetFalse, [], "Disable ODR indicator globals">>, 1455 Group<f_clang_Group>; 1456// Note: This flag was introduced when it was necessary to distinguish between 1457// ABI for correct codegen. This is no longer needed, but the flag is 1458// not removed since targeting either ABI will behave the same. 1459// This way we cause no disturbance to existing scripts & code, and if we 1460// want to use this flag in the future we will cause no disturbance then 1461// either. 1462def fsanitize_hwaddress_abi_EQ 1463 : Joined<["-"], "fsanitize-hwaddress-abi=">, 1464 Group<f_clang_Group>, 1465 HelpText<"Select the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor). This option is currently unused.">; 1466def fsanitize_recover_EQ : CommaJoined<["-"], "fsanitize-recover=">, 1467 Group<f_clang_Group>, 1468 HelpText<"Enable recovery for specified sanitizers">; 1469def fno_sanitize_recover_EQ : CommaJoined<["-"], "fno-sanitize-recover=">, 1470 Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>, 1471 HelpText<"Disable recovery for specified sanitizers">; 1472def fsanitize_recover : Flag<["-"], "fsanitize-recover">, Group<f_clang_Group>, 1473 Alias<fsanitize_recover_EQ>, AliasArgs<["all"]>; 1474def fno_sanitize_recover : Flag<["-"], "fno-sanitize-recover">, 1475 Flags<[CoreOption, NoXarchOption]>, Group<f_clang_Group>, 1476 Alias<fno_sanitize_recover_EQ>, AliasArgs<["all"]>; 1477def fsanitize_trap_EQ : CommaJoined<["-"], "fsanitize-trap=">, Group<f_clang_Group>, 1478 HelpText<"Enable trapping for specified sanitizers">; 1479def fno_sanitize_trap_EQ : CommaJoined<["-"], "fno-sanitize-trap=">, Group<f_clang_Group>, 1480 Flags<[CoreOption, NoXarchOption]>, 1481 HelpText<"Disable trapping for specified sanitizers">; 1482def fsanitize_trap : Flag<["-"], "fsanitize-trap">, Group<f_clang_Group>, 1483 Alias<fsanitize_trap_EQ>, AliasArgs<["all"]>, 1484 HelpText<"Enable trapping for all sanitizers">; 1485def fno_sanitize_trap : Flag<["-"], "fno-sanitize-trap">, Group<f_clang_Group>, 1486 Alias<fno_sanitize_trap_EQ>, AliasArgs<["all"]>, 1487 Flags<[CoreOption, NoXarchOption]>, 1488 HelpText<"Disable trapping for all sanitizers">; 1489def fsanitize_undefined_trap_on_error 1490 : Flag<["-"], "fsanitize-undefined-trap-on-error">, Group<f_clang_Group>, 1491 Alias<fsanitize_trap_EQ>, AliasArgs<["undefined"]>; 1492def fno_sanitize_undefined_trap_on_error 1493 : Flag<["-"], "fno-sanitize-undefined-trap-on-error">, Group<f_clang_Group>, 1494 Alias<fno_sanitize_trap_EQ>, AliasArgs<["undefined"]>; 1495defm sanitize_minimal_runtime : BoolOption<"f", "sanitize-minimal-runtime", 1496 CodeGenOpts<"SanitizeMinimalRuntime">, DefaultFalse, 1497 PosFlag<SetTrue>, NegFlag<SetFalse>>, 1498 Group<f_clang_Group>; 1499def fsanitize_link_runtime : Flag<["-"], "fsanitize-link-runtime">, 1500 Group<f_clang_Group>; 1501def fno_sanitize_link_runtime : Flag<["-"], "fno-sanitize-link-runtime">, 1502 Group<f_clang_Group>; 1503def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">, 1504 Group<f_clang_Group>; 1505def fno_sanitize_link_cxx_runtime : Flag<["-"], "fno-sanitize-link-c++-runtime">, 1506 Group<f_clang_Group>; 1507defm sanitize_cfi_cross_dso : BoolOption<"f", "sanitize-cfi-cross-dso", 1508 CodeGenOpts<"SanitizeCfiCrossDso">, DefaultFalse, 1509 PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [CoreOption, NoXarchOption], "Disable">, 1510 BothFlags<[], " control flow integrity (CFI) checks for cross-DSO calls.">>, 1511 Group<f_clang_Group>; 1512def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">, 1513 Group<f_clang_Group>, 1514 HelpText<"Generalize pointers in CFI indirect call type signature checks">, 1515 MarshallingInfoFlag<CodeGenOpts<"SanitizeCfiICallGeneralizePointers">>; 1516defm sanitize_cfi_canonical_jump_tables : BoolOption<"f", "sanitize-cfi-canonical-jump-tables", 1517 CodeGenOpts<"SanitizeCfiCanonicalJumpTables">, DefaultFalse, 1518 PosFlag<SetTrue, [], "Make">, NegFlag<SetFalse, [CoreOption, NoXarchOption], "Do not make">, 1519 BothFlags<[], " the jump table addresses canonical in the symbol table">>, 1520 Group<f_clang_Group>; 1521defm sanitize_stats : BoolOption<"f", "sanitize-stats", 1522 CodeGenOpts<"SanitizeStats">, DefaultFalse, 1523 PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [CoreOption, NoXarchOption], "Disable">, 1524 BothFlags<[], " sanitizer statistics gathering.">>, 1525 Group<f_clang_Group>; 1526def fsanitize_thread_memory_access : Flag<["-"], "fsanitize-thread-memory-access">, 1527 Group<f_clang_Group>, 1528 HelpText<"Enable memory access instrumentation in ThreadSanitizer (default)">; 1529def fno_sanitize_thread_memory_access : Flag<["-"], "fno-sanitize-thread-memory-access">, 1530 Group<f_clang_Group>, 1531 Flags<[CoreOption, NoXarchOption]>, 1532 HelpText<"Disable memory access instrumentation in ThreadSanitizer">; 1533def fsanitize_thread_func_entry_exit : Flag<["-"], "fsanitize-thread-func-entry-exit">, 1534 Group<f_clang_Group>, 1535 HelpText<"Enable function entry/exit instrumentation in ThreadSanitizer (default)">; 1536def fno_sanitize_thread_func_entry_exit : Flag<["-"], "fno-sanitize-thread-func-entry-exit">, 1537 Group<f_clang_Group>, 1538 Flags<[CoreOption, NoXarchOption]>, 1539 HelpText<"Disable function entry/exit instrumentation in ThreadSanitizer">; 1540def fsanitize_thread_atomics : Flag<["-"], "fsanitize-thread-atomics">, 1541 Group<f_clang_Group>, 1542 HelpText<"Enable atomic operations instrumentation in ThreadSanitizer (default)">; 1543def fno_sanitize_thread_atomics : Flag<["-"], "fno-sanitize-thread-atomics">, 1544 Group<f_clang_Group>, 1545 Flags<[CoreOption, NoXarchOption]>, 1546 HelpText<"Disable atomic operations instrumentation in ThreadSanitizer">; 1547def fsanitize_undefined_strip_path_components_EQ : Joined<["-"], "fsanitize-undefined-strip-path-components=">, 1548 Group<f_clang_Group>, MetaVarName<"<number>">, 1549 HelpText<"Strip (or keep only, if negative) a given number of path components " 1550 "when emitting check metadata.">, 1551 MarshallingInfoStringInt<CodeGenOpts<"EmitCheckPathComponentsToStrip">, "0", "int">; 1552 1553} // end -f[no-]sanitize* flags 1554 1555def funsafe_math_optimizations : Flag<["-"], "funsafe-math-optimizations">, 1556 Group<f_Group>; 1557def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">, 1558 Group<f_Group>; 1559def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>; 1560def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>; 1561defm reciprocal_math : OptInFFlag<"reciprocal-math", "Allow division operations to be reassociated", "", "", [], 1562 LangOpts<"AllowRecip">, [menable_unsafe_fp_math.KeyPath]>; 1563def fapprox_func : Flag<["-"], "fapprox-func">, Group<f_Group>, Flags<[CC1Option, NoDriverOption]>, 1564 MarshallingInfoFlag<LangOpts<"ApproxFunc">>, ImpliedByAnyOf<[menable_unsafe_fp_math.KeyPath]>; 1565defm finite_math_only : OptInFFlag<"finite-math-only", "", "", "", [], 1566 LangOpts<"FiniteMathOnly">, [cl_finite_math_only.KeyPath, ffast_math.KeyPath]>; 1567defm signed_zeros : BoolFOption<"signed-zeros", 1568 LangOpts<"NoSignedZero">, DefaultFalse, 1569 NegFlag<SetTrue, [CC1Option], "Allow optimizations that ignore the sign of floating point zeros", 1570 [cl_no_signed_zeros.KeyPath, menable_unsafe_fp_math.KeyPath]>, 1571 PosFlag<SetFalse>>; 1572def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>; 1573def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>; 1574def fhonor_infinities : Flag<["-"], "fhonor-infinities">, Group<f_Group>; 1575def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>; 1576// This option was originally misspelt "infinites" [sic]. 1577def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>; 1578def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>; 1579def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>, 1580 MarshallingInfoFlag<LangOpts<"FPRoundingMode">, "llvm::RoundingMode::NearestTiesToEven">, 1581 Normalizer<"makeFlagToValueNormalizer(llvm::RoundingMode::Dynamic)">; 1582def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>; 1583def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>; 1584def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>; 1585def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>, 1586 Flags<[CC1Option]>, HelpText<"Form fused FP ops (e.g. FMAs):" 1587 " fast (fuses across statements disregarding pragmas)" 1588 " | on (only fuses in the same statement unless dictated by pragmas)" 1589 " | off (never fuses)" 1590 " | fast-honor-pragmas (fuses across statements unless diectated by pragmas)." 1591 " Default is 'fast' for CUDA, 'fast-honor-pragmas' for HIP, and 'on' otherwise.">, 1592 Values<"fast,on,off,fast-honor-pragmas">; 1593 1594defm strict_float_cast_overflow : BoolFOption<"strict-float-cast-overflow", 1595 CodeGenOpts<"StrictFloatCastOverflow">, DefaultTrue, 1596 NegFlag<SetFalse, [CC1Option], "Relax language rules and try to match the behavior" 1597 " of the target's native float-to-int conversion instructions">, 1598 PosFlag<SetTrue, [], "Assume that overflowing float-to-int casts are undefined (default)">>; 1599 1600def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>; 1601def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>; 1602 1603defm rewrite_imports : BoolFOption<"rewrite-imports", 1604 PreprocessorOutputOpts<"RewriteImports">, DefaultFalse, 1605 PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>>; 1606defm rewrite_includes : BoolFOption<"rewrite-includes", 1607 PreprocessorOutputOpts<"RewriteIncludes">, DefaultFalse, 1608 PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>>; 1609 1610defm delete_null_pointer_checks : BoolFOption<"delete-null-pointer-checks", 1611 CodeGenOpts<"NullPointerIsValid">, DefaultFalse, 1612 NegFlag<SetTrue, [CC1Option], "Do not treat usage of null pointers as undefined behavior">, 1613 PosFlag<SetFalse, [], "Treat usage of null pointers as undefined behavior (default)">, 1614 BothFlags<[CoreOption]>>; 1615 1616def frewrite_map_file : Separate<["-"], "frewrite-map-file">, 1617 Group<f_Group>, 1618 Flags<[ NoXarchOption, CC1Option ]>, 1619 MarshallingInfoStringVector<CodeGenOpts<"RewriteMapFiles">>; 1620def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">, 1621 Group<f_Group>, 1622 Flags<[NoXarchOption]>; 1623 1624defm use_line_directives : BoolFOption<"use-line-directives", 1625 PreprocessorOutputOpts<"UseLineDirectives">, DefaultFalse, 1626 PosFlag<SetTrue, [CC1Option], "Use #line in preprocessed output">, NegFlag<SetFalse>>; 1627 1628def fformat_extensions: Flag<["-"], "fformat-extensions">, Group<f_Group>, Flags<[CC1Option]>, 1629 HelpText<"Enable FreeBSD kernel specific format string extensions">; 1630def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>, 1631 HelpText<"Assert that the compilation takes place in a freestanding environment">, 1632 MarshallingInfoFlag<LangOpts<"Freestanding">>; 1633def fgnuc_version_EQ : Joined<["-"], "fgnuc-version=">, Group<f_Group>, 1634 HelpText<"Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)">, 1635 Flags<[CC1Option, CoreOption]>; 1636// We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension 1637// keywords. This behavior is provided by GCC's poorly named '-fasm' flag, 1638// while a subset (the non-C++ GNU keywords) is provided by GCC's 1639// '-fgnu-keywords'. Clang conflates the two for simplicity under the single 1640// name, as it doesn't seem a useful distinction. 1641defm gnu_keywords : BoolFOption<"gnu-keywords", 1642 LangOpts<"GNUKeywords">, Default<gnu_mode.KeyPath>, 1643 PosFlag<SetTrue, [], "Allow GNU-extension keywords regardless of language standard">, 1644 NegFlag<SetFalse>, BothFlags<[CC1Option]>>; 1645defm gnu89_inline : BoolFOption<"gnu89-inline", 1646 LangOpts<"GNUInline">, Default<!strconcat("!", c99.KeyPath, " && !", cplusplus.KeyPath)>, 1647 PosFlag<SetTrue, [CC1Option], "Use the gnu89 inline semantics">, 1648 NegFlag<SetFalse>>, ShouldParseIf<!strconcat("!", cplusplus.KeyPath)>; 1649def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>, 1650 HelpText<"Generate output compatible with the standard GNU Objective-C runtime">; 1651def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>, 1652 MarshallingInfoFlag<LangOpts<"HeinousExtensions">>; 1653def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>, 1654 Group<Link_Group>; 1655def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>; 1656def finline_functions : Flag<["-"], "finline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>, 1657 HelpText<"Inline suitable functions">; 1658def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>, 1659 HelpText<"Inline functions which are (explicitly or implicitly) marked inline">; 1660def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>; 1661def fglobal_isel : Flag<["-"], "fglobal-isel">, Group<f_clang_Group>, 1662 HelpText<"Enables the global instruction selector">; 1663def fexperimental_isel : Flag<["-"], "fexperimental-isel">, Group<f_clang_Group>, 1664 Alias<fglobal_isel>; 1665defm legacy_pass_manager : BoolOption<"f", "legacy-pass-manager", 1666 CodeGenOpts<"LegacyPassManager">, Default<"!static_cast<unsigned>(LLVM_ENABLE_NEW_PASS_MANAGER)">, 1667 PosFlag<SetTrue, [], "Use the legacy pass manager in LLVM">, 1668 NegFlag<SetFalse, [], "Use the new pass manager in LLVM">, 1669 BothFlags<[CC1Option]>>, Group<f_clang_Group>; 1670def fexperimental_new_pass_manager : Flag<["-"], "fexperimental-new-pass-manager">, 1671 Group<f_clang_Group>, Flags<[CC1Option]>, Alias<fno_legacy_pass_manager>; 1672def fno_experimental_new_pass_manager : Flag<["-"], "fno-experimental-new-pass-manager">, 1673 Group<f_clang_Group>, Flags<[CC1Option]>, Alias<flegacy_pass_manager>; 1674def fexperimental_strict_floating_point : Flag<["-"], "fexperimental-strict-floating-point">, 1675 Group<f_clang_Group>, Flags<[CC1Option]>, 1676 HelpText<"Enables experimental strict floating point in LLVM.">, 1677 MarshallingInfoFlag<LangOpts<"ExpStrictFP">>; 1678def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>; 1679def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>; 1680def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>, 1681 HelpText<"Generate calls to instrument function entry and exit">, 1682 MarshallingInfoFlag<CodeGenOpts<"InstrumentFunctions">>; 1683def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>, 1684 HelpText<"Like -finstrument-functions, but insert the calls after inlining">, 1685 MarshallingInfoFlag<CodeGenOpts<"InstrumentFunctionsAfterInlining">>; 1686def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>, 1687 HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">, 1688 MarshallingInfoFlag<CodeGenOpts<"InstrumentFunctionEntryBare">>; 1689def fcf_protection_EQ : Joined<["-"], "fcf-protection=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>, 1690 HelpText<"Instrument control-flow architecture protection. Options: return, branch, full, none.">, Values<"return,branch,full,none">; 1691def fcf_protection : Flag<["-"], "fcf-protection">, Group<f_Group>, Flags<[CoreOption, CC1Option]>, 1692 Alias<fcf_protection_EQ>, AliasArgs<["full"]>, 1693 HelpText<"Enable cf-protection in 'full' mode">; 1694 1695defm xray_instrument : OptInFFlag<"xray-instrument", "Generate XRay instrumentation sleds on function entry and exit", "", "", [], LangOpts<"XRayInstrument">>; 1696 1697def fxray_instruction_threshold_EQ : 1698 JoinedOrSeparate<["-"], "fxray-instruction-threshold=">, 1699 Group<f_Group>, Flags<[CC1Option]>, 1700 HelpText<"Sets the minimum function size to instrument with XRay">, 1701 MarshallingInfoStringInt<CodeGenOpts<"XRayInstructionThreshold">, "200">; 1702def fxray_instruction_threshold_ : 1703 JoinedOrSeparate<["-"], "fxray-instruction-threshold">, 1704 Group<f_Group>, Flags<[CC1Option]>; 1705 1706def fxray_always_instrument : 1707 JoinedOrSeparate<["-"], "fxray-always-instrument=">, 1708 Group<f_Group>, Flags<[CC1Option]>, 1709 HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.">, 1710 MarshallingInfoStringVector<LangOpts<"XRayAlwaysInstrumentFiles">>; 1711def fxray_never_instrument : 1712 JoinedOrSeparate<["-"], "fxray-never-instrument=">, 1713 Group<f_Group>, Flags<[CC1Option]>, 1714 HelpText<"DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.">, 1715 MarshallingInfoStringVector<LangOpts<"XRayNeverInstrumentFiles">>; 1716def fxray_attr_list : 1717 JoinedOrSeparate<["-"], "fxray-attr-list=">, 1718 Group<f_Group>, Flags<[CC1Option]>, 1719 HelpText<"Filename defining the list of functions/types for imbuing XRay attributes.">, 1720 MarshallingInfoStringVector<LangOpts<"XRayAttrListFiles">>; 1721def fxray_modes : 1722 JoinedOrSeparate<["-"], "fxray-modes=">, 1723 Group<f_Group>, Flags<[CC1Option]>, 1724 HelpText<"List of modes to link in by default into XRay instrumented binaries.">; 1725 1726defm xray_always_emit_customevents : OptInFFlag<"xray-always-emit-customevents", 1727 "Always emit __xray_customevent(...) calls even if the containing function is not always instrumented", "", "", [], LangOpts<"XRayAlwaysEmitCustomEvents">>; 1728 1729defm xray_always_emit_typedevents : OptInFFlag<"xray-always-emit-typedevents", 1730 "Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented", "", "", [], LangOpts<"XRayAlwaysEmitTypedEvents">>; 1731 1732defm xray_ignore_loops : OptInFFlag<"xray-ignore-loops", 1733 "Don't instrument functions with loops unless they also meet the minimum function size", "", "", [], CodeGenOpts<"XRayIgnoreLoops">>; 1734defm xray_function_index : OptOutFFlag<"xray-function-index", "", 1735 "Omit function index section at the expense of single-function patching performance", "", [], CodeGenOpts<"XRayOmitFunctionIndex">>; 1736 1737def fxray_link_deps : Flag<["-"], "fxray-link-deps">, Group<f_Group>, 1738 Flags<[CC1Option]>, 1739 HelpText<"Tells clang to add the link dependencies for XRay.">; 1740def fnoxray_link_deps : Flag<["-"], "fnoxray-link-deps">, Group<f_Group>, 1741 Flags<[CC1Option]>; 1742 1743def fxray_instrumentation_bundle : 1744 JoinedOrSeparate<["-"], "fxray-instrumentation-bundle=">, 1745 Group<f_Group>, Flags<[CC1Option]>, 1746 HelpText<"Select which XRay instrumentation points to emit. Options: all, none, function-entry, function-exit, function, custom. Default is 'all'. 'function' includes both 'function-entry' and 'function-exit'.">; 1747 1748def fxray_function_groups : 1749 Joined<["-"], "fxray-function-groups=">, 1750 Group<f_Group>, Flags<[CC1Option]>, 1751 HelpText<"Only instrument 1 of N groups">, 1752 MarshallingInfoStringInt<CodeGenOpts<"XRayTotalFunctionGroups">, "1">; 1753 1754def fxray_selected_function_group : 1755 Joined<["-"], "fxray-selected-function-group=">, 1756 Group<f_Group>, Flags<[CC1Option]>, 1757 HelpText<"When using -fxray-function-groups, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1">, 1758 MarshallingInfoStringInt<CodeGenOpts<"XRaySelectedFunctionGroup">, "0">; 1759 1760 1761defm fine_grained_bitfield_accesses : BoolOption<"f", "fine-grained-bitfield-accesses", 1762 CodeGenOpts<"FineGrainedBitfieldAccesses">, DefaultFalse, 1763 PosFlag<SetTrue, [], "Use separate accesses for consecutive bitfield runs with legal widths and alignments.">, 1764 NegFlag<SetFalse, [], "Use large-integer access for consecutive bitfield runs.">, 1765 BothFlags<[CC1Option]>>, 1766 Group<f_clang_Group>; 1767 1768defm experimental_relative_cxx_abi_vtables : BoolFOption<"experimental-relative-c++-abi-vtables", 1769 LangOpts<"RelativeCXXABIVTables">, DefaultFalse, 1770 PosFlag<SetTrue, [], "Use">, NegFlag<SetFalse, [], "Do not use">, 1771 BothFlags<[CC1Option], " the experimental C++ class ABI for classes with virtual tables">>; 1772 1773def flat__namespace : Flag<["-"], "flat_namespace">; 1774def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Group<f_Group>, 1775 HelpText<"Enable implicit vector bit-casts">, Values<"none,integer,all">, Flags<[CC1Option]>, 1776 NormalizedValues<["LangOptions::LaxVectorConversionKind::None", 1777 "LangOptions::LaxVectorConversionKind::Integer", 1778 "LangOptions::LaxVectorConversionKind::All"]>, 1779 MarshallingInfoString<LangOpts<"LaxVectorConversions">, 1780 !strconcat(open_cl.KeyPath, " ? LangOptions::LaxVectorConversionKind::None" 1781 " : LangOptions::LaxVectorConversionKind::All")>, 1782 AutoNormalizeEnum; 1783def flax_vector_conversions : Flag<["-"], "flax-vector-conversions">, Group<f_Group>, 1784 Alias<flax_vector_conversions_EQ>, AliasArgs<["integer"]>; 1785def flimited_precision_EQ : Joined<["-"], "flimited-precision=">, Group<f_Group>; 1786def fapple_link_rtlib : Flag<["-"], "fapple-link-rtlib">, Group<f_Group>, 1787 HelpText<"Force linking the clang builtins runtime library">; 1788def flto_EQ : Joined<["-"], "flto=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>, 1789 HelpText<"Set LTO mode to either 'full' or 'thin'">, Values<"thin,full">; 1790def flto : Flag<["-"], "flto">, Flags<[CoreOption, CC1Option]>, Group<f_Group>, 1791 HelpText<"Enable LTO in 'full' mode">; 1792def fno_lto : Flag<["-"], "fno-lto">, Flags<[CoreOption, CC1Option]>, Group<f_Group>, 1793 HelpText<"Disable LTO mode (default)">; 1794def flto_jobs_EQ : Joined<["-"], "flto-jobs=">, 1795 Flags<[CC1Option]>, Group<f_Group>, 1796 HelpText<"Controls the backend parallelism of -flto=thin (default " 1797 "of 0 means the number of threads will be derived from " 1798 "the number of CPUs detected)">; 1799def fthinlto_index_EQ : Joined<["-"], "fthinlto-index=">, 1800 Flags<[CoreOption, CC1Option]>, Group<f_Group>, 1801 HelpText<"Perform ThinLTO importing using provided function summary index">; 1802def fthin_link_bitcode_EQ : Joined<["-"], "fthin-link-bitcode=">, 1803 Flags<[CoreOption, CC1Option]>, Group<f_Group>, 1804 HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">, 1805 MarshallingInfoString<CodeGenOpts<"ThinLinkBitcodeFile">>; 1806def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">, 1807 Group<f_Group>, Flags<[NoXarchOption, CoreOption]>; 1808defm merge_all_constants : BoolFOption<"merge-all-constants", 1809 CodeGenOpts<"MergeAllConstants">, DefaultFalse, 1810 PosFlag<SetTrue, [CC1Option, CoreOption], "Allow">, NegFlag<SetFalse, [], "Disallow">, 1811 BothFlags<[], " merging of constants">>; 1812def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>, 1813 HelpText<"Format message diagnostics so that they fit within N columns">, 1814 MarshallingInfoStringInt<DiagnosticOpts<"MessageLength">>; 1815def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1816 HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">; 1817def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1818 HelpText<"Enable full Microsoft Visual C++ compatibility">, 1819 MarshallingInfoFlag<LangOpts<"MSVCCompat">>; 1820def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>, 1821 MarshallingInfoFlag<CodeGenOpts<"MSVolatile">>; 1822def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[NoXarchOption, CoreOption]>, 1823 HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">; 1824def fms_compatibility_version 1825 : Joined<["-"], "fms-compatibility-version=">, 1826 Group<f_Group>, 1827 Flags<[ CC1Option, CoreOption ]>, 1828 HelpText<"Dot-separated value representing the Microsoft compiler " 1829 "version number to report in _MSC_VER (0 = don't define it " 1830 "(default))">; 1831defm delayed_template_parsing : BoolFOption<"delayed-template-parsing", 1832 LangOpts<"DelayedTemplateParsing">, DefaultFalse, 1833 PosFlag<SetTrue, [CC1Option], "Parse templated function definitions at the end of the translation unit">, 1834 NegFlag<SetFalse, [NoXarchOption], "Disable delayed template parsing">, 1835 BothFlags<[CoreOption]>>; 1836def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>, 1837 Values<"single,multiple,virtual">, NormalizedValuesScope<"LangOptions">, 1838 NormalizedValues<["PPTMK_FullGeneralitySingleInheritance", "PPTMK_FullGeneralityMultipleInheritance", 1839 "PPTMK_FullGeneralityVirtualInheritance"]>, 1840 MarshallingInfoString<LangOpts<"MSPointerToMemberRepresentationMethod">, "PPTMK_BestCase">, 1841 AutoNormalizeEnum; 1842def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>, 1843 Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">, 1844 HelpText<"Specify the module cache path">; 1845def fmodules_user_build_path : Separate<["-"], "fmodules-user-build-path">, Group<i_Group>, 1846 Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">, 1847 HelpText<"Specify the module user build path">, 1848 MarshallingInfoString<HeaderSearchOpts<"ModuleUserBuildPath">>; 1849def fprebuilt_module_path : Joined<["-"], "fprebuilt-module-path=">, Group<i_Group>, 1850 Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">, 1851 HelpText<"Specify the prebuilt module path">; 1852defm prebuilt_implicit_modules : OptInFFlag<"prebuilt-implicit-modules", 1853 "Look up implicit modules in the prebuilt module path", "", "", 1854 [NoXarchOption, CC1Option], HeaderSearchOpts<"EnablePrebuiltImplicitModules">>; 1855def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>, 1856 Flags<[CC1Option]>, MetaVarName<"<seconds>">, 1857 HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">, 1858 MarshallingInfoStringInt<HeaderSearchOpts<"ModuleCachePruneInterval">, "7 * 24 * 60 * 60">; 1859def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>, 1860 Flags<[CC1Option]>, MetaVarName<"<seconds>">, 1861 HelpText<"Specify the interval (in seconds) after which a module file will be considered unused">, 1862 MarshallingInfoStringInt<HeaderSearchOpts<"ModuleCachePruneAfter">, "31 * 24 * 60 * 60">; 1863def fmodules_search_all : Flag <["-"], "fmodules-search-all">, Group<f_Group>, 1864 Flags<[NoXarchOption, CC1Option]>, 1865 HelpText<"Search even non-imported modules to resolve references">; 1866def fbuild_session_timestamp : Joined<["-"], "fbuild-session-timestamp=">, 1867 Group<i_Group>, Flags<[CC1Option]>, MetaVarName<"<time since Epoch in seconds>">, 1868 HelpText<"Time when the current build session started">, 1869 MarshallingInfoStringInt<HeaderSearchOpts<"BuildSessionTimestamp">, "0", "uint64_t">; 1870def fbuild_session_file : Joined<["-"], "fbuild-session-file=">, 1871 Group<i_Group>, MetaVarName<"<file>">, 1872 HelpText<"Use the last modification time of <file> as the build session timestamp">; 1873def fmodules_validate_once_per_build_session : Flag<["-"], "fmodules-validate-once-per-build-session">, 1874 Group<i_Group>, Flags<[CC1Option]>, 1875 HelpText<"Don't verify input files for the modules if the module has been " 1876 "successfully validated or loaded during this build session">, 1877 MarshallingInfoFlag<HeaderSearchOpts<"ModulesValidateOncePerBuildSession">>; 1878def fmodules_disable_diagnostic_validation : Flag<["-"], "fmodules-disable-diagnostic-validation">, 1879 Group<i_Group>, Flags<[CC1Option]>, 1880 HelpText<"Disable validation of the diagnostic options when loading the module">, 1881 MarshallingInfoNegativeFlag<HeaderSearchOpts<"ModulesValidateDiagnosticOptions">>; 1882defm modules_validate_system_headers : BoolOption<"f", "modules-validate-system-headers", 1883 HeaderSearchOpts<"ModulesValidateSystemHeaders">, DefaultFalse, 1884 PosFlag<SetTrue, [CC1Option], "Validate the system headers that a module depends on when loading the module">, 1885 NegFlag<SetFalse, [NoXarchOption]>>, Group<i_Group>; 1886 1887def fvalidate_ast_input_files_content: 1888 Flag <["-"], "fvalidate-ast-input-files-content">, 1889 Group<f_Group>, Flags<[CC1Option]>, 1890 HelpText<"Compute and store the hash of input files used to build an AST." 1891 " Files with mismatching mtime's are considered valid" 1892 " if both contents is identical">, 1893 MarshallingInfoFlag<HeaderSearchOpts<"ValidateASTInputFilesContent">>; 1894def fmodules_validate_input_files_content: 1895 Flag <["-"], "fmodules-validate-input-files-content">, 1896 Group<f_Group>, Flags<[NoXarchOption]>, 1897 HelpText<"Validate PCM input files based on content if mtime differs">; 1898def fno_modules_validate_input_files_content: 1899 Flag <["-"], "fno_modules-validate-input-files-content">, 1900 Group<f_Group>, Flags<[NoXarchOption]>; 1901def fpch_validate_input_files_content: 1902 Flag <["-"], "fpch-validate-input-files-content">, 1903 Group<f_Group>, Flags<[NoXarchOption]>, 1904 HelpText<"Validate PCH input files based on content if mtime differs">; 1905def fno_pch_validate_input_files_content: 1906 Flag <["-"], "fno_pch-validate-input-files-content">, 1907 Group<f_Group>, Flags<[NoXarchOption]>; 1908defm pch_instantiate_templates : BoolFOption<"pch-instantiate-templates", 1909 LangOpts<"PCHInstantiateTemplates">, DefaultFalse, 1910 PosFlag<SetTrue, [], "Instantiate templates already while building a PCH">, 1911 NegFlag<SetFalse>, BothFlags<[CC1Option, CoreOption]>>; 1912defm pch_codegen: OptInFFlag<"pch-codegen", "Generate ", "Do not generate ", 1913 "code for uses of this PCH that assumes an explicit object file will be built for the PCH">; 1914defm pch_debuginfo: OptInFFlag<"pch-debuginfo", "Generate ", "Do not generate ", 1915 "debug info for types in an object file built from this PCH and do not generate them elsewhere">; 1916 1917def fmodules : Flag <["-"], "fmodules">, Group<f_Group>, 1918 Flags<[NoXarchOption, CC1Option]>, 1919 HelpText<"Enable the 'modules' language feature">; 1920def fimplicit_module_maps : Flag <["-"], "fimplicit-module-maps">, Group<f_Group>, 1921 Flags<[NoXarchOption, CC1Option]>, 1922 HelpText<"Implicitly search the file system for module map files.">, 1923 MarshallingInfoFlag<HeaderSearchOpts<"ImplicitModuleMaps">>; 1924def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_Group>, 1925 Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">, 1926 MarshallingInfoFlag<LangOpts<"ModulesTS">>; 1927def fmodule_maps : Flag <["-"], "fmodule-maps">, Alias<fimplicit_module_maps>; 1928def fmodule_name_EQ : Joined<["-"], "fmodule-name=">, Group<f_Group>, 1929 Flags<[NoXarchOption,CC1Option]>, MetaVarName<"<name>">, 1930 HelpText<"Specify the name of the module to build">, 1931 MarshallingInfoString<LangOpts<"ModuleName">>; 1932def fmodule_name : Separate<["-"], "fmodule-name">, Alias<fmodule_name_EQ>; 1933def fmodule_implementation_of : Separate<["-"], "fmodule-implementation-of">, 1934 Flags<[CC1Option]>, Alias<fmodule_name_EQ>; 1935def fsystem_module : Flag<["-"], "fsystem-module">, Flags<[CC1Option]>, 1936 HelpText<"Build this module as a system module. Only used with -emit-module">, 1937 MarshallingInfoFlag<FrontendOpts<"IsSystemModule">>; 1938def fmodule_map_file : Joined<["-"], "fmodule-map-file=">, 1939 Group<f_Group>, Flags<[NoXarchOption,CC1Option]>, MetaVarName<"<file>">, 1940 HelpText<"Load this module map file">, 1941 MarshallingInfoStringVector<FrontendOpts<"ModuleMapFiles">>; 1942def fmodule_file : Joined<["-"], "fmodule-file=">, 1943 Group<i_Group>, Flags<[NoXarchOption,CC1Option]>, MetaVarName<"[<name>=]<file>">, 1944 HelpText<"Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.">; 1945def fmodules_ignore_macro : Joined<["-"], "fmodules-ignore-macro=">, Group<f_Group>, Flags<[CC1Option]>, 1946 HelpText<"Ignore the definition of the given macro when building and loading modules">; 1947def fmodules_decluse : Flag <["-"], "fmodules-decluse">, Group<f_Group>, 1948 Flags<[NoXarchOption,CC1Option]>, 1949 HelpText<"Require declaration of modules used within a module">; 1950def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>, 1951 Flags<[NoXarchOption,CC1Option]>, 1952 HelpText<"Like -fmodules-decluse but requires all headers to be in modules">, 1953 MarshallingInfoFlag<LangOpts<"ModulesStrictDeclUse">>; 1954def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>, 1955 Flags<[NoXarchOption, CC1Option]>; 1956defm implicit_modules : BoolFOption<"implicit-modules", 1957 LangOpts<"ImplicitModules">, DefaultTrue, 1958 NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue>, BothFlags<[NoXarchOption]>>; 1959def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>, 1960 MarshallingInfoFlag<LangOpts<"RetainCommentsFromSystemHeaders">>; 1961 1962def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>; 1963def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>; 1964def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>; 1965def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>; 1966def fno_xl_pragma_pack : Flag<["-"], "fno-xl-pragma-pack">, Group<f_Group>; 1967def fno_asm : Flag<["-"], "fno-asm">, Group<f_Group>; 1968def fno_asynchronous_unwind_tables : Flag<["-"], "fno-asynchronous-unwind-tables">, Group<f_Group>; 1969def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>, 1970 HelpText<"Don't assume that C++'s global operator new can't alias any pointer">, 1971 Flags<[CC1Option]>, MarshallingInfoNegativeFlag<CodeGenOpts<"AssumeSaneOperatorNew">>; 1972def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1973 HelpText<"Disable implicit builtin knowledge of functions">; 1974def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, 1975 HelpText<"Disable implicit builtin knowledge of a specific function">; 1976def fno_diagnostics_color : Flag<["-"], "fno-diagnostics-color">, Group<f_Group>, 1977 Flags<[CoreOption, NoXarchOption]>; 1978def fno_common : Flag<["-"], "fno-common">, Group<f_Group>, Flags<[CC1Option]>, 1979 HelpText<"Compile common globals like normal definitions">; 1980def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>, 1981 Flags<[NoXarchOption]>; 1982defm digraphs : BoolFOption<"digraphs", 1983 LangOpts<"Digraphs">, Default<std#".hasDigraphs()">, 1984 PosFlag<SetTrue, [], "Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)">, 1985 NegFlag<SetFalse, [], "Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'">, 1986 BothFlags<[CC1Option]>>; 1987def fno_declspec : Flag<["-"], "fno-declspec">, Group<f_clang_Group>, 1988 HelpText<"Disallow __declspec as a keyword">, Flags<[CC1Option]>; 1989def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>, 1990 HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>; 1991def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>; 1992def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>; 1993def fno_inline : Flag<["-"], "fno-inline">, Group<f_clang_Group>, Flags<[CC1Option]>; 1994def fno_global_isel : Flag<["-"], "fno-global-isel">, Group<f_clang_Group>, 1995 HelpText<"Disables the global instruction selector">; 1996def fno_experimental_isel : Flag<["-"], "fno-experimental-isel">, Group<f_clang_Group>, 1997 Alias<fno_global_isel>; 1998def fveclib : Joined<["-"], "fveclib=">, Group<f_Group>, Flags<[CC1Option]>, 1999 HelpText<"Use the given vector functions library">, 2000 Values<"Accelerate,libmvec,MASSV,SVML,none">, 2001 NormalizedValuesScope<"CodeGenOptions">, 2002 NormalizedValues<["Accelerate", "LIBMVEC", "MASSV", "SVML", "NoLibrary"]>, 2003 MarshallingInfoString<CodeGenOpts<"VecLib">, "NoLibrary">, AutoNormalizeEnum; 2004def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>, 2005 Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>; 2006def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>, 2007 Flags<[NoXarchOption]>; 2008def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>, 2009 Flags<[NoXarchOption]>; 2010def fno_module_maps : Flag <["-"], "fno-module-maps">, Alias<fno_implicit_module_maps>; 2011def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>, 2012 Flags<[NoXarchOption]>; 2013def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>, 2014 Flags<[NoXarchOption]>; 2015def fmodule_file_deps : Flag <["-"], "fmodule-file-deps">, Group<f_Group>, 2016 Flags<[NoXarchOption]>; 2017def fno_module_file_deps : Flag <["-"], "fno-module-file-deps">, Group<f_Group>, 2018 Flags<[NoXarchOption]>; 2019def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>, 2020 Flags<[CoreOption]>; 2021def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>, 2022 Flags<[CoreOption]>; 2023def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>; 2024def fno_objc_weak : Flag<["-"], "fno-objc-weak">, Group<f_Group>, Flags<[CC1Option]>; 2025def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>; 2026def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>, 2027 HelpText<"Do not treat C++ operator name keywords as synonyms for operators">, 2028 Flags<[CC1Option]>; 2029def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>, 2030 Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">, 2031 MarshallingInfoFlag<DiagnosticOpts<"AbsolutePath">>; 2032def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>, 2033 HelpText<"Disable the use of stack protectors">; 2034def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>, 2035 Flags<[NoXarchOption, CoreOption]>; 2036def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>; 2037def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>; 2038def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>; 2039def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>; 2040def fno_temp_file : Flag<["-"], "fno-temp-file">, Group<f_Group>, 2041 Flags<[CC1Option, CoreOption]>, HelpText< 2042 "Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes">, 2043 MarshallingInfoNegativeFlag<FrontendOpts<"UseTemporary">>; 2044defm use_cxa_atexit : BoolFOption<"use-cxa-atexit", 2045 CodeGenOpts<"CXAAtExit">, DefaultTrue, 2046 NegFlag<SetFalse, [CC1Option], "Don't use __cxa_atexit for calling destructors">, 2047 PosFlag<SetTrue>>; 2048def fno_unit_at_a_time : Flag<["-"], "fno-unit-at-a-time">, Group<f_Group>; 2049def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>; 2050def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>, 2051 MarshallingInfoNegativeFlag<CodeGenOpts<"AsmVerbose">>; 2052def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>; 2053def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>; 2054def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>, 2055 HelpText<"Synthesize retain and release calls for Objective-C pointers">; 2056def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>; 2057defm objc_convert_messages_to_runtime_calls : BoolFOption<"objc-convert-messages-to-runtime-calls", 2058 CodeGenOpts<"ObjCConvertMessagesToRuntimeCalls">, DefaultTrue, 2059 NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue>>; 2060defm objc_arc_exceptions : OptInFFlag<"objc-arc-exceptions", 2061 "Use EH-safe code when synthesizing retains and releases in -fobjc-arc", 2062 "", "", [], CodeGenOpts<"ObjCAutoRefCountExceptions">>; 2063def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>; 2064def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>; 2065defm objc_exceptions : BoolFOption<"objc-exceptions", 2066 LangOpts<"ObjCExceptions">, DefaultFalse, 2067 PosFlag<SetTrue, [CC1Option], "Enable Objective-C exceptions">, NegFlag<SetFalse>>; 2068defm application_extension : BoolFOption<"application-extension", 2069 LangOpts<"AppExt">, DefaultFalse, 2070 PosFlag<SetTrue, [CC1Option], "Restrict code to those available for App Extensions">, 2071 NegFlag<SetFalse>>; 2072defm relaxed_template_template_args : BoolFOption<"relaxed-template-template-args", 2073 LangOpts<"RelaxedTemplateTemplateArgs">, DefaultFalse, 2074 PosFlag<SetTrue, [CC1Option], "Enable C++17 relaxed template template argument matching">, 2075 NegFlag<SetFalse>>; 2076defm sized_deallocation : BoolFOption<"sized-deallocation", 2077 LangOpts<"SizedDeallocation">, DefaultFalse, 2078 PosFlag<SetTrue, [CC1Option], "Enable C++14 sized global deallocation functions">, 2079 NegFlag<SetFalse>>; 2080def faligned_allocation : Flag<["-"], "faligned-allocation">, Flags<[CC1Option]>, 2081 HelpText<"Enable C++17 aligned allocation functions">, Group<f_Group>; 2082def fno_aligned_allocation: Flag<["-"], "fno-aligned-allocation">, 2083 Group<f_Group>, Flags<[CC1Option]>; 2084def fnew_alignment_EQ : Joined<["-"], "fnew-alignment=">, 2085 HelpText<"Specifies the largest alignment guaranteed by '::operator new(size_t)'">, 2086 MetaVarName<"<align>">, Group<f_Group>, Flags<[CC1Option]>, 2087 MarshallingInfoStringInt<LangOpts<"NewAlignOverride">>; 2088def : Separate<["-"], "fnew-alignment">, Alias<fnew_alignment_EQ>; 2089def : Flag<["-"], "faligned-new">, Alias<faligned_allocation>; 2090def : Flag<["-"], "fno-aligned-new">, Alias<fno_aligned_allocation>; 2091def faligned_new_EQ : Joined<["-"], "faligned-new=">; 2092 2093def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>; 2094def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>; 2095defm objc_infer_related_result_type : BoolFOption<"objc-infer-related-result-type", 2096 LangOpts<"ObjCInferRelatedResultType">, DefaultTrue, 2097 NegFlag<SetFalse, [CC1Option], "do not infer Objective-C related result type based on method family">, 2098 PosFlag<SetTrue>>; 2099def fobjc_link_runtime: Flag<["-"], "fobjc-link-runtime">, Group<f_Group>; 2100def fobjc_weak : Flag<["-"], "fobjc-weak">, Group<f_Group>, Flags<[CC1Option]>, 2101 HelpText<"Enable ARC-style weak references in Objective-C">; 2102 2103// Objective-C ABI options. 2104def fobjc_runtime_EQ : Joined<["-"], "fobjc-runtime=">, Group<f_Group>, Flags<[CC1Option, CoreOption]>, 2105 HelpText<"Specify the target Objective-C runtime kind and version">; 2106def fobjc_abi_version_EQ : Joined<["-"], "fobjc-abi-version=">, Group<f_Group>; 2107def fobjc_nonfragile_abi_version_EQ : Joined<["-"], "fobjc-nonfragile-abi-version=">, Group<f_Group>; 2108def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>; 2109def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>; 2110 2111def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>; 2112def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>; 2113def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>, 2114 HelpText<"Parse OpenMP pragmas and generate parallel code.">, 2115 MarshallingInfoFlag<LangOpts<"OpenMP">, "0u">, Normalizer<"makeFlagToValueNormalizer(50u)">; 2116def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>; 2117def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>; 2118def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>; 2119def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>, 2120 Flags<[NoArgumentUnused, HelpHidden]>; 2121def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>, 2122 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2123def fopenmp_targets_EQ : CommaJoined<["-"], "fopenmp-targets=">, Flags<[NoXarchOption, CC1Option]>, 2124 HelpText<"Specify comma-separated list of triples OpenMP offloading targets to be supported">; 2125def fopenmp_relocatable_target : Flag<["-"], "fopenmp-relocatable-target">, 2126 Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2127def fnoopenmp_relocatable_target : Flag<["-"], "fnoopenmp-relocatable-target">, 2128 Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2129def fopenmp_simd : Flag<["-"], "fopenmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>, 2130 HelpText<"Emit OpenMP code only for SIMD-based constructs.">; 2131def fopenmp_enable_irbuilder : Flag<["-"], "fopenmp-enable-irbuilder">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused, HelpHidden]>, 2132 HelpText<"Use the experimental OpenMP-IR-Builder codegen path.">; 2133def fno_openmp_simd : Flag<["-"], "fno-openmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>; 2134def fopenmp_cuda_mode : Flag<["-"], "fopenmp-cuda-mode">, Group<f_Group>, 2135 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2136def fno_openmp_cuda_mode : Flag<["-"], "fno-openmp-cuda-mode">, Group<f_Group>, 2137 Flags<[NoArgumentUnused, HelpHidden]>; 2138def fopenmp_cuda_force_full_runtime : Flag<["-"], "fopenmp-cuda-force-full-runtime">, Group<f_Group>, 2139 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2140def fno_openmp_cuda_force_full_runtime : Flag<["-"], "fno-openmp-cuda-force-full-runtime">, Group<f_Group>, 2141 Flags<[NoArgumentUnused, HelpHidden]>; 2142def fopenmp_cuda_number_of_sm_EQ : Joined<["-"], "fopenmp-cuda-number-of-sm=">, Group<f_Group>, 2143 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2144def fopenmp_cuda_blocks_per_sm_EQ : Joined<["-"], "fopenmp-cuda-blocks-per-sm=">, Group<f_Group>, 2145 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2146def fopenmp_cuda_teams_reduction_recs_num_EQ : Joined<["-"], "fopenmp-cuda-teams-reduction-recs-num=">, Group<f_Group>, 2147 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>; 2148defm openmp_optimistic_collapse : BoolFOption<"openmp-optimistic-collapse", 2149 LangOpts<"OpenMPOptimisticCollapse">, DefaultFalse, 2150 PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>, BothFlags<[NoArgumentUnused, HelpHidden]>>; 2151def fopenmp_cuda_parallel_target_regions : Flag<["-"], "fopenmp-cuda-parallel-target-regions">, Group<f_Group>, 2152 Flags<[CC1Option, NoArgumentUnused, HelpHidden]>, 2153 HelpText<"Support parallel execution of target regions on Cuda-based devices.">; 2154def fno_openmp_cuda_parallel_target_regions : Flag<["-"], "fno-openmp-cuda-parallel-target-regions">, Group<f_Group>, 2155 Flags<[NoArgumentUnused, HelpHidden]>, 2156 HelpText<"Support only serial execution of target regions on Cuda-based devices.">; 2157def static_openmp: Flag<["-"], "static-openmp">, 2158 HelpText<"Use the static host OpenMP runtime while linking.">; 2159def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>; 2160def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>; 2161defm escaping_block_tail_calls : BoolFOption<"escaping-block-tail-calls", 2162 CodeGenOpts<"NoEscapingBlockTailCalls">, DefaultFalse, 2163 NegFlag<SetTrue, [CC1Option]>, PosFlag<SetFalse>>; 2164def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">; 2165def force__flat__namespace : Flag<["-"], "force_flat_namespace">; 2166def force__load : Separate<["-"], "force_load">; 2167def force_addr : Joined<["-"], "fforce-addr">, Group<clang_ignored_f_Group>; 2168def foutput_class_dir_EQ : Joined<["-"], "foutput-class-dir=">, Group<f_Group>; 2169def fpack_struct : Flag<["-"], "fpack-struct">, Group<f_Group>; 2170def fno_pack_struct : Flag<["-"], "fno-pack-struct">, Group<f_Group>; 2171def fpack_struct_EQ : Joined<["-"], "fpack-struct=">, Group<f_Group>, Flags<[CC1Option]>, 2172 HelpText<"Specify the default maximum struct packing alignment">, 2173 MarshallingInfoStringInt<LangOpts<"PackStruct">>; 2174def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>, 2175 HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">, 2176 MarshallingInfoStringInt<LangOpts<"MaxTypeAlign">>; 2177def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>; 2178defm pascal_strings : BoolFOption<"pascal-strings", 2179 LangOpts<"PascalStrings">, DefaultFalse, 2180 PosFlag<SetTrue, [CC1Option], "Recognize and construct Pascal-style string literals">, 2181 NegFlag<SetFalse>>; 2182// Note: This flag has different semantics in the driver and in -cc1. The driver accepts -fpatchable-function-entry=M,N 2183// and forwards it to -cc1 as -fpatchable-function-entry=M and -fpatchable-function-entry-offset=N. In -cc1, both flags 2184// are treated as a single integer. 2185def fpatchable_function_entry_EQ : Joined<["-"], "fpatchable-function-entry=">, Group<f_Group>, Flags<[CC1Option]>, 2186 MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">, 2187 MarshallingInfoStringInt<CodeGenOpts<"PatchableFunctionEntryCount">>; 2188def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>, 2189 HelpText<"Override the default ABI to return all structs on the stack">; 2190def fpch_preprocess : Flag<["-"], "fpch-preprocess">, Group<f_Group>; 2191def fpic : Flag<["-"], "fpic">, Group<f_Group>; 2192def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>; 2193def fpie : Flag<["-"], "fpie">, Group<f_Group>; 2194def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>; 2195def fdirect_access_external_data : Flag<["-"], "fdirect-access-external-data">, Group<f_Group>, Flags<[CC1Option]>, 2196 HelpText<"Don't use GOT indirection to reference external data symbols">; 2197def fno_direct_access_external_data : Flag<["-"], "fno-direct-access-external-data">, Group<f_Group>, Flags<[CC1Option]>, 2198 HelpText<"Use GOT indirection to reference external data symbols">; 2199defm plt : BoolFOption<"plt", 2200 CodeGenOpts<"NoPLT">, DefaultFalse, 2201 NegFlag<SetTrue, [CC1Option], "Use GOT indirection instead of PLT to make external function calls (x86 only)">, 2202 PosFlag<SetFalse>>; 2203defm ropi : BoolFOption<"ropi", 2204 LangOpts<"ROPI">, DefaultFalse, 2205 PosFlag<SetTrue, [CC1Option], "Generate read-only position independent code (ARM only)">, 2206 NegFlag<SetFalse>>; 2207defm rwpi : BoolFOption<"rwpi", 2208 LangOpts<"RWPI">, DefaultFalse, 2209 PosFlag<SetTrue, [CC1Option], "Generate read-write position independent code (ARM only)">, 2210 NegFlag<SetFalse>>; 2211def fplugin_EQ : Joined<["-"], "fplugin=">, Group<f_Group>, Flags<[NoXarchOption]>, MetaVarName<"<dsopath>">, 2212 HelpText<"Load the named plugin (dynamic shared object)">; 2213def fpass_plugin_EQ : Joined<["-"], "fpass-plugin=">, 2214 Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<dsopath>">, 2215 HelpText<"Load pass plugin from a dynamic shared object file (only with new pass manager).">, 2216 MarshallingInfoStringVector<CodeGenOpts<"PassPlugins">>; 2217defm preserve_as_comments : BoolFOption<"preserve-as-comments", 2218 CodeGenOpts<"PreserveAsmComments">, DefaultTrue, 2219 NegFlag<SetFalse, [CC1Option], "Do not preserve comments in inline assembly">, 2220 PosFlag<SetTrue>>; 2221def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>; 2222def frandom_seed_EQ : Joined<["-"], "frandom-seed=">, Group<clang_ignored_f_Group>; 2223def freg_struct_return : Flag<["-"], "freg-struct-return">, Group<f_Group>, Flags<[CC1Option]>, 2224 HelpText<"Override the default ABI to return small structs in registers">; 2225defm rtti : OptOutFFlag<"rtti", "", "Disable generation of rtti information">; 2226defm rtti_data : OptOutFFlag<"rtti-data", "", "Disable generation of RTTI data">; 2227def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>; 2228defm short_enums : BoolFOption<"short-enums", 2229 LangOpts<"ShortEnums">, DefaultFalse, 2230 PosFlag<SetTrue, [CC1Option], "Allocate to an enum type only as many bytes as it" 2231 " needs for the declared range of possible values">, 2232 NegFlag<SetFalse>>; 2233def fchar8__t : Flag<["-"], "fchar8_t">, Group<f_Group>, Flags<[CC1Option]>, 2234 HelpText<"Enable C++ builtin type char8_t">; 2235def fno_char8__t : Flag<["-"], "fno-char8_t">, Group<f_Group>, Flags<[CC1Option]>, 2236 HelpText<"Disable C++ builtin type char8_t">; 2237def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>, 2238 HelpText<"Force wchar_t to be a short unsigned int">; 2239def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>, 2240 HelpText<"Force wchar_t to be an unsigned int">; 2241def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>, 2242 HelpText<"Which overload candidates to show when overload resolution fails: " 2243 "best|all; defaults to all">, Values<"best,all">, 2244 NormalizedValues<["Ovl_Best", "Ovl_All"]>, 2245 MarshallingInfoString<DiagnosticOpts<"ShowOverloads">, "Ovl_All">, AutoNormalizeEnum; 2246defm show_column : BoolFOption<"show-column", 2247 DiagnosticOpts<"ShowColumn">, DefaultTrue, 2248 NegFlag<SetFalse, [CC1Option], "Do not include column number on diagnostics">, 2249 PosFlag<SetTrue>>; 2250defm show_source_location : BoolFOption<"show-source-location", 2251 DiagnosticOpts<"ShowLocation">, DefaultTrue, 2252 NegFlag<SetFalse, [CC1Option], "Do not include source location information with diagnostics">, 2253 PosFlag<SetTrue>>; 2254defm spell_checking : BoolFOption<"spell-checking", 2255 LangOpts<"SpellChecking">, DefaultTrue, 2256 NegFlag<SetFalse, [CC1Option], "Disable spell-checking">, PosFlag<SetTrue>>; 2257def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>; 2258def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>; 2259defm signed_char : OptOutFFlag<"signed-char", "char is signed", "char is unsigned">; 2260def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>; 2261def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>, 2262 HelpText<"Enable stack protectors for all functions">; 2263defm stack_clash_protection : BoolFOption<"stack-clash-protection", 2264 CodeGenOpts<"StackClashProtector">, DefaultFalse, 2265 PosFlag<SetTrue, [CC1Option], "Enable">, NegFlag<SetFalse, [], "Disable">, 2266 BothFlags<[], " stack clash protection">>; 2267def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>, 2268 HelpText<"Enable stack protectors for some functions vulnerable to stack smashing. " 2269 "Compared to -fstack-protector, this uses a stronger heuristic " 2270 "that includes functions containing arrays of any size (and any type), " 2271 "as well as any calls to alloca or the taking of an address from a local variable">; 2272def fstack_protector : Flag<["-"], "fstack-protector">, Group<f_Group>, 2273 HelpText<"Enable stack protectors for some functions vulnerable to stack smashing. " 2274 "This uses a loose heuristic which considers functions vulnerable if they " 2275 "contain a char (or 8bit integer) array or constant sized calls to alloca " 2276 ", which are of greater size than ssp-buffer-size (default: 8 bytes). All " 2277 "variable sized calls to alloca are considered vulnerable. A function with " 2278 "a stack protector has a guard value added to the stack frame that is " 2279 "checked on function exit. The guard value must be positioned in the " 2280 "stack frame such that a buffer overflow from a vulnerable variable will " 2281 "overwrite the guard value before overwriting the function's return " 2282 "address. The reference stack guard value is stored in a global variable.">; 2283def ftrivial_auto_var_init : Joined<["-"], "ftrivial-auto-var-init=">, Group<f_Group>, 2284 Flags<[CC1Option, CoreOption]>, HelpText<"Initialize trivial automatic stack variables: uninitialized (default)" 2285 " | pattern">, Values<"uninitialized,zero,pattern">, 2286 NormalizedValuesScope<"LangOptions::TrivialAutoVarInitKind">, 2287 NormalizedValues<["Uninitialized", "Zero", "Pattern"]>, 2288 MarshallingInfoString<LangOpts<"TrivialAutoVarInit">, "Uninitialized">, AutoNormalizeEnum; 2289def enable_trivial_var_init_zero : Flag<["-"], "enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang">, 2290 Flags<[CC1Option, CoreOption]>, 2291 HelpText<"Trivial automatic variable initialization to zero is only here for benchmarks, it'll eventually be removed, and I'm OK with that because I'm only using it to benchmark">; 2292def ftrivial_auto_var_init_stop_after : Joined<["-"], "ftrivial-auto-var-init-stop-after=">, Group<f_Group>, 2293 Flags<[CC1Option, CoreOption]>, HelpText<"Stop initializing trivial automatic stack variables after the specified number of instances">, 2294 MarshallingInfoStringInt<LangOpts<"TrivialAutoVarInitStopAfter">>; 2295def fstandalone_debug : Flag<["-"], "fstandalone-debug">, Group<f_Group>, Flags<[CoreOption]>, 2296 HelpText<"Emit full debug info for all types used by the program">; 2297def fno_standalone_debug : Flag<["-"], "fno-standalone-debug">, Group<f_Group>, Flags<[CoreOption]>, 2298 HelpText<"Limit debug information produced to reduce size of debug binary">; 2299def flimit_debug_info : Flag<["-"], "flimit-debug-info">, Flags<[CoreOption]>, Alias<fno_standalone_debug>; 2300def fno_limit_debug_info : Flag<["-"], "fno-limit-debug-info">, Flags<[CoreOption]>, Alias<fstandalone_debug>; 2301def fdebug_macro : Flag<["-"], "fdebug-macro">, Group<f_Group>, Flags<[CoreOption]>, 2302 HelpText<"Emit macro debug information">; 2303def fno_debug_macro : Flag<["-"], "fno-debug-macro">, Group<f_Group>, Flags<[CoreOption]>, 2304 HelpText<"Do not emit macro debug information">; 2305def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>, 2306 Flags<[NoXarchOption, CoreOption]>; 2307def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>, 2308 HelpText<"Enable optimizations based on the strict definition of an enum's " 2309 "value range">, 2310 MarshallingInfoFlag<CodeGenOpts<"StrictEnums">>; 2311defm strict_vtable_pointers : BoolFOption<"strict-vtable-pointers", 2312 CodeGenOpts<"StrictVTablePointers">, DefaultFalse, 2313 PosFlag<SetTrue, [CC1Option], "Enable optimizations based on the strict rules for" 2314 " overwriting polymorphic C++ objects">, 2315 NegFlag<SetFalse>>; 2316def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>; 2317def fsyntax_only : Flag<["-"], "fsyntax-only">, 2318 Flags<[NoXarchOption,CoreOption,CC1Option,FC1Option]>, Group<Action_Group>; 2319def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>; 2320def ftemplate_depth_EQ : Joined<["-"], "ftemplate-depth=">, Group<f_Group>; 2321def ftemplate_depth_ : Joined<["-"], "ftemplate-depth-">, Group<f_Group>; 2322def ftemplate_backtrace_limit_EQ : Joined<["-"], "ftemplate-backtrace-limit=">, 2323 Group<f_Group>; 2324def foperator_arrow_depth_EQ : Joined<["-"], "foperator-arrow-depth=">, 2325 Group<f_Group>; 2326 2327def fsave_optimization_record : Flag<["-"], "fsave-optimization-record">, 2328 Group<f_Group>, HelpText<"Generate a YAML optimization record file">; 2329def fsave_optimization_record_EQ : Joined<["-"], "fsave-optimization-record=">, 2330 Group<f_Group>, HelpText<"Generate an optimization record file in a specific format">, 2331 MetaVarName<"<format>">; 2332def fno_save_optimization_record : Flag<["-"], "fno-save-optimization-record">, 2333 Group<f_Group>, Flags<[NoArgumentUnused]>; 2334def foptimization_record_file_EQ : Joined<["-"], "foptimization-record-file=">, 2335 Group<f_Group>, 2336 HelpText<"Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.">, 2337 MetaVarName<"<file>">; 2338def foptimization_record_passes_EQ : Joined<["-"], "foptimization-record-passes=">, 2339 Group<f_Group>, 2340 HelpText<"Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)">, 2341 MetaVarName<"<regex>">; 2342 2343def fvectorize : Flag<["-"], "fvectorize">, Group<f_Group>, 2344 HelpText<"Enable the loop vectorization passes">; 2345def fno_vectorize : Flag<["-"], "fno-vectorize">, Group<f_Group>; 2346def : Flag<["-"], "ftree-vectorize">, Alias<fvectorize>; 2347def : Flag<["-"], "fno-tree-vectorize">, Alias<fno_vectorize>; 2348def fslp_vectorize : Flag<["-"], "fslp-vectorize">, Group<f_Group>, 2349 HelpText<"Enable the superword-level parallelism vectorization passes">; 2350def fno_slp_vectorize : Flag<["-"], "fno-slp-vectorize">, Group<f_Group>; 2351def : Flag<["-"], "ftree-slp-vectorize">, Alias<fslp_vectorize>; 2352def : Flag<["-"], "fno-tree-slp-vectorize">, Alias<fno_slp_vectorize>; 2353def Wlarge_by_value_copy_def : Flag<["-"], "Wlarge-by-value-copy">, 2354 HelpText<"Warn if a function definition returns or accepts an object larger " 2355 "in bytes than a given value">, Flags<[HelpHidden]>; 2356def Wlarge_by_value_copy_EQ : Joined<["-"], "Wlarge-by-value-copy=">, Flags<[CC1Option]>, 2357 MarshallingInfoStringInt<LangOpts<"NumLargeByValueCopy">>; 2358 2359// These "special" warning flags are effectively processed as f_Group flags by the driver: 2360// Just silence warnings about -Wlarger-than for now. 2361def Wlarger_than_EQ : Joined<["-"], "Wlarger-than=">, Group<clang_ignored_f_Group>; 2362def Wlarger_than_ : Joined<["-"], "Wlarger-than-">, Alias<Wlarger_than_EQ>; 2363def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[NoXarchOption]>; 2364 2365def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>; 2366defm threadsafe_statics : BoolFOption<"threadsafe-statics", 2367 LangOpts<"ThreadsafeStatics">, DefaultTrue, 2368 NegFlag<SetFalse, [CC1Option], "Do not emit code to make initialization of local statics thread safe">, 2369 PosFlag<SetTrue>>; 2370def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>, 2371 MarshallingInfoFlag<CodeGenOpts<"TimePasses">>; 2372def ftime_report_EQ: Joined<["-"], "ftime-report=">, Group<f_Group>, 2373 Flags<[CC1Option]>, Values<"per-pass,per-pass-run">, 2374 MarshallingInfoFlag<CodeGenOpts<"TimePassesPerRun">>, 2375 HelpText<"(For new pass manager) \"per-pass\": one report for each pass; " 2376 "\"per-pass-run\": one report for each pass invocation">; 2377def ftime_trace : Flag<["-"], "ftime-trace">, Group<f_Group>, 2378 HelpText<"Turn on time profiler. Generates JSON file based on output filename.">, 2379 DocBrief<[{ 2380Turn on time profiler. Generates JSON file based on output filename. Results 2381can be analyzed with chrome://tracing or `Speedscope App 2382<https://www.speedscope.app>`_ for flamegraph visualization.}]>, 2383 Flags<[CC1Option, CoreOption]>, 2384 MarshallingInfoFlag<FrontendOpts<"TimeTrace">>; 2385def ftime_trace_granularity_EQ : Joined<["-"], "ftime-trace-granularity=">, Group<f_Group>, 2386 HelpText<"Minimum time granularity (in microseconds) traced by time profiler">, 2387 Flags<[CC1Option, CoreOption]>, 2388 MarshallingInfoStringInt<FrontendOpts<"TimeTraceGranularity">, "500u">; 2389def fproc_stat_report : Joined<["-"], "fproc-stat-report">, Group<f_Group>, 2390 HelpText<"Print subprocess statistics">; 2391def fproc_stat_report_EQ : Joined<["-"], "fproc-stat-report=">, Group<f_Group>, 2392 HelpText<"Save subprocess statistics to the given file">; 2393def ftlsmodel_EQ : Joined<["-"], "ftls-model=">, Group<f_Group>, Flags<[CC1Option]>, 2394 Values<"global-dynamic,local-dynamic,initial-exec,local-exec">, 2395 NormalizedValuesScope<"CodeGenOptions">, 2396 NormalizedValues<["GeneralDynamicTLSModel", "LocalDynamicTLSModel", "InitialExecTLSModel", "LocalExecTLSModel"]>, 2397 MarshallingInfoString<CodeGenOpts<"DefaultTLSModel">, "GeneralDynamicTLSModel">, AutoNormalizeEnum; 2398def ftrapv : Flag<["-"], "ftrapv">, Group<f_Group>, Flags<[CC1Option]>, 2399 HelpText<"Trap on integer overflow">; 2400def ftrapv_handler_EQ : Joined<["-"], "ftrapv-handler=">, Group<f_Group>, 2401 MetaVarName<"<function name>">, 2402 HelpText<"Specify the function to be called on overflow">; 2403def ftrapv_handler : Separate<["-"], "ftrapv-handler">, Group<f_Group>, Flags<[CC1Option]>; 2404def ftrap_function_EQ : Joined<["-"], "ftrap-function=">, Group<f_Group>, Flags<[CC1Option]>, 2405 HelpText<"Issue call to specified function rather than a trap instruction">, 2406 MarshallingInfoString<CodeGenOpts<"TrapFuncName">>; 2407def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>; 2408def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>, 2409 HelpText<"Turn on loop unroller">, Flags<[CC1Option]>; 2410def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>, 2411 HelpText<"Turn off loop unroller">, Flags<[CC1Option]>; 2412defm reroll_loops : BoolFOption<"reroll-loops", 2413 CodeGenOpts<"RerollLoops">, DefaultFalse, 2414 PosFlag<SetTrue, [CC1Option], "Turn on loop reroller">, NegFlag<SetFalse>>; 2415def ffinite_loops: Flag<["-"], "ffinite-loops">, Group<f_Group>, 2416 HelpText<"Assume all loops are finite.">, Flags<[CC1Option]>; 2417def fno_finite_loops: Flag<["-"], "fno-finite-loops">, Group<f_Group>, 2418 HelpText<"Do not assume that any loop is finite.">, Flags<[CC1Option]>; 2419 2420def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>, 2421 HelpText<"Process trigraph sequences">, Flags<[CC1Option]>; 2422def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>, 2423 HelpText<"Do not process trigraph sequences">, Flags<[CC1Option]>; 2424def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>; 2425def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>; 2426def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">; 2427def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>; 2428defm register_global_dtors_with_atexit : BoolFOption<"register-global-dtors-with-atexit", 2429 CodeGenOpts<"RegisterGlobalDtorsWithAtExit">, DefaultFalse, 2430 PosFlag<SetTrue, [CC1Option], "Use">, NegFlag<SetFalse, [], "Don't use">, 2431 BothFlags<[], " atexit or __cxa_atexit to register global destructors">>; 2432defm use_init_array : BoolFOption<"use-init-array", 2433 CodeGenOpts<"UseInitArray">, DefaultTrue, 2434 NegFlag<SetFalse, [CC1Option], "Use .ctors/.dtors instead of .init_array/.fini_array">, 2435 PosFlag<SetTrue>>; 2436def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>; 2437def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>, 2438 HelpText<"Generate verbose assembly output">; 2439def dA : Flag<["-"], "dA">, Alias<fverbose_asm>; 2440defm visibility_from_dllstorageclass : BoolFOption<"visibility-from-dllstorageclass", 2441 LangOpts<"VisibilityFromDLLStorageClass">, DefaultFalse, 2442 PosFlag<SetTrue, [CC1Option], "Set the visiblity of symbols in the generated code from their DLL storage class">, 2443 NegFlag<SetFalse>>; 2444def fvisibility_dllexport_EQ : Joined<["-"], "fvisibility-dllexport=">, Group<f_Group>, Flags<[CC1Option]>, 2445 HelpText<"The visibility for dllexport defintions [-fvisibility-from-dllstorageclass]">, 2446 MarshallingInfoVisibility<LangOpts<"DLLExportVisibility">, "DefaultVisibility">, 2447 ShouldParseIf<fvisibility_from_dllstorageclass.KeyPath>; 2448def fvisibility_nodllstorageclass_EQ : Joined<["-"], "fvisibility-nodllstorageclass=">, Group<f_Group>, Flags<[CC1Option]>, 2449 HelpText<"The visibility for defintiions without an explicit DLL export class [-fvisibility-from-dllstorageclass]">, 2450 MarshallingInfoVisibility<LangOpts<"NoDLLStorageClassVisibility">, "HiddenVisibility">, 2451 ShouldParseIf<fvisibility_from_dllstorageclass.KeyPath>; 2452def fvisibility_externs_dllimport_EQ : Joined<["-"], "fvisibility-externs-dllimport=">, Group<f_Group>, Flags<[CC1Option]>, 2453 HelpText<"The visibility for dllimport external declarations [-fvisibility-from-dllstorageclass]">, 2454 MarshallingInfoVisibility<LangOpts<"ExternDeclDLLImportVisibility">, "DefaultVisibility">, 2455 ShouldParseIf<fvisibility_from_dllstorageclass.KeyPath>; 2456def fvisibility_externs_nodllstorageclass_EQ : Joined<["-"], "fvisibility-externs-nodllstorageclass=">, Group<f_Group>, Flags<[CC1Option]>, 2457 HelpText<"The visibility for external declarations without an explicit DLL dllstorageclass [-fvisibility-from-dllstorageclass]">, 2458 MarshallingInfoVisibility<LangOpts<"ExternDeclNoDLLStorageClassVisibility">, "HiddenVisibility">, 2459 ShouldParseIf<fvisibility_from_dllstorageclass.KeyPath>; 2460def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>, 2461 HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">; 2462def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>, 2463 HelpText<"Give inline C++ member functions hidden visibility by default">, 2464 Flags<[CC1Option]>, MarshallingInfoFlag<LangOpts<"InlineVisibilityHidden">>; 2465defm visibility_inlines_hidden_static_local_var : BoolFOption<"visibility-inlines-hidden-static-local-var", 2466 LangOpts<"VisibilityInlinesHiddenStaticLocalVar">, DefaultFalse, 2467 PosFlag<SetTrue, [CC1Option], "When -fvisibility-inlines-hidden is enabled, static variables in" 2468 " inline C++ member functions will also be given hidden visibility by default">, 2469 NegFlag<SetFalse, [], "Disables -fvisibility-inlines-hidden-static-local-var" 2470 " (this is the default on non-darwin targets)">, BothFlags<[CC1Option]>>; 2471def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>, 2472 HelpText<"Give global types 'default' visibility and global functions and " 2473 "variables 'hidden' visibility by default">; 2474def fvisibility_global_new_delete_hidden : Flag<["-"], "fvisibility-global-new-delete-hidden">, Group<f_Group>, 2475 HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>, 2476 MarshallingInfoFlag<LangOpts<"GlobalAllocationFunctionVisibilityHidden">>; 2477defm whole_program_vtables : BoolFOption<"whole-program-vtables", 2478 CodeGenOpts<"WholeProgramVTables">, DefaultFalse, 2479 PosFlag<SetTrue, [CC1Option], "Enables whole-program vtable optimization. Requires -flto">, 2480 NegFlag<SetFalse>, BothFlags<[CoreOption]>>; 2481defm split_lto_unit : BoolFOption<"split-lto-unit", 2482 CodeGenOpts<"EnableSplitLTOUnit">, DefaultFalse, 2483 PosFlag<SetTrue, [CC1Option], "Enables splitting of the LTO unit">, 2484 NegFlag<SetFalse>, BothFlags<[CoreOption]>>; 2485defm force_emit_vtables : BoolFOption<"force-emit-vtables", 2486 CodeGenOpts<"ForceEmitVTables">, DefaultFalse, 2487 PosFlag<SetTrue, [CC1Option], "Emits more virtual tables to improve devirtualization">, 2488 NegFlag<SetFalse>, BothFlags<[CoreOption]>>; 2489defm virtual_function_elimination : BoolFOption<"virtual-function-elimination", 2490 CodeGenOpts<"VirtualFunctionElimination">, DefaultFalse, 2491 PosFlag<SetTrue, [CC1Option], "Enables dead virtual function elimination optimization. Requires -flto=full">, 2492 NegFlag<SetFalse>, BothFlags<[CoreOption]>>; 2493 2494def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>, 2495 HelpText<"Treat signed integer overflow as two's complement">; 2496def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>, 2497 HelpText<"Store string literals as writable data">, 2498 MarshallingInfoFlag<LangOpts<"WritableStrings">>; 2499defm zero_initialized_in_bss : BoolFOption<"zero-initialized-in-bss", 2500 CodeGenOpts<"NoZeroInitializedInBSS">, DefaultFalse, 2501 NegFlag<SetTrue, [CC1Option], "Don't place zero initialized data in BSS">, 2502 PosFlag<SetFalse>>; 2503defm function_sections : OptInFFlag<"function-sections", "Place each function in its own section">; 2504def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>, 2505 Flags<[CC1Option, CC1AsOption]>, 2506 HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">, 2507 DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>, 2508 Values<"all,labels,none,list=">, 2509 MarshallingInfoString<CodeGenOpts<"BBSections">, [{"none"}]>; 2510defm data_sections : BoolFOption<"data-sections", 2511 CodeGenOpts<"DataSections">, DefaultFalse, 2512 PosFlag<SetTrue, [CC1Option], "Place each data in its own section">, NegFlag<SetFalse>>; 2513defm stack_size_section : BoolFOption<"stack-size-section", 2514 CodeGenOpts<"StackSizeSection">, DefaultFalse, 2515 PosFlag<SetTrue, [CC1Option], "Emit section containing metadata on function stack sizes">, 2516 NegFlag<SetFalse>>; 2517 2518defm unique_basic_block_section_names : BoolFOption<"unique-basic-block-section-names", 2519 CodeGenOpts<"UniqueBasicBlockSectionNames">, DefaultFalse, 2520 PosFlag<SetTrue, [CC1Option], "Use unique names for basic block sections (ELF Only)">, 2521 NegFlag<SetFalse>>; 2522defm unique_internal_linkage_names : BoolFOption<"unique-internal-linkage-names", 2523 CodeGenOpts<"UniqueInternalLinkageNames">, DefaultFalse, 2524 PosFlag<SetTrue, [CC1Option], "Uniqueify Internal Linkage Symbol Names by appending" 2525 " the MD5 hash of the module path">, 2526 NegFlag<SetFalse>>; 2527defm unique_section_names : BoolFOption<"unique-section-names", 2528 CodeGenOpts<"UniqueSectionNames">, DefaultTrue, 2529 NegFlag<SetFalse, [CC1Option], "Don't use unique names for text and data sections">, 2530 PosFlag<SetTrue>>; 2531 2532defm split_machine_functions: BoolFOption<"split-machine-functions", 2533 CodeGenOpts<"SplitMachineFunctions">, DefaultFalse, 2534 PosFlag<SetTrue, [CC1Option], "Enable">, NegFlag<SetFalse, [], "Disable">, 2535 BothFlags<[], " late function splitting using profile information (x86 ELF)">>; 2536 2537defm strict_return : BoolFOption<"strict-return", 2538 CodeGenOpts<"StrictReturn">, DefaultTrue, 2539 NegFlag<SetFalse, [CC1Option], "Don't treat control flow paths that fall off the end" 2540 " of a non-void function as unreachable">, 2541 PosFlag<SetTrue>>; 2542 2543def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_Group>, 2544 Flags<[CC1Option]>, 2545 HelpText<"Enable matrix data type and related builtin functions">, 2546 MarshallingInfoFlag<LangOpts<"MatrixTypes">>; 2547 2548 2549def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>, 2550 HelpText<"Place debug types in their own section (ELF Only)">; 2551def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>; 2552defm debug_ranges_base_address : BoolFOption<"debug-ranges-base-address", 2553 CodeGenOpts<"DebugRangesBaseAddress">, DefaultFalse, 2554 PosFlag<SetTrue, [CC1Option], "Use DWARF base address selection entries in .debug_ranges">, 2555 NegFlag<SetFalse>>; 2556defm split_dwarf_inlining : BoolFOption<"split-dwarf-inlining", 2557 CodeGenOpts<"SplitDwarfInlining">, DefaultTrue, 2558 NegFlag<SetFalse, [CC1Option]>, 2559 PosFlag<SetTrue, [], "Provide minimal debug info in the object/executable" 2560 " to facilitate online symbolication/stack traces in the absence of" 2561 " .dwo/.dwp files when using Split DWARF">>; 2562def fdebug_default_version: Joined<["-"], "fdebug-default-version=">, Group<f_Group>, 2563 HelpText<"Default DWARF version to use, if a -g option caused DWARF debug info to be produced">; 2564def fdebug_prefix_map_EQ 2565 : Joined<["-"], "fdebug-prefix-map=">, Group<f_Group>, 2566 Flags<[CC1Option,CC1AsOption]>, 2567 HelpText<"remap file source paths in debug info">; 2568def fprofile_prefix_map_EQ 2569 : Joined<["-"], "fprofile-prefix-map=">, Group<f_Group>, 2570 Flags<[CC1Option]>, 2571 HelpText<"remap file source paths in coverage info">; 2572def ffile_prefix_map_EQ 2573 : Joined<["-"], "ffile-prefix-map=">, Group<f_Group>, 2574 HelpText<"remap file source paths in debug info and predefined preprocessor macros">; 2575def fmacro_prefix_map_EQ 2576 : Joined<["-"], "fmacro-prefix-map=">, Group<Preprocessor_Group>, Flags<[CC1Option]>, 2577 HelpText<"remap file source paths in predefined preprocessor macros">; 2578defm force_dwarf_frame : BoolFOption<"force-dwarf-frame", 2579 CodeGenOpts<"ForceDwarfFrameSection">, DefaultFalse, 2580 PosFlag<SetTrue, [CC1Option], "Always emit a debug frame section">, NegFlag<SetFalse>>; 2581def g_Flag : Flag<["-"], "g">, Group<g_Group>, 2582 HelpText<"Generate source-level debug information">; 2583def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>, 2584 Flags<[CoreOption]>, HelpText<"Emit debug line number tables only">; 2585def gline_directives_only : Flag<["-"], "gline-directives-only">, Group<gN_Group>, 2586 Flags<[CoreOption]>, HelpText<"Emit debug line info directives only">; 2587def gmlt : Flag<["-"], "gmlt">, Alias<gline_tables_only>; 2588def g0 : Flag<["-"], "g0">, Group<gN_Group>; 2589def g1 : Flag<["-"], "g1">, Group<gN_Group>, Alias<gline_tables_only>; 2590def g2 : Flag<["-"], "g2">, Group<gN_Group>; 2591def g3 : Flag<["-"], "g3">, Group<gN_Group>; 2592def ggdb : Flag<["-"], "ggdb">, Group<gTune_Group>; 2593def ggdb0 : Flag<["-"], "ggdb0">, Group<ggdbN_Group>; 2594def ggdb1 : Flag<["-"], "ggdb1">, Group<ggdbN_Group>; 2595def ggdb2 : Flag<["-"], "ggdb2">, Group<ggdbN_Group>; 2596def ggdb3 : Flag<["-"], "ggdb3">, Group<ggdbN_Group>; 2597def glldb : Flag<["-"], "glldb">, Group<gTune_Group>; 2598def gsce : Flag<["-"], "gsce">, Group<gTune_Group>; 2599// Equivalent to our default dwarf version. Forces usual dwarf emission when 2600// CodeView is enabled. 2601def gdwarf : Flag<["-"], "gdwarf">, Group<g_Group>, Flags<[CoreOption]>, 2602 HelpText<"Generate source-level debug information with the default dwarf version">; 2603def gdwarf_2 : Flag<["-"], "gdwarf-2">, Group<g_Group>, 2604 HelpText<"Generate source-level debug information with dwarf version 2">; 2605def gdwarf_3 : Flag<["-"], "gdwarf-3">, Group<g_Group>, 2606 HelpText<"Generate source-level debug information with dwarf version 3">; 2607def gdwarf_4 : Flag<["-"], "gdwarf-4">, Group<g_Group>, 2608 HelpText<"Generate source-level debug information with dwarf version 4">; 2609def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>, 2610 HelpText<"Generate source-level debug information with dwarf version 5">; 2611def gdwarf64 : Flag<["-"], "gdwarf64">, Group<g_Group>, Flags<[CC1Option]>, 2612 HelpText<"Enables DWARF64 format for ELF binaries, if debug information emission is enabled.">, 2613 MarshallingInfoFlag<CodeGenOpts<"Dwarf64">>; 2614def gdwarf32 : Flag<["-"], "gdwarf32">, Group<g_Group>, Flags<[CC1Option]>, 2615 HelpText<"Enables DWARF32 format for ELF binaries, if debug information emission is enabled.">; 2616 2617def gcodeview : Flag<["-"], "gcodeview">, 2618 HelpText<"Generate CodeView debug information">, 2619 Flags<[CC1Option, CC1AsOption, CoreOption]>, 2620 MarshallingInfoFlag<CodeGenOpts<"EmitCodeView">>; 2621defm codeview_ghash : BoolOption<"g", "codeview-ghash", 2622 CodeGenOpts<"CodeViewGHash">, DefaultFalse, 2623 PosFlag<SetTrue, [CC1Option], "Emit type record hashes in a .debug$H section">, 2624 NegFlag<SetFalse>, BothFlags<[CoreOption]>>; 2625defm inline_line_tables : BoolGOption<"inline-line-tables", 2626 CodeGenOpts<"NoInlineLineTables">, DefaultFalse, 2627 NegFlag<SetTrue, [CC1Option], "Don't emit inline line tables.">, 2628 PosFlag<SetFalse>, BothFlags<[CoreOption]>>; 2629 2630def gfull : Flag<["-"], "gfull">, Group<g_Group>; 2631def gused : Flag<["-"], "gused">, Group<g_Group>; 2632def gstabs : Joined<["-"], "gstabs">, Group<g_Group>, Flags<[Unsupported]>; 2633def gcoff : Joined<["-"], "gcoff">, Group<g_Group>, Flags<[Unsupported]>; 2634def gxcoff : Joined<["-"], "gxcoff">, Group<g_Group>, Flags<[Unsupported]>; 2635def gvms : Joined<["-"], "gvms">, Group<g_Group>, Flags<[Unsupported]>; 2636def gtoggle : Flag<["-"], "gtoggle">, Group<g_flags_Group>, Flags<[Unsupported]>; 2637def grecord_command_line : Flag<["-"], "grecord-command-line">, 2638 Group<g_flags_Group>; 2639def gno_record_command_line : Flag<["-"], "gno-record-command-line">, 2640 Group<g_flags_Group>; 2641def : Flag<["-"], "grecord-gcc-switches">, Alias<grecord_command_line>; 2642def : Flag<["-"], "gno-record-gcc-switches">, Alias<gno_record_command_line>; 2643def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>; 2644def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>; 2645defm column_info : BoolOption<"g", "column-info", 2646 CodeGenOpts<"DebugColumnInfo">, DefaultTrue, 2647 NegFlag<SetFalse, [CC1Option]>, PosFlag<SetTrue>, BothFlags<[CoreOption]>>, 2648 Group<g_flags_Group>; 2649def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>; 2650def gsplit_dwarf_EQ : Joined<["-"], "gsplit-dwarf=">, Group<g_flags_Group>, 2651 HelpText<"Set DWARF fission mode to either 'split' or 'single'">, 2652 Values<"split,single">; 2653def gno_split_dwarf : Flag<["-"], "gno-split-dwarf">, Group<g_flags_Group>; 2654def ggnu_pubnames : Flag<["-"], "ggnu-pubnames">, Group<g_flags_Group>, Flags<[CC1Option]>; 2655def gno_gnu_pubnames : Flag<["-"], "gno-gnu-pubnames">, Group<g_flags_Group>; 2656def gpubnames : Flag<["-"], "gpubnames">, Group<g_flags_Group>, Flags<[CC1Option]>; 2657def gno_pubnames : Flag<["-"], "gno-pubnames">, Group<g_flags_Group>; 2658def gdwarf_aranges : Flag<["-"], "gdwarf-aranges">, Group<g_flags_Group>; 2659def gmodules : Flag <["-"], "gmodules">, Group<gN_Group>, 2660 HelpText<"Generate debug info with external references to clang modules" 2661 " or precompiled headers">; 2662def gz_EQ : Joined<["-"], "gz=">, Group<g_flags_Group>, 2663 HelpText<"DWARF debug sections compression type">; 2664def gz : Flag<["-"], "gz">, Alias<gz_EQ>, AliasArgs<["zlib"]>, Group<g_flags_Group>; 2665def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>, Flags<[CC1Option]>, 2666 HelpText<"Embed source text in DWARF debug sections">, 2667 MarshallingInfoFlag<CodeGenOpts<"EmbedSource">>; 2668def gno_embed_source : Flag<["-"], "gno-embed-source">, Group<g_flags_Group>, 2669 Flags<[NoXarchOption]>, 2670 HelpText<"Restore the default behavior of not embedding source text in DWARF debug sections">; 2671def headerpad__max__install__names : Joined<["-"], "headerpad_max_install_names">; 2672def help : Flag<["-", "--"], "help">, Flags<[CC1Option,CC1AsOption, FC1Option, 2673 FlangOption]>, HelpText<"Display available options">, 2674 MarshallingInfoFlag<FrontendOpts<"ShowHelp">>; 2675def ibuiltininc : Flag<["-"], "ibuiltininc">, 2676 HelpText<"Enable builtin #include directories even when -nostdinc is used " 2677 "before or after -ibuiltininc. " 2678 "Using -nobuiltininc after the option disables it">; 2679def index_header_map : Flag<["-"], "index-header-map">, Flags<[CC1Option]>, 2680 HelpText<"Make the next included directory (-I or -F) an indexer header map">; 2681def idirafter : JoinedOrSeparate<["-"], "idirafter">, Group<clang_i_Group>, Flags<[CC1Option]>, 2682 HelpText<"Add directory to AFTER include search path">; 2683def iframework : JoinedOrSeparate<["-"], "iframework">, Group<clang_i_Group>, Flags<[CC1Option]>, 2684 HelpText<"Add directory to SYSTEM framework search path">; 2685def iframeworkwithsysroot : JoinedOrSeparate<["-"], "iframeworkwithsysroot">, 2686 Group<clang_i_Group>, 2687 HelpText<"Add directory to SYSTEM framework search path, " 2688 "absolute paths are relative to -isysroot">, 2689 MetaVarName<"<directory>">, Flags<[CC1Option]>; 2690def imacros : JoinedOrSeparate<["-", "--"], "imacros">, Group<clang_i_Group>, Flags<[CC1Option]>, 2691 HelpText<"Include macros from file before parsing">, MetaVarName<"<file>">, 2692 MarshallingInfoStringVector<PreprocessorOpts<"MacroIncludes">>; 2693def image__base : Separate<["-"], "image_base">; 2694def include_ : JoinedOrSeparate<["-", "--"], "include">, Group<clang_i_Group>, EnumName<"include">, 2695 MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>; 2696def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>, 2697 HelpText<"Include precompiled header file">, MetaVarName<"<file>">, 2698 MarshallingInfoString<PreprocessorOpts<"ImplicitPCHInclude">>; 2699def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>, 2700 HelpText<"Whether to build a relocatable precompiled header">, 2701 MarshallingInfoFlag<FrontendOpts<"RelocatablePCH">>; 2702def verify_pch : Flag<["-"], "verify-pch">, Group<Action_Group>, Flags<[CC1Option]>, 2703 HelpText<"Load and verify that a pre-compiled header file is not stale">; 2704def init : Separate<["-"], "init">; 2705def install__name : Separate<["-"], "install_name">; 2706def iprefix : JoinedOrSeparate<["-"], "iprefix">, Group<clang_i_Group>, Flags<[CC1Option]>, 2707 HelpText<"Set the -iwithprefix/-iwithprefixbefore prefix">, MetaVarName<"<dir>">; 2708def iquote : JoinedOrSeparate<["-"], "iquote">, Group<clang_i_Group>, Flags<[CC1Option]>, 2709 HelpText<"Add directory to QUOTE include search path">, MetaVarName<"<directory>">; 2710def isysroot : JoinedOrSeparate<["-"], "isysroot">, Group<clang_i_Group>, Flags<[CC1Option]>, 2711 HelpText<"Set the system root directory (usually /)">, MetaVarName<"<dir>">, 2712 MarshallingInfoString<HeaderSearchOpts<"Sysroot">, [{"/"}]>; 2713def isystem : JoinedOrSeparate<["-"], "isystem">, Group<clang_i_Group>, 2714 Flags<[CC1Option]>, 2715 HelpText<"Add directory to SYSTEM include search path">, MetaVarName<"<directory>">; 2716def isystem_after : JoinedOrSeparate<["-"], "isystem-after">, 2717 Group<clang_i_Group>, Flags<[NoXarchOption]>, MetaVarName<"<directory>">, 2718 HelpText<"Add directory to end of the SYSTEM include search path">; 2719def iwithprefixbefore : JoinedOrSeparate<["-"], "iwithprefixbefore">, Group<clang_i_Group>, 2720 HelpText<"Set directory to include search path with prefix">, MetaVarName<"<dir>">, 2721 Flags<[CC1Option]>; 2722def iwithprefix : JoinedOrSeparate<["-"], "iwithprefix">, Group<clang_i_Group>, Flags<[CC1Option]>, 2723 HelpText<"Set directory to SYSTEM include search path with prefix">, MetaVarName<"<dir>">; 2724def iwithsysroot : JoinedOrSeparate<["-"], "iwithsysroot">, Group<clang_i_Group>, 2725 HelpText<"Add directory to SYSTEM include search path, " 2726 "absolute paths are relative to -isysroot">, MetaVarName<"<directory>">, 2727 Flags<[CC1Option]>; 2728def ivfsoverlay : JoinedOrSeparate<["-"], "ivfsoverlay">, Group<clang_i_Group>, Flags<[CC1Option]>, 2729 HelpText<"Overlay the virtual filesystem described by file over the real file system">; 2730def imultilib : Separate<["-"], "imultilib">, Group<gfortran_Group>; 2731def keep__private__externs : Flag<["-"], "keep_private_externs">; 2732def l : JoinedOrSeparate<["-"], "l">, Flags<[LinkerInput, RenderJoined]>, 2733 Group<Link_Group>; 2734def lazy__framework : Separate<["-"], "lazy_framework">, Flags<[LinkerInput]>; 2735def lazy__library : Separate<["-"], "lazy_library">, Flags<[LinkerInput]>; 2736def mlittle_endian : Flag<["-"], "mlittle-endian">, Flags<[NoXarchOption]>; 2737def EL : Flag<["-"], "EL">, Alias<mlittle_endian>; 2738def mbig_endian : Flag<["-"], "mbig-endian">, Flags<[NoXarchOption]>; 2739def EB : Flag<["-"], "EB">, Alias<mbig_endian>; 2740def m16 : Flag<["-"], "m16">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; 2741def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; 2742def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[NoXarchOption,CC1Option]>, 2743 HelpText<"Enable hexagon-qdsp6 backward compatibility">, 2744 MarshallingInfoFlag<LangOpts<"HexagonQdsp6Compat">>; 2745def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; 2746def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; 2747def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>; 2748def miamcu : Flag<["-"], "miamcu">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>, 2749 HelpText<"Use Intel MCU ABI">; 2750def mno_iamcu : Flag<["-"], "mno-iamcu">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>; 2751def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>; 2752def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>; 2753def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>; 2754def malign_branch_EQ : CommaJoined<["-"], "malign-branch=">, Group<m_Group>, Flags<[NoXarchOption]>, 2755 HelpText<"Specify types of branches to align">; 2756def malign_branch_boundary_EQ : Joined<["-"], "malign-branch-boundary=">, Group<m_Group>, Flags<[NoXarchOption]>, 2757 HelpText<"Specify the boundary's size to align branches">; 2758def mpad_max_prefix_size_EQ : Joined<["-"], "mpad-max-prefix-size=">, Group<m_Group>, Flags<[NoXarchOption]>, 2759 HelpText<"Specify maximum number of prefixes to use for padding">; 2760def mbranches_within_32B_boundaries : Flag<["-"], "mbranches-within-32B-boundaries">, Flags<[NoXarchOption]>, Group<m_Group>, 2761 HelpText<"Align selected branches (fused, jcc, jmp) within 32-byte boundary">; 2762def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Group>; 2763def mlong_calls : Flag<["-"], "mlong-calls">, Group<m_Group>, 2764 HelpText<"Generate branches with extended addressability, usually via indirect jumps.">; 2765def mdouble_EQ : Joined<["-"], "mdouble=">, Group<m_Group>, Values<"32,64">, Flags<[CC1Option]>, 2766 HelpText<"Force double to be 32 bits or 64 bits">, 2767 MarshallingInfoStringInt<LangOpts<"DoubleSize">, "0">; 2768def LongDouble_Group : OptionGroup<"<LongDouble group>">, Group<m_Group>, 2769 DocName<"Long double flags">, 2770 DocBrief<[{Selects the long double implementation}]>; 2771def mlong_double_64 : Flag<["-"], "mlong-double-64">, Group<LongDouble_Group>, Flags<[CC1Option]>, 2772 HelpText<"Force long double to be 64 bits">; 2773def mlong_double_80 : Flag<["-"], "mlong-double-80">, Group<LongDouble_Group>, Flags<[CC1Option]>, 2774 HelpText<"Force long double to be 80 bits, padded to 128 bits for storage">; 2775def mlong_double_128 : Flag<["-"], "mlong-double-128">, Group<LongDouble_Group>, Flags<[CC1Option]>, 2776 HelpText<"Force long double to be 128 bits">; 2777def mno_long_calls : Flag<["-"], "mno-long-calls">, Group<m_Group>, 2778 HelpText<"Restore the default behaviour of not generating long calls">; 2779def mexecute_only : Flag<["-"], "mexecute-only">, Group<m_arm_Features_Group>, 2780 HelpText<"Disallow generation of data access to code sections (ARM only)">; 2781def mno_execute_only : Flag<["-"], "mno-execute-only">, Group<m_arm_Features_Group>, 2782 HelpText<"Allow generation of data access to code sections (ARM only)">; 2783def mtp_mode_EQ : Joined<["-"], "mtp=">, Group<m_arm_Features_Group>, Values<"soft,cp15,el0,el1,el2,el3">, 2784 HelpText<"Thread pointer access method (AArch32/AArch64 only)">; 2785def mpure_code : Flag<["-"], "mpure-code">, Alias<mexecute_only>; // Alias for GCC compatibility 2786def mno_pure_code : Flag<["-"], "mno-pure-code">, Alias<mno_execute_only>; 2787def mtvos_version_min_EQ : Joined<["-"], "mtvos-version-min=">, Group<m_Group>; 2788def mappletvos_version_min_EQ : Joined<["-"], "mappletvos-version-min=">, Alias<mtvos_version_min_EQ>; 2789def mtvos_simulator_version_min_EQ : Joined<["-"], "mtvos-simulator-version-min=">; 2790def mappletvsimulator_version_min_EQ : Joined<["-"], "mappletvsimulator-version-min=">, Alias<mtvos_simulator_version_min_EQ>; 2791def mwatchos_version_min_EQ : Joined<["-"], "mwatchos-version-min=">, Group<m_Group>; 2792def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">; 2793def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias<mwatchos_simulator_version_min_EQ>; 2794def march_EQ : Joined<["-"], "march=">, Group<m_Group>, Flags<[CoreOption]>; 2795def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[NoXarchOption]>; 2796def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>, Flags<[CC1Option]>, 2797 MarshallingInfoString<TargetOpts<"CodeModel">, [{"default"}]>; 2798def mtls_size_EQ : Joined<["-"], "mtls-size=">, Group<m_Group>, Flags<[NoXarchOption, CC1Option]>, 2799 HelpText<"Specify bit size of immediate TLS offsets (AArch64 ELF only): " 2800 "12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)">, 2801 MarshallingInfoStringInt<CodeGenOpts<"TLSSize">>; 2802def mimplicit_it_EQ : Joined<["-"], "mimplicit-it=">, Group<m_Group>; 2803def mdefault_build_attributes : Joined<["-"], "mdefault-build-attributes">, Group<m_Group>; 2804def mno_default_build_attributes : Joined<["-"], "mno-default-build-attributes">, Group<m_Group>; 2805def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>; 2806def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[NoXarchOption]>; 2807def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[NoXarchOption]>; 2808def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[NoXarchOption]>; 2809def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[NoXarchOption]>; 2810def mthreads : Joined<["-"], "mthreads">, Group<m_Group>, Flags<[NoXarchOption]>; 2811def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>; 2812def mmcu_EQ : Joined<["-"], "mmcu=">, Group<m_Group>; 2813def msim : Flag<["-"], "msim">, Group<m_Group>; 2814def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>; 2815def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>; 2816def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>; 2817def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>; 2818def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>; 2819def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>, 2820 HelpText<"Align doubles to two words in structs (x86 only)">, 2821 MarshallingInfoFlag<LangOpts<"AlignDouble">>; 2822def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">; 2823def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>; 2824def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>; 2825def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>; 2826def mhwmult_EQ : Joined<["-"], "mhwmult=">, Group<m_Group>; 2827def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>, Flags<[CC1Option]>, 2828 HelpText<"Enable merging of globals">; 2829def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>; 2830def miphoneos_version_min_EQ : Joined<["-"], "miphoneos-version-min=">, Group<m_Group>; 2831def mios_version_min_EQ : Joined<["-"], "mios-version-min=">, 2832 Alias<miphoneos_version_min_EQ>, HelpText<"Set iOS deployment target">; 2833def mios_simulator_version_min_EQ : Joined<["-"], "mios-simulator-version-min=">; 2834def miphonesimulator_version_min_EQ : Joined<["-"], "miphonesimulator-version-min=">, Alias<mios_simulator_version_min_EQ>; 2835def mkernel : Flag<["-"], "mkernel">, Group<m_Group>; 2836def mlinker_version_EQ : Joined<["-"], "mlinker-version=">, 2837 Flags<[NoXarchOption]>; 2838def mllvm : Separate<["-"], "mllvm">, Flags<[CC1Option,CC1AsOption,CoreOption]>, 2839 HelpText<"Additional arguments to forward to LLVM's option processing">, 2840 MarshallingInfoStringVector<FrontendOpts<"LLVMArgs">>; 2841def mmacosx_version_min_EQ : Joined<["-"], "mmacosx-version-min=">, 2842 Group<m_Group>, HelpText<"Set Mac OS X deployment target">; 2843def mmacos_version_min_EQ : Joined<["-"], "mmacos-version-min=">, 2844 Group<m_Group>, Alias<mmacosx_version_min_EQ>; 2845def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>, 2846 HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">, 2847 MarshallingInfoFlag<LangOpts<"MSBitfields">>; 2848def moutline : Flag<["-"], "moutline">, Group<f_clang_Group>, Flags<[CC1Option]>, 2849 HelpText<"Enable function outlining (AArch64 only)">; 2850def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Option]>, 2851 HelpText<"Disable function outlining (AArch64 only)">; 2852def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>, 2853 HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">; 2854def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>, 2855 HelpText<"Force realign the stack at entry to every function">, 2856 MarshallingInfoFlag<CodeGenOpts<"StackRealignment">>; 2857def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>, 2858 HelpText<"Set the stack alignment">, 2859 MarshallingInfoStringInt<CodeGenOpts<"StackAlignment">>; 2860def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>, 2861 HelpText<"Set the stack probe size">, 2862 MarshallingInfoStringInt<CodeGenOpts<"StackProbeSize">, "4096">; 2863def mstack_arg_probe : Flag<["-"], "mstack-arg-probe">, Group<m_Group>, 2864 HelpText<"Enable stack probes">; 2865def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>, 2866 HelpText<"Disable stack probes which are enabled by default">, 2867 MarshallingInfoFlag<CodeGenOpts<"NoStackArgProbe">>; 2868def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>, 2869 HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">; 2870def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>, 2871 HelpText<"Set EABI type, e.g. 4, 5 or gnu (default depends on triple)">, Values<"default,4,5,gnu">, 2872 MarshallingInfoString<TargetOpts<"EABIVersion">, "Default">, 2873 NormalizedValuesScope<"llvm::EABI">, 2874 NormalizedValues<["Default", "EABI4", "EABI5", "GNU"]>, AutoNormalizeEnum; 2875 2876def mno_constant_cfstrings : Flag<["-"], "mno-constant-cfstrings">, Group<m_Group>; 2877def mno_global_merge : Flag<["-"], "mno-global-merge">, Group<m_Group>, Flags<[CC1Option]>, 2878 HelpText<"Disable merging of globals">; 2879def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">, 2880 Alias<fno_pascal_strings>; 2881def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>; 2882def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group<m_Group>, Flags<[CC1Option]>, 2883 HelpText<"Disable direct TLS access through segment registers">, 2884 MarshallingInfoFlag<CodeGenOpts<"IndirectTlsSegRefs">>; 2885def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>; 2886def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>; 2887def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>; 2888def mno_stackrealign : Flag<["-"], "mno-stackrealign">, Group<m_Group>; 2889 2890def mretpoline : Flag<["-"], "mretpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>; 2891def mno_retpoline : Flag<["-"], "mno-retpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>; 2892defm speculative_load_hardening : BoolOption<"m", "speculative-load-hardening", 2893 CodeGenOpts<"SpeculativeLoadHardening">, DefaultFalse, 2894 PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>, BothFlags<[CoreOption]>>, 2895 Group<m_Group>; 2896def mlvi_hardening : Flag<["-"], "mlvi-hardening">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>, 2897 HelpText<"Enable all mitigations for Load Value Injection (LVI)">; 2898def mno_lvi_hardening : Flag<["-"], "mno-lvi-hardening">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>, 2899 HelpText<"Disable mitigations for Load Value Injection (LVI)">; 2900def mlvi_cfi : Flag<["-"], "mlvi-cfi">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>, 2901 HelpText<"Enable only control-flow mitigations for Load Value Injection (LVI)">; 2902def mno_lvi_cfi : Flag<["-"], "mno-lvi-cfi">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>, 2903 HelpText<"Disable control-flow mitigations for Load Value Injection (LVI)">; 2904def m_seses : Flag<["-"], "mseses">, Group<m_Group>, Flags<[CoreOption, NoXarchOption]>, 2905 HelpText<"Enable speculative execution side effect suppression (SESES). " 2906 "Includes LVI control flow integrity mitigations">; 2907def mno_seses : Flag<["-"], "mno-seses">, Group<m_Group>, Flags<[CoreOption, NoXarchOption]>, 2908 HelpText<"Disable speculative execution side effect suppression (SESES)">; 2909 2910def mrelax : Flag<["-"], "mrelax">, Group<m_Group>, 2911 HelpText<"Enable linker relaxation">; 2912def mno_relax : Flag<["-"], "mno-relax">, Group<m_Group>, 2913 HelpText<"Disable linker relaxation">; 2914def msmall_data_limit_EQ : Joined<["-"], "msmall-data-limit=">, Group<m_Group>, 2915 Alias<G>, 2916 HelpText<"Put global and static data smaller than the limit into a special section">; 2917def msave_restore : Flag<["-"], "msave-restore">, Group<m_riscv_Features_Group>, 2918 HelpText<"Enable using library calls for save and restore">; 2919def mno_save_restore : Flag<["-"], "mno-save-restore">, Group<m_riscv_Features_Group>, 2920 HelpText<"Disable using library calls for save and restore">; 2921def mcmodel_EQ_medlow : Flag<["-"], "mcmodel=medlow">, Group<m_riscv_Features_Group>, 2922 Flags<[CC1Option]>, Alias<mcmodel_EQ>, AliasArgs<["small"]>, 2923 HelpText<"Equivalent to -mcmodel=small, compatible with RISC-V gcc.">; 2924def mcmodel_EQ_medany : Flag<["-"], "mcmodel=medany">, Group<m_riscv_Features_Group>, 2925 Flags<[CC1Option]>, Alias<mcmodel_EQ>, AliasArgs<["medium"]>, 2926 HelpText<"Equivalent to -mcmodel=medium, compatible with RISC-V gcc.">; 2927def menable_experimental_extensions : Flag<["-"], "menable-experimental-extensions">, Group<m_Group>, 2928 HelpText<"Enable use of experimental RISC-V extensions.">; 2929 2930def munaligned_access : Flag<["-"], "munaligned-access">, Group<m_arm_Features_Group>, 2931 HelpText<"Allow memory accesses to be unaligned (AArch32/AArch64 only)">; 2932def mno_unaligned_access : Flag<["-"], "mno-unaligned-access">, Group<m_arm_Features_Group>, 2933 HelpText<"Force all memory accesses to be aligned (AArch32/AArch64 only)">; 2934def mstrict_align : Flag<["-"], "mstrict-align">, Alias<mno_unaligned_access>, Flags<[CC1Option,HelpHidden]>, 2935 HelpText<"Force all memory accesses to be aligned (same as mno-unaligned-access)">; 2936def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_arm_Features_Group>; 2937def mrestrict_it: Flag<["-"], "mrestrict-it">, Group<m_arm_Features_Group>, 2938 HelpText<"Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.">; 2939def mno_restrict_it: Flag<["-"], "mno-restrict-it">, Group<m_arm_Features_Group>, 2940 HelpText<"Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode">; 2941def marm : Flag<["-"], "marm">, Alias<mno_thumb>; 2942def ffixed_r9 : Flag<["-"], "ffixed-r9">, Group<m_arm_Features_Group>, 2943 HelpText<"Reserve the r9 register (ARM only)">; 2944def mno_movt : Flag<["-"], "mno-movt">, Group<m_arm_Features_Group>, 2945 HelpText<"Disallow use of movt/movw pairs (ARM only)">; 2946def mcrc : Flag<["-"], "mcrc">, Group<m_Group>, 2947 HelpText<"Allow use of CRC instructions (ARM/Mips only)">; 2948def mnocrc : Flag<["-"], "mnocrc">, Group<m_arm_Features_Group>, 2949 HelpText<"Disallow use of CRC instructions (ARM only)">; 2950def mno_neg_immediates: Flag<["-"], "mno-neg-immediates">, Group<m_arm_Features_Group>, 2951 HelpText<"Disallow converting instructions with negative immediates to their negation or inversion.">; 2952def mcmse : Flag<["-"], "mcmse">, Group<m_arm_Features_Group>, 2953 Flags<[NoXarchOption,CC1Option]>, 2954 HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">, 2955 MarshallingInfoFlag<LangOpts<"Cmse">>; 2956def ForceAAPCSBitfieldLoad : Flag<["-"], "faapcs-bitfield-load">, Group<m_arm_Features_Group>, 2957 Flags<[NoXarchOption,CC1Option]>, 2958 HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">, 2959 MarshallingInfoFlag<CodeGenOpts<"ForceAAPCSBitfieldLoad">>; 2960defm aapcs_bitfield_width : BoolOption<"f", "aapcs-bitfield-width", 2961 CodeGenOpts<"AAPCSBitfieldWidth">, DefaultTrue, 2962 NegFlag<SetFalse, [], "Do not follow">, PosFlag<SetTrue, [], "Follow">, 2963 BothFlags<[NoXarchOption, CC1Option], " the AAPCS standard requirement stating that" 2964 " volatile bit-field width is dictated by the field container type. (ARM only).">>, 2965 Group<m_arm_Features_Group>; 2966 2967def mgeneral_regs_only : Flag<["-"], "mgeneral-regs-only">, Group<m_aarch64_Features_Group>, 2968 HelpText<"Generate code which only uses the general purpose registers (AArch64 only)">; 2969def mfix_cortex_a53_835769 : Flag<["-"], "mfix-cortex-a53-835769">, 2970 Group<m_aarch64_Features_Group>, 2971 HelpText<"Workaround Cortex-A53 erratum 835769 (AArch64 only)">; 2972def mno_fix_cortex_a53_835769 : Flag<["-"], "mno-fix-cortex-a53-835769">, 2973 Group<m_aarch64_Features_Group>, 2974 HelpText<"Don't workaround Cortex-A53 erratum 835769 (AArch64 only)">; 2975def mmark_bti_property : Flag<["-"], "mmark-bti-property">, 2976 Group<m_aarch64_Features_Group>, 2977 HelpText<"Add .note.gnu.property with BTI to assembly files (AArch64 only)">; 2978foreach i = {1-31} in 2979 def ffixed_x#i : Flag<["-"], "ffixed-x"#i>, Group<m_Group>, 2980 HelpText<"Reserve the x"#i#" register (AArch64/RISC-V only)">; 2981 2982foreach i = {8-15,18} in 2983 def fcall_saved_x#i : Flag<["-"], "fcall-saved-x"#i>, Group<m_aarch64_Features_Group>, 2984 HelpText<"Make the x"#i#" register call-saved (AArch64 only)">; 2985 2986def msve_vector_bits_EQ : Joined<["-"], "msve-vector-bits=">, 2987 Group<m_aarch64_Features_Group>, Flags<[NoXarchOption,CC1Option]>, 2988 HelpText<"Specify the size in bits of an SVE vector register. Defaults to the" 2989 " vector length agnostic value of \"scalable\". (AArch64 only)">, 2990 Values<"128,256,512,1024,2048,scalable">; 2991 2992def msign_return_address_EQ : Joined<["-"], "msign-return-address=">, 2993 Flags<[CC1Option]>, Group<m_Group>, Values<"none,all,non-leaf">, 2994 HelpText<"Select return address signing scope">; 2995def mbranch_protection_EQ : Joined<["-"], "mbranch-protection=">, 2996 HelpText<"Enforce targets of indirect branches and function returns">; 2997 2998def mharden_sls_EQ : Joined<["-"], "mharden-sls=">, 2999 HelpText<"Select straight-line speculation hardening scope">; 3000 3001def msimd128 : Flag<["-"], "msimd128">, Group<m_wasm_Features_Group>; 3002def munimplemented_simd128 : Flag<["-"], "munimplemented-simd128">, Group<m_wasm_Features_Group>; 3003def mno_unimplemented_simd128 : Flag<["-"], "mno-unimplemented-simd128">, Group<m_wasm_Features_Group>; 3004def mno_simd128 : Flag<["-"], "mno-simd128">, Group<m_wasm_Features_Group>; 3005def mnontrapping_fptoint : Flag<["-"], "mnontrapping-fptoint">, Group<m_wasm_Features_Group>; 3006def mno_nontrapping_fptoint : Flag<["-"], "mno-nontrapping-fptoint">, Group<m_wasm_Features_Group>; 3007def msign_ext : Flag<["-"], "msign-ext">, Group<m_wasm_Features_Group>; 3008def mno_sign_ext : Flag<["-"], "mno-sign-ext">, Group<m_wasm_Features_Group>; 3009def mexception_handing : Flag<["-"], "mexception-handling">, Group<m_wasm_Features_Group>; 3010def mno_exception_handing : Flag<["-"], "mno-exception-handling">, Group<m_wasm_Features_Group>; 3011def matomics : Flag<["-"], "matomics">, Group<m_wasm_Features_Group>; 3012def mno_atomics : Flag<["-"], "mno-atomics">, Group<m_wasm_Features_Group>; 3013def mbulk_memory : Flag<["-"], "mbulk-memory">, Group<m_wasm_Features_Group>; 3014def mno_bulk_memory : Flag<["-"], "mno-bulk-memory">, Group<m_wasm_Features_Group>; 3015def mmutable_globals : Flag<["-"], "mmutable-globals">, Group<m_wasm_Features_Group>; 3016def mno_mutable_globals : Flag<["-"], "mno-mutable-globals">, Group<m_wasm_Features_Group>; 3017def mmultivalue : Flag<["-"], "mmultivalue">, Group<m_wasm_Features_Group>; 3018def mno_multivalue : Flag<["-"], "mno-multivalue">, Group<m_wasm_Features_Group>; 3019def mtail_call : Flag<["-"], "mtail-call">, Group<m_wasm_Features_Group>; 3020def mno_tail_call : Flag<["-"], "mno-tail-call">, Group<m_wasm_Features_Group>; 3021def mreference_types : Flag<["-"], "mreference-types">, Group<m_wasm_Features_Group>; 3022def mno_reference_types : Flag<["-"], "mno-reference-types">, Group<m_wasm_Features_Group>; 3023def mexec_model_EQ : Joined<["-"], "mexec-model=">, Group<m_wasm_Features_Driver_Group>, 3024 Values<"command,reactor">, 3025 HelpText<"Execution model (WebAssembly only)">; 3026 3027def mcode_object_version_EQ : Joined<["-"], "mcode-object-version=">, Group<m_Group>, 3028 HelpText<"Specify code object ABI version. Defaults to 3. (AMDGPU only)">, 3029 MetaVarName<"<version>">, Values<"2,3,4">; 3030 3031def mcode_object_v3_legacy : Flag<["-"], "mcode-object-v3">, Group<m_Group>, 3032 HelpText<"Legacy option to specify code object ABI V2 (-mnocode-object-v3) or V3 (-mcode-object-v3) (AMDGPU only)">; 3033def mno_code_object_v3_legacy : Flag<["-"], "mno-code-object-v3">, Group<m_Group>; 3034 3035def mcumode : Flag<["-"], "mcumode">, Group<m_amdgpu_Features_Group>, 3036 HelpText<"Specify CU (-mcumode) or WGP (-mno-cumode) wavefront execution mode (AMDGPU only)">; 3037def mno_cumode : Flag<["-"], "mno-cumode">, Group<m_amdgpu_Features_Group>; 3038 3039def mwavefrontsize64 : Flag<["-"], "mwavefrontsize64">, Group<m_Group>, 3040 HelpText<"Specify wavefront size 64 mode (AMDGPU only)">; 3041def mno_wavefrontsize64 : Flag<["-"], "mno-wavefrontsize64">, Group<m_Group>, 3042 HelpText<"Specify wavefront size 32 mode (AMDGPU only)">; 3043 3044defm unsafe_fp_atomics : BoolOption<"m", "unsafe-fp-atomics", 3045 TargetOpts<"AllowAMDGPUUnsafeFPAtomics">, DefaultFalse, 3046 PosFlag<SetTrue, [CC1Option], "Enable unsafe floating point atomic instructions (AMDGPU only)">, 3047 NegFlag<SetFalse>>, Group<m_Group>; 3048 3049def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[NoXarchOption]>; 3050def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[NoXarchOption]>; 3051def maltivec : Flag<["-"], "maltivec">, Group<m_ppc_Features_Group>; 3052def mno_altivec : Flag<["-"], "mno-altivec">, Group<m_ppc_Features_Group>; 3053def mpcrel: Flag<["-"], "mpcrel">, Group<m_ppc_Features_Group>; 3054def mno_pcrel: Flag<["-"], "mno-pcrel">, Group<m_ppc_Features_Group>; 3055def mspe : Flag<["-"], "mspe">, Group<m_ppc_Features_Group>; 3056def mno_spe : Flag<["-"], "mno-spe">, Group<m_ppc_Features_Group>; 3057def mefpu2 : Flag<["-"], "mefpu2">, Group<m_ppc_Features_Group>; 3058def mabi_EQ_vec_extabi : Flag<["-"], "mabi=vec-extabi">, Group<m_Group>, Flags<[CC1Option]>, 3059 HelpText<"Enable the extended Altivec ABI on AIX (AIX only). Uses volatile and nonvolatile vector registers">; 3060def mabi_EQ_vec_default : Flag<["-"], "mabi=vec-default">, Group<m_Group>, Flags<[CC1Option]>, 3061 HelpText<"Enable the default Altivec ABI on AIX (AIX only). Uses only volatile vector registers.">; 3062def mvsx : Flag<["-"], "mvsx">, Group<m_ppc_Features_Group>; 3063def mno_vsx : Flag<["-"], "mno-vsx">, Group<m_ppc_Features_Group>; 3064def msecure_plt : Flag<["-"], "msecure-plt">, Group<m_ppc_Features_Group>; 3065def mpower8_vector : Flag<["-"], "mpower8-vector">, 3066 Group<m_ppc_Features_Group>; 3067def mno_power8_vector : Flag<["-"], "mno-power8-vector">, 3068 Group<m_ppc_Features_Group>; 3069def mpower9_vector : Flag<["-"], "mpower9-vector">, 3070 Group<m_ppc_Features_Group>; 3071def mno_power9_vector : Flag<["-"], "mno-power9-vector">, 3072 Group<m_ppc_Features_Group>; 3073def mpower10_vector : Flag<["-"], "mpower10-vector">, 3074 Group<m_ppc_Features_Group>; 3075def mno_power10_vector : Flag<["-"], "mno-power10-vector">, 3076 Group<m_ppc_Features_Group>; 3077def mpower8_crypto : Flag<["-"], "mcrypto">, 3078 Group<m_ppc_Features_Group>; 3079def mnopower8_crypto : Flag<["-"], "mno-crypto">, 3080 Group<m_ppc_Features_Group>; 3081def mdirect_move : Flag<["-"], "mdirect-move">, 3082 Group<m_ppc_Features_Group>; 3083def mnodirect_move : Flag<["-"], "mno-direct-move">, 3084 Group<m_ppc_Features_Group>; 3085def mpaired_vector_memops: Flag<["-"], "mpaired-vector-memops">, 3086 Group<m_ppc_Features_Group>; 3087def mnopaired_vector_memops: Flag<["-"], "mno-paired-vector-memops">, 3088 Group<m_ppc_Features_Group>; 3089def mhtm : Flag<["-"], "mhtm">, Group<m_ppc_Features_Group>; 3090def mno_htm : Flag<["-"], "mno-htm">, Group<m_ppc_Features_Group>; 3091def mfprnd : Flag<["-"], "mfprnd">, Group<m_ppc_Features_Group>; 3092def mno_fprnd : Flag<["-"], "mno-fprnd">, Group<m_ppc_Features_Group>; 3093def mcmpb : Flag<["-"], "mcmpb">, Group<m_ppc_Features_Group>; 3094def mno_cmpb : Flag<["-"], "mno-cmpb">, Group<m_ppc_Features_Group>; 3095def misel : Flag<["-"], "misel">, Group<m_ppc_Features_Group>; 3096def mno_isel : Flag<["-"], "mno-isel">, Group<m_ppc_Features_Group>; 3097def mmfocrf : Flag<["-"], "mmfocrf">, Group<m_ppc_Features_Group>; 3098def mmfcrf : Flag<["-"], "mmfcrf">, Alias<mmfocrf>; 3099def mno_mfocrf : Flag<["-"], "mno-mfocrf">, Group<m_ppc_Features_Group>; 3100def mno_mfcrf : Flag<["-"], "mno-mfcrf">, Alias<mno_mfocrf>; 3101def mpopcntd : Flag<["-"], "mpopcntd">, Group<m_ppc_Features_Group>; 3102def mno_popcntd : Flag<["-"], "mno-popcntd">, Group<m_ppc_Features_Group>; 3103def mcrbits : Flag<["-"], "mcrbits">, Group<m_ppc_Features_Group>; 3104def mno_crbits : Flag<["-"], "mno-crbits">, Group<m_ppc_Features_Group>; 3105def minvariant_function_descriptors : 3106 Flag<["-"], "minvariant-function-descriptors">, Group<m_ppc_Features_Group>; 3107def mno_invariant_function_descriptors : 3108 Flag<["-"], "mno-invariant-function-descriptors">, 3109 Group<m_ppc_Features_Group>; 3110def mfloat128: Flag<["-"], "mfloat128">, 3111 Group<m_ppc_Features_Group>; 3112def mno_float128 : Flag<["-"], "mno-float128">, 3113 Group<m_ppc_Features_Group>; 3114def mlongcall: Flag<["-"], "mlongcall">, 3115 Group<m_ppc_Features_Group>; 3116def mno_longcall : Flag<["-"], "mno-longcall">, 3117 Group<m_ppc_Features_Group>; 3118def mmma: Flag<["-"], "mmma">, Group<m_ppc_Features_Group>; 3119def mno_mma: Flag<["-"], "mno-mma">, Group<m_ppc_Features_Group>; 3120def maix_struct_return : Flag<["-"], "maix-struct-return">, 3121 Group<m_Group>, Flags<[CC1Option]>, 3122 HelpText<"Return all structs in memory (PPC32 only)">; 3123def msvr4_struct_return : Flag<["-"], "msvr4-struct-return">, 3124 Group<m_Group>, Flags<[CC1Option]>, 3125 HelpText<"Return small structs in registers (PPC32 only)">; 3126 3127def mvx : Flag<["-"], "mvx">, Group<m_Group>; 3128def mno_vx : Flag<["-"], "mno-vx">, Group<m_Group>; 3129 3130defm zvector : BoolFOption<"zvector", 3131 LangOpts<"ZVector">, DefaultFalse, 3132 PosFlag<SetTrue, [CC1Option], "Enable System z vector language extension">, 3133 NegFlag<SetFalse>>; 3134def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>; 3135def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>; 3136 3137def mignore_xcoff_visibility : Flag<["-"], "mignore-xcoff-visibility">, Group<m_Group>, 3138HelpText<"Not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file">, 3139 Flags<[CC1Option]>; 3140defm backchain : BoolOption<"m", "backchain", 3141 CodeGenOpts<"Backchain">, DefaultFalse, 3142 PosFlag<SetTrue, [], "Link stack frames through backchain on System Z">, 3143 NegFlag<SetFalse>, BothFlags<[NoXarchOption,CC1Option]>>, Group<m_Group>; 3144 3145def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>; 3146def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>; 3147def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>, 3148 HelpText<"Omit frame pointer setup for leaf functions">; 3149def moslib_EQ : Joined<["-"], "moslib=">, Group<m_Group>; 3150def mpascal_strings : Flag<["-"], "mpascal-strings">, Alias<fpascal_strings>; 3151def mred_zone : Flag<["-"], "mred-zone">, Group<m_Group>; 3152def mtls_direct_seg_refs : Flag<["-"], "mtls-direct-seg-refs">, Group<m_Group>, 3153 HelpText<"Enable direct TLS access through segment registers (default)">; 3154def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>; 3155def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>, 3156 HelpText<"(integrated-as) Relax all machine instructions">, 3157 MarshallingInfoFlag<CodeGenOpts<"RelaxAll">>; 3158def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group<m_Group>, 3159 Flags<[CC1Option,CC1AsOption]>, 3160 HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">, 3161 MarshallingInfoFlag<CodeGenOpts<"IncrementalLinkerCompatible">>; 3162def mno_incremental_linker_compatible : Flag<["-"], "mno-incremental-linker-compatible">, Group<m_Group>, 3163 HelpText<"(integrated-as) Emit an object file which cannot be used with an incremental linker">; 3164def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>, 3165 HelpText<"Make StdCall calling convention the default">; 3166def msmall_data_threshold_EQ : Joined <["-"], "msmall-data-threshold=">, 3167 Group<m_Group>, Alias<G>; 3168def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>, 3169 HelpText<"Use software floating point">, 3170 MarshallingInfoFlag<CodeGenOpts<"SoftFloat">>; 3171def moutline_atomics : Flag<["-"], "moutline-atomics">, Group<f_clang_Group>, Flags<[CC1Option]>, 3172 HelpText<"Generate local calls to out-of-line atomic operations">; 3173def mno_outline_atomics : Flag<["-"], "mno-outline-atomics">, Group<f_clang_Group>, Flags<[CC1Option]>, 3174 HelpText<"Don't generate local calls to out-of-line atomic operations">; 3175def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>, 3176 HelpText<"Don't generate implicit floating point instructions">; 3177def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>; 3178def mrecip : Flag<["-"], "mrecip">, Group<m_Group>; 3179def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>, 3180 MarshallingInfoStringVector<CodeGenOpts<"Reciprocals">>; 3181def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>, 3182 HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">, 3183 MarshallingInfoString<CodeGenOpts<"PreferVectorWidth">>; 3184def mstack_protector_guard_EQ : Joined<["-"], "mstack-protector-guard=">, Group<m_Group>, Flags<[CC1Option]>, 3185 HelpText<"Use the given guard (global, tls) for addressing the stack-protector guard">, 3186 MarshallingInfoString<CodeGenOpts<"StackProtectorGuard">>; 3187def mstack_protector_guard_offset_EQ : Joined<["-"], "mstack-protector-guard-offset=">, Group<m_Group>, Flags<[CC1Option]>, 3188 HelpText<"Use the given offset for addressing the stack-protector guard">, 3189 MarshallingInfoStringInt<CodeGenOpts<"StackProtectorGuardOffset">, "(unsigned)-1">; 3190def mstack_protector_guard_reg_EQ : Joined<["-"], "mstack-protector-guard-reg=">, Group<m_Group>, Flags<[CC1Option]>, 3191 HelpText<"Use the given reg for addressing the stack-protector guard">, 3192 MarshallingInfoString<CodeGenOpts<"StackProtectorGuardReg">, [{"none"}]>; 3193def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, 3194 Alias<fdirect_access_external_data>, Group<m_Group>; 3195def mno_pie_copy_relocations : Flag<["-"], "mno-pie-copy-relocations">, 3196 Alias<fno_direct_access_external_data>, Group<m_Group>; 3197def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86/SystemZ only)">, 3198 Flags<[CC1Option]>, Group<m_Group>, 3199 MarshallingInfoFlag<CodeGenOpts<"CallFEntry">>; 3200def mnop_mcount : Flag<["-"], "mnop-mcount">, HelpText<"Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.">, 3201 Flags<[CC1Option]>, Group<m_Group>, 3202 MarshallingInfoFlag<CodeGenOpts<"MNopMCount">>; 3203def mrecord_mcount : Flag<["-"], "mrecord-mcount">, HelpText<"Generate a __mcount_loc section entry for each __fentry__ call.">, 3204 Flags<[CC1Option]>, Group<m_Group>, 3205 MarshallingInfoFlag<CodeGenOpts<"RecordMCount">>; 3206def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">, 3207 Flags<[CC1Option]>, Group<m_Group>, 3208 MarshallingInfoFlag<CodeGenOpts<"PackedStack">>; 3209def mno_packed_stack : Flag<["-"], "mno-packed-stack">, Flags<[CC1Option]>, Group<m_Group>; 3210def mips16 : Flag<["-"], "mips16">, Group<m_mips_Features_Group>; 3211def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_mips_Features_Group>; 3212def mmicromips : Flag<["-"], "mmicromips">, Group<m_mips_Features_Group>; 3213def mno_micromips : Flag<["-"], "mno-micromips">, Group<m_mips_Features_Group>; 3214def mxgot : Flag<["-"], "mxgot">, Group<m_mips_Features_Group>; 3215def mno_xgot : Flag<["-"], "mno-xgot">, Group<m_mips_Features_Group>; 3216def mldc1_sdc1 : Flag<["-"], "mldc1-sdc1">, Group<m_mips_Features_Group>; 3217def mno_ldc1_sdc1 : Flag<["-"], "mno-ldc1-sdc1">, Group<m_mips_Features_Group>; 3218def mcheck_zero_division : Flag<["-"], "mcheck-zero-division">, 3219 Group<m_mips_Features_Group>; 3220def mno_check_zero_division : Flag<["-"], "mno-check-zero-division">, 3221 Group<m_mips_Features_Group>; 3222def mcompact_branches_EQ : Joined<["-"], "mcompact-branches=">, 3223 Group<m_mips_Features_Group>; 3224def mbranch_likely : Flag<["-"], "mbranch-likely">, Group<m_Group>, 3225 IgnoredGCCCompat; 3226def mno_branch_likely : Flag<["-"], "mno-branch-likely">, Group<m_Group>, 3227 IgnoredGCCCompat; 3228def mindirect_jump_EQ : Joined<["-"], "mindirect-jump=">, 3229 Group<m_mips_Features_Group>, 3230 HelpText<"Change indirect jump instructions to inhibit speculation">; 3231def mdsp : Flag<["-"], "mdsp">, Group<m_mips_Features_Group>; 3232def mno_dsp : Flag<["-"], "mno-dsp">, Group<m_mips_Features_Group>; 3233def mdspr2 : Flag<["-"], "mdspr2">, Group<m_mips_Features_Group>; 3234def mno_dspr2 : Flag<["-"], "mno-dspr2">, Group<m_mips_Features_Group>; 3235def msingle_float : Flag<["-"], "msingle-float">, Group<m_mips_Features_Group>; 3236def mdouble_float : Flag<["-"], "mdouble-float">, Group<m_mips_Features_Group>; 3237def mmadd4 : Flag<["-"], "mmadd4">, Group<m_mips_Features_Group>, 3238 HelpText<"Enable the generation of 4-operand madd.s, madd.d and related instructions.">; 3239def mno_madd4 : Flag<["-"], "mno-madd4">, Group<m_mips_Features_Group>, 3240 HelpText<"Disable the generation of 4-operand madd.s, madd.d and related instructions.">; 3241def mmsa : Flag<["-"], "mmsa">, Group<m_mips_Features_Group>, 3242 HelpText<"Enable MSA ASE (MIPS only)">; 3243def mno_msa : Flag<["-"], "mno-msa">, Group<m_mips_Features_Group>, 3244 HelpText<"Disable MSA ASE (MIPS only)">; 3245def mmt : Flag<["-"], "mmt">, Group<m_mips_Features_Group>, 3246 HelpText<"Enable MT ASE (MIPS only)">; 3247def mno_mt : Flag<["-"], "mno-mt">, Group<m_mips_Features_Group>, 3248 HelpText<"Disable MT ASE (MIPS only)">; 3249def mfp64 : Flag<["-"], "mfp64">, Group<m_mips_Features_Group>, 3250 HelpText<"Use 64-bit floating point registers (MIPS only)">; 3251def mfp32 : Flag<["-"], "mfp32">, Group<m_mips_Features_Group>, 3252 HelpText<"Use 32-bit floating point registers (MIPS only)">; 3253def mgpopt : Flag<["-"], "mgpopt">, Group<m_mips_Features_Group>, 3254 HelpText<"Use GP relative accesses for symbols known to be in a small" 3255 " data section (MIPS)">; 3256def mno_gpopt : Flag<["-"], "mno-gpopt">, Group<m_mips_Features_Group>, 3257 HelpText<"Do not use GP relative accesses for symbols known to be in a small" 3258 " data section (MIPS)">; 3259def mlocal_sdata : Flag<["-"], "mlocal-sdata">, 3260 Group<m_mips_Features_Group>, 3261 HelpText<"Extend the -G behaviour to object local data (MIPS)">; 3262def mno_local_sdata : Flag<["-"], "mno-local-sdata">, 3263 Group<m_mips_Features_Group>, 3264 HelpText<"Do not extend the -G behaviour to object local data (MIPS)">; 3265def mextern_sdata : Flag<["-"], "mextern-sdata">, 3266 Group<m_mips_Features_Group>, 3267 HelpText<"Assume that externally defined data is in the small data if it" 3268 " meets the -G <size> threshold (MIPS)">; 3269def mno_extern_sdata : Flag<["-"], "mno-extern-sdata">, 3270 Group<m_mips_Features_Group>, 3271 HelpText<"Do not assume that externally defined data is in the small data if" 3272 " it meets the -G <size> threshold (MIPS)">; 3273def membedded_data : Flag<["-"], "membedded-data">, 3274 Group<m_mips_Features_Group>, 3275 HelpText<"Place constants in the .rodata section instead of the .sdata " 3276 "section even if they meet the -G <size> threshold (MIPS)">; 3277def mno_embedded_data : Flag<["-"], "mno-embedded-data">, 3278 Group<m_mips_Features_Group>, 3279 HelpText<"Do not place constants in the .rodata section instead of the " 3280 ".sdata if they meet the -G <size> threshold (MIPS)">; 3281def mnan_EQ : Joined<["-"], "mnan=">, Group<m_mips_Features_Group>; 3282def mabs_EQ : Joined<["-"], "mabs=">, Group<m_mips_Features_Group>; 3283def mabicalls : Flag<["-"], "mabicalls">, Group<m_mips_Features_Group>, 3284 HelpText<"Enable SVR4-style position-independent code (Mips only)">; 3285def mno_abicalls : Flag<["-"], "mno-abicalls">, Group<m_mips_Features_Group>, 3286 HelpText<"Disable SVR4-style position-independent code (Mips only)">; 3287def mno_crc : Flag<["-"], "mno-crc">, Group<m_mips_Features_Group>, 3288 HelpText<"Disallow use of CRC instructions (Mips only)">; 3289def mvirt : Flag<["-"], "mvirt">, Group<m_mips_Features_Group>; 3290def mno_virt : Flag<["-"], "mno-virt">, Group<m_mips_Features_Group>; 3291def mginv : Flag<["-"], "mginv">, Group<m_mips_Features_Group>; 3292def mno_ginv : Flag<["-"], "mno-ginv">, Group<m_mips_Features_Group>; 3293def mips1 : Flag<["-"], "mips1">, 3294 Alias<march_EQ>, AliasArgs<["mips1"]>, Group<m_mips_Features_Group>, 3295 HelpText<"Equivalent to -march=mips1">, Flags<[HelpHidden]>; 3296def mips2 : Flag<["-"], "mips2">, 3297 Alias<march_EQ>, AliasArgs<["mips2"]>, Group<m_mips_Features_Group>, 3298 HelpText<"Equivalent to -march=mips2">, Flags<[HelpHidden]>; 3299def mips3 : Flag<["-"], "mips3">, 3300 Alias<march_EQ>, AliasArgs<["mips3"]>, Group<m_mips_Features_Group>, 3301 HelpText<"Equivalent to -march=mips3">, Flags<[HelpHidden]>; 3302def mips4 : Flag<["-"], "mips4">, 3303 Alias<march_EQ>, AliasArgs<["mips4"]>, Group<m_mips_Features_Group>, 3304 HelpText<"Equivalent to -march=mips4">, Flags<[HelpHidden]>; 3305def mips5 : Flag<["-"], "mips5">, 3306 Alias<march_EQ>, AliasArgs<["mips5"]>, Group<m_mips_Features_Group>, 3307 HelpText<"Equivalent to -march=mips5">, Flags<[HelpHidden]>; 3308def mips32 : Flag<["-"], "mips32">, 3309 Alias<march_EQ>, AliasArgs<["mips32"]>, Group<m_mips_Features_Group>, 3310 HelpText<"Equivalent to -march=mips32">, Flags<[HelpHidden]>; 3311def mips32r2 : Flag<["-"], "mips32r2">, 3312 Alias<march_EQ>, AliasArgs<["mips32r2"]>, Group<m_mips_Features_Group>, 3313 HelpText<"Equivalent to -march=mips32r2">, Flags<[HelpHidden]>; 3314def mips32r3 : Flag<["-"], "mips32r3">, 3315 Alias<march_EQ>, AliasArgs<["mips32r3"]>, Group<m_mips_Features_Group>, 3316 HelpText<"Equivalent to -march=mips32r3">, Flags<[HelpHidden]>; 3317def mips32r5 : Flag<["-"], "mips32r5">, 3318 Alias<march_EQ>, AliasArgs<["mips32r5"]>, Group<m_mips_Features_Group>, 3319 HelpText<"Equivalent to -march=mips32r5">, Flags<[HelpHidden]>; 3320def mips32r6 : Flag<["-"], "mips32r6">, 3321 Alias<march_EQ>, AliasArgs<["mips32r6"]>, Group<m_mips_Features_Group>, 3322 HelpText<"Equivalent to -march=mips32r6">, Flags<[HelpHidden]>; 3323def mips64 : Flag<["-"], "mips64">, 3324 Alias<march_EQ>, AliasArgs<["mips64"]>, Group<m_mips_Features_Group>, 3325 HelpText<"Equivalent to -march=mips64">, Flags<[HelpHidden]>; 3326def mips64r2 : Flag<["-"], "mips64r2">, 3327 Alias<march_EQ>, AliasArgs<["mips64r2"]>, Group<m_mips_Features_Group>, 3328 HelpText<"Equivalent to -march=mips64r2">, Flags<[HelpHidden]>; 3329def mips64r3 : Flag<["-"], "mips64r3">, 3330 Alias<march_EQ>, AliasArgs<["mips64r3"]>, Group<m_mips_Features_Group>, 3331 HelpText<"Equivalent to -march=mips64r3">, Flags<[HelpHidden]>; 3332def mips64r5 : Flag<["-"], "mips64r5">, 3333 Alias<march_EQ>, AliasArgs<["mips64r5"]>, Group<m_mips_Features_Group>, 3334 HelpText<"Equivalent to -march=mips64r5">, Flags<[HelpHidden]>; 3335def mips64r6 : Flag<["-"], "mips64r6">, 3336 Alias<march_EQ>, AliasArgs<["mips64r6"]>, Group<m_mips_Features_Group>, 3337 HelpText<"Equivalent to -march=mips64r6">, Flags<[HelpHidden]>; 3338def mfpxx : Flag<["-"], "mfpxx">, Group<m_mips_Features_Group>, 3339 HelpText<"Avoid FPU mode dependent operations when used with the O32 ABI">, 3340 Flags<[HelpHidden]>; 3341def modd_spreg : Flag<["-"], "modd-spreg">, Group<m_mips_Features_Group>, 3342 HelpText<"Enable odd single-precision floating point registers">, 3343 Flags<[HelpHidden]>; 3344def mno_odd_spreg : Flag<["-"], "mno-odd-spreg">, Group<m_mips_Features_Group>, 3345 HelpText<"Disable odd single-precision floating point registers">, 3346 Flags<[HelpHidden]>; 3347def mrelax_pic_calls : Flag<["-"], "mrelax-pic-calls">, 3348 Group<m_mips_Features_Group>, 3349 HelpText<"Produce relaxation hints for linkers to try optimizing PIC " 3350 "call sequences into direct calls (MIPS only)">, Flags<[HelpHidden]>; 3351def mno_relax_pic_calls : Flag<["-"], "mno-relax-pic-calls">, 3352 Group<m_mips_Features_Group>, 3353 HelpText<"Do not produce relaxation hints for linkers to try optimizing PIC " 3354 "call sequences into direct calls (MIPS only)">, Flags<[HelpHidden]>; 3355def mglibc : Flag<["-"], "mglibc">, Group<m_libc_Group>, Flags<[HelpHidden]>; 3356def muclibc : Flag<["-"], "muclibc">, Group<m_libc_Group>, Flags<[HelpHidden]>; 3357def module_file_info : Flag<["-"], "module-file-info">, Flags<[NoXarchOption,CC1Option]>, Group<Action_Group>, 3358 HelpText<"Provide information about a particular module file">; 3359def mthumb : Flag<["-"], "mthumb">, Group<m_Group>; 3360def mtune_EQ : Joined<["-"], "mtune=">, Group<m_Group>, 3361 HelpText<"Only supported on X86 and RISC-V. Otherwise accepted for compatibility with GCC.">; 3362def multi__module : Flag<["-"], "multi_module">; 3363def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">; 3364def multiply__defined : Separate<["-"], "multiply_defined">; 3365def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>; 3366def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>, 3367 HelpText<"Use relative instead of canonical paths">; 3368def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>; 3369def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[NoXarchOption]>; 3370def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>; 3371def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">; 3372def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>, 3373 HelpText<"Disable builtin #include directories">, 3374 MarshallingInfoNegativeFlag<HeaderSearchOpts<"UseBuiltinIncludes">>; 3375def nogpuinc : Flag<["-"], "nogpuinc">, HelpText<"Do not add include paths for CUDA/HIP and" 3376 " do not include the default CUDA/HIP wrapper headers">; 3377def : Flag<["-"], "nocudainc">, Alias<nogpuinc>; 3378def nogpulib : Flag<["-"], "nogpulib">, 3379 HelpText<"Do not link device library for CUDA/HIP device compilation">; 3380def : Flag<["-"], "nocudalib">, Alias<nogpulib>; 3381def nodefaultlibs : Flag<["-"], "nodefaultlibs">; 3382def nofixprebinding : Flag<["-"], "nofixprebinding">; 3383def nolibc : Flag<["-"], "nolibc">; 3384def nomultidefs : Flag<["-"], "nomultidefs">; 3385def nopie : Flag<["-"], "nopie">; 3386def no_pie : Flag<["-"], "no-pie">, Alias<nopie>; 3387def noprebind : Flag<["-"], "noprebind">; 3388def noprofilelib : Flag<["-"], "noprofilelib">; 3389def noseglinkedit : Flag<["-"], "noseglinkedit">; 3390def nostartfiles : Flag<["-"], "nostartfiles">, Group<Link_Group>; 3391def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>; 3392def nostdlibinc : Flag<["-"], "nostdlibinc">; 3393def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>, 3394 HelpText<"Disable standard #include directories for the C++ standard library">, 3395 MarshallingInfoNegativeFlag<HeaderSearchOpts<"UseStandardCXXIncludes">>; 3396def nostdlib : Flag<["-"], "nostdlib">, Group<Link_Group>; 3397def nostdlibxx : Flag<["-"], "nostdlib++">; 3398def object : Flag<["-"], "object">; 3399def o : JoinedOrSeparate<["-"], "o">, Flags<[NoXarchOption, RenderAsInput, 3400 CC1Option, CC1AsOption, FC1Option, FlangOption]>, 3401 HelpText<"Write output to <file>">, MetaVarName<"<file>">, 3402 MarshallingInfoString<FrontendOpts<"OutputFile">>; 3403def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">; 3404def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>; 3405def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>, 3406 MarshallingInfoFlag<DiagnosticOpts<"PedanticErrors">>; 3407def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>, 3408 MarshallingInfoFlag<DiagnosticOpts<"Pedantic">>; 3409def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>, 3410 MarshallingInfoFlag<CodeGenOpts<"InstrumentForProfiling">>; 3411def pipe : Flag<["-", "--"], "pipe">, 3412 HelpText<"Use pipes between commands, when possible">; 3413def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">; 3414def prebind : Flag<["-"], "prebind">; 3415def preload : Flag<["-"], "preload">; 3416def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">, 3417 HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">; 3418def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>, 3419 HelpText<"Enable Objective-C Ivar layout bitmap print trace">, 3420 MarshallingInfoFlag<LangOpts<"ObjCGCBitmapPrint">>; 3421def print_libgcc_file_name : Flag<["-", "--"], "print-libgcc-file-name">, 3422 HelpText<"Print the library path for the currently used compiler runtime " 3423 "library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")">; 3424def print_multi_directory : Flag<["-", "--"], "print-multi-directory">; 3425def print_multi_lib : Flag<["-", "--"], "print-multi-lib">; 3426def print_multi_os_directory : Flag<["-", "--"], "print-multi-os-directory">, 3427 Flags<[Unsupported]>; 3428def print_target_triple : Flag<["-", "--"], "print-target-triple">, 3429 HelpText<"Print the normalized target triple">; 3430def print_effective_triple : Flag<["-", "--"], "print-effective-triple">, 3431 HelpText<"Print the effective target triple">; 3432def print_prog_name_EQ : Joined<["-", "--"], "print-prog-name=">, 3433 HelpText<"Print the full program path of <name>">, MetaVarName<"<name>">; 3434def print_resource_dir : Flag<["-", "--"], "print-resource-dir">, 3435 HelpText<"Print the resource directory pathname">; 3436def print_search_dirs : Flag<["-", "--"], "print-search-dirs">, 3437 HelpText<"Print the paths used for finding libraries and programs">; 3438def print_targets : Flag<["-", "--"], "print-targets">, 3439 HelpText<"Print the registered targets">; 3440def private__bundle : Flag<["-"], "private_bundle">; 3441def pthreads : Flag<["-"], "pthreads">; 3442defm pthread : BoolOption<"", "pthread", 3443 LangOpts<"POSIXThreads">, DefaultFalse, 3444 PosFlag<SetTrue, [], "Support POSIX threads in generated code">, 3445 NegFlag<SetFalse>, BothFlags<[CC1Option]>>; 3446def p : Flag<["-"], "p">; 3447def pie : Flag<["-"], "pie">, Group<Link_Group>; 3448def static_pie : Flag<["-"], "static-pie">, Group<Link_Group>; 3449def read__only__relocs : Separate<["-"], "read_only_relocs">; 3450def remap : Flag<["-"], "remap">; 3451def rewrite_objc : Flag<["-"], "rewrite-objc">, Flags<[NoXarchOption,CC1Option]>, 3452 HelpText<"Rewrite Objective-C source to C++">, Group<Action_Group>; 3453def rewrite_legacy_objc : Flag<["-"], "rewrite-legacy-objc">, Flags<[NoXarchOption]>, 3454 HelpText<"Rewrite Legacy Objective-C source to C++">; 3455def rdynamic : Flag<["-"], "rdynamic">, Group<Link_Group>; 3456def resource_dir : Separate<["-"], "resource-dir">, 3457 Flags<[NoXarchOption, CC1Option, CoreOption, HelpHidden]>, 3458 HelpText<"The directory which holds the compiler resource files">, 3459 MarshallingInfoString<HeaderSearchOpts<"ResourceDir">>; 3460def resource_dir_EQ : Joined<["-"], "resource-dir=">, Flags<[NoXarchOption, CoreOption]>, 3461 Alias<resource_dir>; 3462def rpath : Separate<["-"], "rpath">, Flags<[LinkerInput]>, Group<Link_Group>; 3463def rtlib_EQ : Joined<["-", "--"], "rtlib=">, 3464 HelpText<"Compiler runtime library to use">; 3465def frtlib_add_rpath: Flag<["-"], "frtlib-add-rpath">, Flags<[NoArgumentUnused]>, 3466 HelpText<"Add -rpath with architecture-specific resource directory to the linker flags">; 3467def fno_rtlib_add_rpath: Flag<["-"], "fno-rtlib-add-rpath">, Flags<[NoArgumentUnused]>, 3468 HelpText<"Do not add -rpath with architecture-specific resource directory to the linker flags">; 3469def r : Flag<["-"], "r">, Flags<[LinkerInput,NoArgumentUnused]>, 3470 Group<Link_Group>; 3471def save_temps_EQ : Joined<["-", "--"], "save-temps=">, Flags<[CC1Option, NoXarchOption]>, 3472 HelpText<"Save intermediate compilation results.">; 3473def save_temps : Flag<["-", "--"], "save-temps">, Flags<[NoXarchOption]>, 3474 Alias<save_temps_EQ>, AliasArgs<["cwd"]>, 3475 HelpText<"Save intermediate compilation results">; 3476def save_stats_EQ : Joined<["-", "--"], "save-stats=">, Flags<[NoXarchOption]>, 3477 HelpText<"Save llvm statistics.">; 3478def save_stats : Flag<["-", "--"], "save-stats">, Flags<[NoXarchOption]>, 3479 Alias<save_stats_EQ>, AliasArgs<["cwd"]>, 3480 HelpText<"Save llvm statistics.">; 3481def via_file_asm : Flag<["-", "--"], "via-file-asm">, InternalDebugOpt, 3482 HelpText<"Write assembly to file for input to assemble jobs">; 3483def sectalign : MultiArg<["-"], "sectalign", 3>; 3484def sectcreate : MultiArg<["-"], "sectcreate", 3>; 3485def sectobjectsymbols : MultiArg<["-"], "sectobjectsymbols", 2>; 3486def sectorder : MultiArg<["-"], "sectorder", 3>; 3487def seg1addr : JoinedOrSeparate<["-"], "seg1addr">; 3488def seg__addr__table__filename : Separate<["-"], "seg_addr_table_filename">; 3489def seg__addr__table : Separate<["-"], "seg_addr_table">; 3490def segaddr : MultiArg<["-"], "segaddr", 2>; 3491def segcreate : MultiArg<["-"], "segcreate", 3>; 3492def seglinkedit : Flag<["-"], "seglinkedit">; 3493def segprot : MultiArg<["-"], "segprot", 3>; 3494def segs__read__only__addr : Separate<["-"], "segs_read_only_addr">; 3495def segs__read__write__addr : Separate<["-"], "segs_read_write_addr">; 3496def segs__read__ : Joined<["-"], "segs_read_">; 3497def shared_libgcc : Flag<["-"], "shared-libgcc">; 3498def shared : Flag<["-", "--"], "shared">, Group<Link_Group>; 3499def single__module : Flag<["-"], "single_module">; 3500def specs_EQ : Joined<["-", "--"], "specs=">, Group<Link_Group>; 3501def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>; 3502def static_libgcc : Flag<["-"], "static-libgcc">; 3503def static_libstdcxx : Flag<["-"], "static-libstdc++">; 3504def static : Flag<["-", "--"], "static">, Group<Link_Group>, Flags<[NoArgumentUnused]>; 3505def std_default_EQ : Joined<["-"], "std-default=">; 3506def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>, 3507 Group<CompileOnly_Group>, HelpText<"Language standard to compile for">, 3508 ValuesCode<[{ 3509 const char *Values = 3510 #define LANGSTANDARD(id, name, lang, desc, features) name "," 3511 #define LANGSTANDARD_ALIAS(id, alias) alias "," 3512 #include "clang/Basic/LangStandards.def" 3513 ; 3514 }]>; 3515def stdlib_EQ : Joined<["-", "--"], "stdlib=">, Flags<[CC1Option]>, 3516 HelpText<"C++ standard library to use">, Values<"libc++,libstdc++,platform">; 3517def stdlibxx_isystem : JoinedOrSeparate<["-"], "stdlib++-isystem">, 3518 Group<clang_i_Group>, 3519 HelpText<"Use directory as the C++ standard library include path">, 3520 Flags<[NoXarchOption]>, MetaVarName<"<directory>">; 3521def unwindlib_EQ : Joined<["-", "--"], "unwindlib=">, Flags<[CC1Option]>, 3522 HelpText<"Unwind library to use">, Values<"libgcc,unwindlib,platform">; 3523def sub__library : JoinedOrSeparate<["-"], "sub_library">; 3524def sub__umbrella : JoinedOrSeparate<["-"], "sub_umbrella">; 3525def system_header_prefix : Joined<["--"], "system-header-prefix=">, 3526 Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">, 3527 HelpText<"Treat all #include paths starting with <prefix> as including a " 3528 "system header.">; 3529def : Separate<["--"], "system-header-prefix">, Alias<system_header_prefix>; 3530def no_system_header_prefix : Joined<["--"], "no-system-header-prefix=">, 3531 Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">, 3532 HelpText<"Treat all #include paths starting with <prefix> as not including a " 3533 "system header.">; 3534def : Separate<["--"], "no-system-header-prefix">, Alias<no_system_header_prefix>; 3535def s : Flag<["-"], "s">, Group<Link_Group>; 3536def target : Joined<["--"], "target=">, Flags<[NoXarchOption, CoreOption]>, 3537 HelpText<"Generate code for the given target">; 3538def print_supported_cpus : Flag<["-", "--"], "print-supported-cpus">, 3539 Group<CompileOnly_Group>, Flags<[CC1Option, CoreOption]>, 3540 HelpText<"Print supported cpu models for the given target (if target is not specified," 3541 " it will print the supported cpus for the default target)">, 3542 MarshallingInfoFlag<FrontendOpts<"PrintSupportedCPUs">>; 3543def mcpu_EQ_QUESTION : Flag<["-"], "mcpu=?">, Alias<print_supported_cpus>; 3544def mtune_EQ_QUESTION : Flag<["-"], "mtune=?">, Alias<print_supported_cpus>; 3545def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[NoXarchOption]>, 3546 HelpText<"Use the gcc toolchain at the given directory">; 3547def time : Flag<["-"], "time">, 3548 HelpText<"Time individual commands">; 3549def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>, 3550 HelpText<"Enable some traditional CPP emulation">, 3551 MarshallingInfoFlag<LangOpts<"TraditionalCPP">>; 3552def traditional : Flag<["-", "--"], "traditional">; 3553def trigraphs : Flag<["-", "--"], "trigraphs">, Alias<ftrigraphs>, 3554 HelpText<"Process trigraph sequences">; 3555def twolevel__namespace__hints : Flag<["-"], "twolevel_namespace_hints">; 3556def twolevel__namespace : Flag<["-"], "twolevel_namespace">; 3557def t : Flag<["-"], "t">, Group<Link_Group>; 3558def umbrella : Separate<["-"], "umbrella">; 3559def undefined : JoinedOrSeparate<["-"], "undefined">, Group<u_Group>; 3560def undef : Flag<["-"], "undef">, Group<u_Group>, Flags<[CC1Option]>, 3561 HelpText<"undef all system defines">, 3562 MarshallingInfoNegativeFlag<PreprocessorOpts<"UsePredefines">>; 3563def unexported__symbols__list : Separate<["-"], "unexported_symbols_list">; 3564def u : JoinedOrSeparate<["-"], "u">, Group<u_Group>; 3565def v : Flag<["-"], "v">, Flags<[CC1Option, CoreOption]>, 3566 HelpText<"Show commands to run and use verbose output">, 3567 MarshallingInfoFlag<HeaderSearchOpts<"Verbose">>; 3568def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[NoXarchOption]>, 3569 HelpText<"Verify the binary representation of debug output">; 3570def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>; 3571def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>; 3572def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>; 3573def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">; 3574def whatsloaded : Flag<["-"], "whatsloaded">; 3575def whyload : Flag<["-"], "whyload">; 3576def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>, 3577 MarshallingInfoFlag<DiagnosticOpts<"IgnoreWarnings">>; 3578def x : JoinedOrSeparate<["-"], "x">, Flags<[NoXarchOption,CC1Option]>, 3579 HelpText<"Treat subsequent input files as having type <language>">, 3580 MetaVarName<"<language>">; 3581def y : Joined<["-"], "y">; 3582 3583defm integrated_as : BoolFOption<"integrated-as", 3584 CodeGenOpts<"DisableIntegratedAS">, DefaultFalse, 3585 NegFlag<SetTrue, [CC1Option], "Disable">, PosFlag<SetFalse, [], "Enable">, 3586 BothFlags<[], " the integrated assembler">>; 3587 3588def fintegrated_cc1 : Flag<["-"], "fintegrated-cc1">, 3589 Flags<[CoreOption, NoXarchOption]>, Group<f_Group>, 3590 HelpText<"Run cc1 in-process">; 3591def fno_integrated_cc1 : Flag<["-"], "fno-integrated-cc1">, 3592 Flags<[CoreOption, NoXarchOption]>, Group<f_Group>, 3593 HelpText<"Spawn a separate process for each cc1">; 3594 3595def : Flag<["-"], "integrated-as">, Alias<fintegrated_as>, Flags<[NoXarchOption]>; 3596def : Flag<["-"], "no-integrated-as">, Alias<fno_integrated_as>, 3597 Flags<[CC1Option, NoXarchOption]>; 3598 3599def working_directory : JoinedOrSeparate<["-"], "working-directory">, Flags<[CC1Option]>, 3600 HelpText<"Resolve file paths relative to the specified directory">, 3601 MarshallingInfoString<FileSystemOpts<"WorkingDir">>; 3602def working_directory_EQ : Joined<["-"], "working-directory=">, Flags<[CC1Option]>, 3603 Alias<working_directory>; 3604 3605// Double dash options, which are usually an alias for one of the previous 3606// options. 3607 3608def _mhwdiv_EQ : Joined<["--"], "mhwdiv=">, Alias<mhwdiv_EQ>; 3609def _mhwdiv : Separate<["--"], "mhwdiv">, Alias<mhwdiv_EQ>; 3610def _CLASSPATH_EQ : Joined<["--"], "CLASSPATH=">, Alias<fclasspath_EQ>; 3611def _CLASSPATH : Separate<["--"], "CLASSPATH">, Alias<fclasspath_EQ>; 3612def _all_warnings : Flag<["--"], "all-warnings">, Alias<Wall>; 3613def _analyzer_no_default_checks : Flag<["--"], "analyzer-no-default-checks">, Flags<[NoXarchOption]>; 3614def _analyzer_output : JoinedOrSeparate<["--"], "analyzer-output">, Flags<[NoXarchOption]>, 3615 HelpText<"Static analyzer report output format (html|plist|plist-multi-file|plist-html|sarif|text).">; 3616def _analyze : Flag<["--"], "analyze">, Flags<[NoXarchOption, CoreOption]>, 3617 HelpText<"Run the static analyzer">; 3618def _assemble : Flag<["--"], "assemble">, Alias<S>; 3619def _assert_EQ : Joined<["--"], "assert=">, Alias<A>; 3620def _assert : Separate<["--"], "assert">, Alias<A>; 3621def _bootclasspath_EQ : Joined<["--"], "bootclasspath=">, Alias<fbootclasspath_EQ>; 3622def _bootclasspath : Separate<["--"], "bootclasspath">, Alias<fbootclasspath_EQ>; 3623def _classpath_EQ : Joined<["--"], "classpath=">, Alias<fclasspath_EQ>; 3624def _classpath : Separate<["--"], "classpath">, Alias<fclasspath_EQ>; 3625def _comments_in_macros : Flag<["--"], "comments-in-macros">, Alias<CC>; 3626def _comments : Flag<["--"], "comments">, Alias<C>; 3627def _compile : Flag<["--"], "compile">, Alias<c>; 3628def _constant_cfstrings : Flag<["--"], "constant-cfstrings">; 3629def _debug_EQ : Joined<["--"], "debug=">, Alias<g_Flag>; 3630def _debug : Flag<["--"], "debug">, Alias<g_Flag>; 3631def _define_macro_EQ : Joined<["--"], "define-macro=">, Alias<D>; 3632def _define_macro : Separate<["--"], "define-macro">, Alias<D>; 3633def _dependencies : Flag<["--"], "dependencies">, Alias<M>; 3634def _dyld_prefix_EQ : Joined<["--"], "dyld-prefix=">; 3635def _dyld_prefix : Separate<["--"], "dyld-prefix">, Alias<_dyld_prefix_EQ>; 3636def _encoding_EQ : Joined<["--"], "encoding=">, Alias<fencoding_EQ>; 3637def _encoding : Separate<["--"], "encoding">, Alias<fencoding_EQ>; 3638def _entry : Flag<["--"], "entry">, Alias<e>; 3639def _extdirs_EQ : Joined<["--"], "extdirs=">, Alias<fextdirs_EQ>; 3640def _extdirs : Separate<["--"], "extdirs">, Alias<fextdirs_EQ>; 3641def _extra_warnings : Flag<["--"], "extra-warnings">, Alias<W_Joined>; 3642def _for_linker_EQ : Joined<["--"], "for-linker=">, Alias<Xlinker>; 3643def _for_linker : Separate<["--"], "for-linker">, Alias<Xlinker>; 3644def _force_link_EQ : Joined<["--"], "force-link=">, Alias<u>; 3645def _force_link : Separate<["--"], "force-link">, Alias<u>; 3646def _help_hidden : Flag<["--"], "help-hidden">, 3647 HelpText<"Display help for hidden options">; 3648def _imacros_EQ : Joined<["--"], "imacros=">, Alias<imacros>; 3649def _include_barrier : Flag<["--"], "include-barrier">, Alias<I_>; 3650def _include_directory_after_EQ : Joined<["--"], "include-directory-after=">, Alias<idirafter>; 3651def _include_directory_after : Separate<["--"], "include-directory-after">, Alias<idirafter>; 3652def _include_directory_EQ : Joined<["--"], "include-directory=">, Alias<I>; 3653def _include_directory : Separate<["--"], "include-directory">, Alias<I>; 3654def _include_prefix_EQ : Joined<["--"], "include-prefix=">, Alias<iprefix>; 3655def _include_prefix : Separate<["--"], "include-prefix">, Alias<iprefix>; 3656def _include_with_prefix_after_EQ : Joined<["--"], "include-with-prefix-after=">, Alias<iwithprefix>; 3657def _include_with_prefix_after : Separate<["--"], "include-with-prefix-after">, Alias<iwithprefix>; 3658def _include_with_prefix_before_EQ : Joined<["--"], "include-with-prefix-before=">, Alias<iwithprefixbefore>; 3659def _include_with_prefix_before : Separate<["--"], "include-with-prefix-before">, Alias<iwithprefixbefore>; 3660def _include_with_prefix_EQ : Joined<["--"], "include-with-prefix=">, Alias<iwithprefix>; 3661def _include_with_prefix : Separate<["--"], "include-with-prefix">, Alias<iwithprefix>; 3662def _include_EQ : Joined<["--"], "include=">, Alias<include_>; 3663def _language_EQ : Joined<["--"], "language=">, Alias<x>; 3664def _language : Separate<["--"], "language">, Alias<x>; 3665def _library_directory_EQ : Joined<["--"], "library-directory=">, Alias<L>; 3666def _library_directory : Separate<["--"], "library-directory">, Alias<L>; 3667def _no_line_commands : Flag<["--"], "no-line-commands">, Alias<P>; 3668def _no_standard_includes : Flag<["--"], "no-standard-includes">, Alias<nostdinc>; 3669def _no_standard_libraries : Flag<["--"], "no-standard-libraries">, Alias<nostdlib>; 3670def _no_undefined : Flag<["--"], "no-undefined">, Flags<[LinkerInput]>; 3671def _no_warnings : Flag<["--"], "no-warnings">, Alias<w>; 3672def _optimize_EQ : Joined<["--"], "optimize=">, Alias<O>; 3673def _optimize : Flag<["--"], "optimize">, Alias<O>; 3674def _output_class_directory_EQ : Joined<["--"], "output-class-directory=">, Alias<foutput_class_dir_EQ>; 3675def _output_class_directory : Separate<["--"], "output-class-directory">, Alias<foutput_class_dir_EQ>; 3676def _output_EQ : Joined<["--"], "output=">, Alias<o>; 3677def _output : Separate<["--"], "output">, Alias<o>; 3678def _param : Separate<["--"], "param">, Group<CompileOnly_Group>; 3679def _param_EQ : Joined<["--"], "param=">, Alias<_param>; 3680def _precompile : Flag<["--"], "precompile">, Flags<[NoXarchOption]>, 3681 Group<Action_Group>, HelpText<"Only precompile the input">; 3682def _prefix_EQ : Joined<["--"], "prefix=">, Alias<B>; 3683def _prefix : Separate<["--"], "prefix">, Alias<B>; 3684def _preprocess : Flag<["--"], "preprocess">, Alias<E>; 3685def _print_diagnostic_categories : Flag<["--"], "print-diagnostic-categories">; 3686def _print_file_name : Separate<["--"], "print-file-name">, Alias<print_file_name_EQ>; 3687def _print_missing_file_dependencies : Flag<["--"], "print-missing-file-dependencies">, Alias<MG>; 3688def _print_prog_name : Separate<["--"], "print-prog-name">, Alias<print_prog_name_EQ>; 3689def _profile_blocks : Flag<["--"], "profile-blocks">, Alias<a>; 3690def _profile : Flag<["--"], "profile">, Alias<p>; 3691def _resource_EQ : Joined<["--"], "resource=">, Alias<fcompile_resource_EQ>; 3692def _resource : Separate<["--"], "resource">, Alias<fcompile_resource_EQ>; 3693def _rtlib : Separate<["--"], "rtlib">, Alias<rtlib_EQ>; 3694def _serialize_diags : Separate<["-", "--"], "serialize-diagnostics">, Flags<[NoXarchOption]>, 3695 HelpText<"Serialize compiler diagnostics to a file">; 3696// We give --version different semantics from -version. 3697def _version : Flag<["--"], "version">, 3698 Flags<[CoreOption, CC1Option, FC1Option, FlangOption]>, 3699 HelpText<"Print version information">; 3700def _signed_char : Flag<["--"], "signed-char">, Alias<fsigned_char>; 3701def _std : Separate<["--"], "std">, Alias<std_EQ>; 3702def _stdlib : Separate<["--"], "stdlib">, Alias<stdlib_EQ>; 3703def _sysroot_EQ : Joined<["--"], "sysroot=">; 3704def _sysroot : Separate<["--"], "sysroot">, Alias<_sysroot_EQ>; 3705def _target_help : Flag<["--"], "target-help">; 3706def _trace_includes : Flag<["--"], "trace-includes">, Alias<H>; 3707def _undefine_macro_EQ : Joined<["--"], "undefine-macro=">, Alias<U>; 3708def _undefine_macro : Separate<["--"], "undefine-macro">, Alias<U>; 3709def _unsigned_char : Flag<["--"], "unsigned-char">, Alias<funsigned_char>; 3710def _user_dependencies : Flag<["--"], "user-dependencies">, Alias<MM>; 3711def _verbose : Flag<["--"], "verbose">, Alias<v>; 3712def _warn__EQ : Joined<["--"], "warn-=">, Alias<W_Joined>; 3713def _warn_ : Joined<["--"], "warn-">, Alias<W_Joined>; 3714def _write_dependencies : Flag<["--"], "write-dependencies">, Alias<MD>; 3715def _write_user_dependencies : Flag<["--"], "write-user-dependencies">, Alias<MMD>; 3716def _ : Joined<["--"], "">, Flags<[Unsupported]>; 3717 3718// Hexagon feature flags. 3719def mieee_rnd_near : Flag<["-"], "mieee-rnd-near">, 3720 Group<m_hexagon_Features_Group>; 3721def mv5 : Flag<["-"], "mv5">, Group<m_hexagon_Features_Group>, Alias<mcpu_EQ>, 3722 AliasArgs<["hexagonv5"]>; 3723def mv55 : Flag<["-"], "mv55">, Group<m_hexagon_Features_Group>, 3724 Alias<mcpu_EQ>, AliasArgs<["hexagonv55"]>; 3725def mv60 : Flag<["-"], "mv60">, Group<m_hexagon_Features_Group>, 3726 Alias<mcpu_EQ>, AliasArgs<["hexagonv60"]>; 3727def mv62 : Flag<["-"], "mv62">, Group<m_hexagon_Features_Group>, 3728 Alias<mcpu_EQ>, AliasArgs<["hexagonv62"]>; 3729def mv65 : Flag<["-"], "mv65">, Group<m_hexagon_Features_Group>, 3730 Alias<mcpu_EQ>, AliasArgs<["hexagonv65"]>; 3731def mv66 : Flag<["-"], "mv66">, Group<m_hexagon_Features_Group>, 3732 Alias<mcpu_EQ>, AliasArgs<["hexagonv66"]>; 3733def mv67 : Flag<["-"], "mv67">, Group<m_hexagon_Features_Group>, 3734 Alias<mcpu_EQ>, AliasArgs<["hexagonv67"]>; 3735def mv67t : Flag<["-"], "mv67t">, Group<m_hexagon_Features_Group>, 3736 Alias<mcpu_EQ>, AliasArgs<["hexagonv67t"]>; 3737def mhexagon_hvx : Flag<["-"], "mhvx">, Group<m_hexagon_Features_HVX_Group>, 3738 HelpText<"Enable Hexagon Vector eXtensions">; 3739def mhexagon_hvx_EQ : Joined<["-"], "mhvx=">, 3740 Group<m_hexagon_Features_HVX_Group>, 3741 HelpText<"Enable Hexagon Vector eXtensions">; 3742def mno_hexagon_hvx : Flag<["-"], "mno-hvx">, 3743 Group<m_hexagon_Features_HVX_Group>, 3744 HelpText<"Disable Hexagon Vector eXtensions">; 3745def mhexagon_hvx_length_EQ : Joined<["-"], "mhvx-length=">, 3746 Group<m_hexagon_Features_HVX_Group>, HelpText<"Set Hexagon Vector Length">, 3747 Values<"64B,128B">; 3748def ffixed_r19: Flag<["-"], "ffixed-r19">, 3749 HelpText<"Reserve register r19 (Hexagon only)">; 3750def mmemops : Flag<["-"], "mmemops">, Group<m_hexagon_Features_Group>, 3751 Flags<[CC1Option]>, HelpText<"Enable generation of memop instructions">; 3752def mno_memops : Flag<["-"], "mno-memops">, Group<m_hexagon_Features_Group>, 3753 Flags<[CC1Option]>, HelpText<"Disable generation of memop instructions">; 3754def mpackets : Flag<["-"], "mpackets">, Group<m_hexagon_Features_Group>, 3755 Flags<[CC1Option]>, HelpText<"Enable generation of instruction packets">; 3756def mno_packets : Flag<["-"], "mno-packets">, Group<m_hexagon_Features_Group>, 3757 Flags<[CC1Option]>, HelpText<"Disable generation of instruction packets">; 3758def mnvj : Flag<["-"], "mnvj">, Group<m_hexagon_Features_Group>, 3759 Flags<[CC1Option]>, HelpText<"Enable generation of new-value jumps">; 3760def mno_nvj : Flag<["-"], "mno-nvj">, Group<m_hexagon_Features_Group>, 3761 Flags<[CC1Option]>, HelpText<"Disable generation of new-value jumps">; 3762def mnvs : Flag<["-"], "mnvs">, Group<m_hexagon_Features_Group>, 3763 Flags<[CC1Option]>, HelpText<"Enable generation of new-value stores">; 3764def mno_nvs : Flag<["-"], "mno-nvs">, Group<m_hexagon_Features_Group>, 3765 Flags<[CC1Option]>, HelpText<"Disable generation of new-value stores">; 3766 3767 3768// X86 feature flags 3769def mx87 : Flag<["-"], "mx87">, Group<m_x86_Features_Group>; 3770def mno_x87 : Flag<["-"], "mno-x87">, Group<m_x86_Features_Group>; 3771def m80387 : Flag<["-"], "m80387">, Alias<mx87>; 3772def mno_80387 : Flag<["-"], "mno-80387">, Alias<mno_x87>; 3773def mmmx : Flag<["-"], "mmmx">, Group<m_x86_Features_Group>; 3774def mno_mmx : Flag<["-"], "mno-mmx">, Group<m_x86_Features_Group>; 3775def m3dnow : Flag<["-"], "m3dnow">, Group<m_x86_Features_Group>; 3776def mno_3dnow : Flag<["-"], "mno-3dnow">, Group<m_x86_Features_Group>; 3777def m3dnowa : Flag<["-"], "m3dnowa">, Group<m_x86_Features_Group>; 3778def mno_3dnowa : Flag<["-"], "mno-3dnowa">, Group<m_x86_Features_Group>; 3779def mamx_bf16 : Flag<["-"], "mamx-bf16">, Group<m_x86_Features_Group>; 3780def mno_amx_bf16 : Flag<["-"], "mno-amx-bf16">, Group<m_x86_Features_Group>; 3781def mtamx_int8 : Flag<["-"], "mamx-int8">, Group<m_x86_Features_Group>; 3782def mno_amx_int8 : Flag<["-"], "mno-amx-int8">, Group<m_x86_Features_Group>; 3783def mamx_tile : Flag<["-"], "mamx-tile">, Group<m_x86_Features_Group>; 3784def mno_amx_tile : Flag<["-"], "mno-amx-tile">, Group<m_x86_Features_Group>; 3785def msse : Flag<["-"], "msse">, Group<m_x86_Features_Group>; 3786def mno_sse : Flag<["-"], "mno-sse">, Group<m_x86_Features_Group>; 3787def msse2 : Flag<["-"], "msse2">, Group<m_x86_Features_Group>; 3788def mno_sse2 : Flag<["-"], "mno-sse2">, Group<m_x86_Features_Group>; 3789def msse3 : Flag<["-"], "msse3">, Group<m_x86_Features_Group>; 3790def mno_sse3 : Flag<["-"], "mno-sse3">, Group<m_x86_Features_Group>; 3791def mssse3 : Flag<["-"], "mssse3">, Group<m_x86_Features_Group>; 3792def mno_ssse3 : Flag<["-"], "mno-ssse3">, Group<m_x86_Features_Group>; 3793def msse4_1 : Flag<["-"], "msse4.1">, Group<m_x86_Features_Group>; 3794def mno_sse4_1 : Flag<["-"], "mno-sse4.1">, Group<m_x86_Features_Group>; 3795def msse4_2 : Flag<["-"], "msse4.2">, Group<m_x86_Features_Group>; 3796def mno_sse4_2 : Flag<["-"], "mno-sse4.2">, Group<m_x86_Features_Group>; 3797def msse4 : Flag<["-"], "msse4">, Alias<msse4_2>; 3798// -mno-sse4 turns off sse4.1 which has the effect of turning off everything 3799// later than 4.1. -msse4 turns on 4.2 which has the effect of turning on 3800// everything earlier than 4.2. 3801def mno_sse4 : Flag<["-"], "mno-sse4">, Alias<mno_sse4_1>; 3802def msse4a : Flag<["-"], "msse4a">, Group<m_x86_Features_Group>; 3803def mno_sse4a : Flag<["-"], "mno-sse4a">, Group<m_x86_Features_Group>; 3804def mavx : Flag<["-"], "mavx">, Group<m_x86_Features_Group>; 3805def mno_avx : Flag<["-"], "mno-avx">, Group<m_x86_Features_Group>; 3806def mavx2 : Flag<["-"], "mavx2">, Group<m_x86_Features_Group>; 3807def mno_avx2 : Flag<["-"], "mno-avx2">, Group<m_x86_Features_Group>; 3808def mavx512f : Flag<["-"], "mavx512f">, Group<m_x86_Features_Group>; 3809def mno_avx512f : Flag<["-"], "mno-avx512f">, Group<m_x86_Features_Group>; 3810def mavx512bf16 : Flag<["-"], "mavx512bf16">, Group<m_x86_Features_Group>; 3811def mno_avx512bf16 : Flag<["-"], "mno-avx512bf16">, Group<m_x86_Features_Group>; 3812def mavx512bitalg : Flag<["-"], "mavx512bitalg">, Group<m_x86_Features_Group>; 3813def mno_avx512bitalg : Flag<["-"], "mno-avx512bitalg">, Group<m_x86_Features_Group>; 3814def mavx512bw : Flag<["-"], "mavx512bw">, Group<m_x86_Features_Group>; 3815def mno_avx512bw : Flag<["-"], "mno-avx512bw">, Group<m_x86_Features_Group>; 3816def mavx512cd : Flag<["-"], "mavx512cd">, Group<m_x86_Features_Group>; 3817def mno_avx512cd : Flag<["-"], "mno-avx512cd">, Group<m_x86_Features_Group>; 3818def mavx512dq : Flag<["-"], "mavx512dq">, Group<m_x86_Features_Group>; 3819def mno_avx512dq : Flag<["-"], "mno-avx512dq">, Group<m_x86_Features_Group>; 3820def mavx512er : Flag<["-"], "mavx512er">, Group<m_x86_Features_Group>; 3821def mno_avx512er : Flag<["-"], "mno-avx512er">, Group<m_x86_Features_Group>; 3822def mavx512ifma : Flag<["-"], "mavx512ifma">, Group<m_x86_Features_Group>; 3823def mno_avx512ifma : Flag<["-"], "mno-avx512ifma">, Group<m_x86_Features_Group>; 3824def mavx512pf : Flag<["-"], "mavx512pf">, Group<m_x86_Features_Group>; 3825def mno_avx512pf : Flag<["-"], "mno-avx512pf">, Group<m_x86_Features_Group>; 3826def mavx512vbmi : Flag<["-"], "mavx512vbmi">, Group<m_x86_Features_Group>; 3827def mno_avx512vbmi : Flag<["-"], "mno-avx512vbmi">, Group<m_x86_Features_Group>; 3828def mavx512vbmi2 : Flag<["-"], "mavx512vbmi2">, Group<m_x86_Features_Group>; 3829def mno_avx512vbmi2 : Flag<["-"], "mno-avx512vbmi2">, Group<m_x86_Features_Group>; 3830def mavx512vl : Flag<["-"], "mavx512vl">, Group<m_x86_Features_Group>; 3831def mno_avx512vl : Flag<["-"], "mno-avx512vl">, Group<m_x86_Features_Group>; 3832def mavx512vnni : Flag<["-"], "mavx512vnni">, Group<m_x86_Features_Group>; 3833def mno_avx512vnni : Flag<["-"], "mno-avx512vnni">, Group<m_x86_Features_Group>; 3834def mavx512vpopcntdq : Flag<["-"], "mavx512vpopcntdq">, Group<m_x86_Features_Group>; 3835def mno_avx512vpopcntdq : Flag<["-"], "mno-avx512vpopcntdq">, Group<m_x86_Features_Group>; 3836def mavx512vp2intersect : Flag<["-"], "mavx512vp2intersect">, Group<m_x86_Features_Group>; 3837def mno_avx512vp2intersect : Flag<["-"], "mno-avx512vp2intersect">, Group<m_x86_Features_Group>; 3838def mavxvnni : Flag<["-"], "mavxvnni">, Group<m_x86_Features_Group>; 3839def mno_avxvnni : Flag<["-"], "mno-avxvnni">, Group<m_x86_Features_Group>; 3840def madx : Flag<["-"], "madx">, Group<m_x86_Features_Group>; 3841def mno_adx : Flag<["-"], "mno-adx">, Group<m_x86_Features_Group>; 3842def maes : Flag<["-"], "maes">, Group<m_x86_Features_Group>; 3843def mno_aes : Flag<["-"], "mno-aes">, Group<m_x86_Features_Group>; 3844def mbmi : Flag<["-"], "mbmi">, Group<m_x86_Features_Group>; 3845def mno_bmi : Flag<["-"], "mno-bmi">, Group<m_x86_Features_Group>; 3846def mbmi2 : Flag<["-"], "mbmi2">, Group<m_x86_Features_Group>; 3847def mno_bmi2 : Flag<["-"], "mno-bmi2">, Group<m_x86_Features_Group>; 3848def mcldemote : Flag<["-"], "mcldemote">, Group<m_x86_Features_Group>; 3849def mno_cldemote : Flag<["-"], "mno-cldemote">, Group<m_x86_Features_Group>; 3850def mclflushopt : Flag<["-"], "mclflushopt">, Group<m_x86_Features_Group>; 3851def mno_clflushopt : Flag<["-"], "mno-clflushopt">, Group<m_x86_Features_Group>; 3852def mclwb : Flag<["-"], "mclwb">, Group<m_x86_Features_Group>; 3853def mno_clwb : Flag<["-"], "mno-clwb">, Group<m_x86_Features_Group>; 3854def mwbnoinvd : Flag<["-"], "mwbnoinvd">, Group<m_x86_Features_Group>; 3855def mno_wbnoinvd : Flag<["-"], "mno-wbnoinvd">, Group<m_x86_Features_Group>; 3856def mclzero : Flag<["-"], "mclzero">, Group<m_x86_Features_Group>; 3857def mno_clzero : Flag<["-"], "mno-clzero">, Group<m_x86_Features_Group>; 3858def mcx16 : Flag<["-"], "mcx16">, Group<m_x86_Features_Group>; 3859def mno_cx16 : Flag<["-"], "mno-cx16">, Group<m_x86_Features_Group>; 3860def menqcmd : Flag<["-"], "menqcmd">, Group<m_x86_Features_Group>; 3861def mno_enqcmd : Flag<["-"], "mno-enqcmd">, Group<m_x86_Features_Group>; 3862def mf16c : Flag<["-"], "mf16c">, Group<m_x86_Features_Group>; 3863def mno_f16c : Flag<["-"], "mno-f16c">, Group<m_x86_Features_Group>; 3864def mfma : Flag<["-"], "mfma">, Group<m_x86_Features_Group>; 3865def mno_fma : Flag<["-"], "mno-fma">, Group<m_x86_Features_Group>; 3866def mfma4 : Flag<["-"], "mfma4">, Group<m_x86_Features_Group>; 3867def mno_fma4 : Flag<["-"], "mno-fma4">, Group<m_x86_Features_Group>; 3868def mfsgsbase : Flag<["-"], "mfsgsbase">, Group<m_x86_Features_Group>; 3869def mno_fsgsbase : Flag<["-"], "mno-fsgsbase">, Group<m_x86_Features_Group>; 3870def mfxsr : Flag<["-"], "mfxsr">, Group<m_x86_Features_Group>; 3871def mno_fxsr : Flag<["-"], "mno-fxsr">, Group<m_x86_Features_Group>; 3872def minvpcid : Flag<["-"], "minvpcid">, Group<m_x86_Features_Group>; 3873def mno_invpcid : Flag<["-"], "mno-invpcid">, Group<m_x86_Features_Group>; 3874def mgfni : Flag<["-"], "mgfni">, Group<m_x86_Features_Group>; 3875def mno_gfni : Flag<["-"], "mno-gfni">, Group<m_x86_Features_Group>; 3876def mhreset : Flag<["-"], "mhreset">, Group<m_x86_Features_Group>; 3877def mno_hreset : Flag<["-"], "mno-hreset">, Group<m_x86_Features_Group>; 3878def mkl : Flag<["-"], "mkl">, Group<m_x86_Features_Group>; 3879def mno_kl : Flag<["-"], "mno-kl">, Group<m_x86_Features_Group>; 3880def mwidekl : Flag<["-"], "mwidekl">, Group<m_x86_Features_Group>; 3881def mno_widekl : Flag<["-"], "mno-widekl">, Group<m_x86_Features_Group>; 3882def mlwp : Flag<["-"], "mlwp">, Group<m_x86_Features_Group>; 3883def mno_lwp : Flag<["-"], "mno-lwp">, Group<m_x86_Features_Group>; 3884def mlzcnt : Flag<["-"], "mlzcnt">, Group<m_x86_Features_Group>; 3885def mno_lzcnt : Flag<["-"], "mno-lzcnt">, Group<m_x86_Features_Group>; 3886def mmovbe : Flag<["-"], "mmovbe">, Group<m_x86_Features_Group>; 3887def mno_movbe : Flag<["-"], "mno-movbe">, Group<m_x86_Features_Group>; 3888def mmovdiri : Flag<["-"], "mmovdiri">, Group<m_x86_Features_Group>; 3889def mno_movdiri : Flag<["-"], "mno-movdiri">, Group<m_x86_Features_Group>; 3890def mmovdir64b : Flag<["-"], "mmovdir64b">, Group<m_x86_Features_Group>; 3891def mno_movdir64b : Flag<["-"], "mno-movdir64b">, Group<m_x86_Features_Group>; 3892def mmwaitx : Flag<["-"], "mmwaitx">, Group<m_x86_Features_Group>; 3893def mno_mwaitx : Flag<["-"], "mno-mwaitx">, Group<m_x86_Features_Group>; 3894def mpku : Flag<["-"], "mpku">, Group<m_x86_Features_Group>; 3895def mno_pku : Flag<["-"], "mno-pku">, Group<m_x86_Features_Group>; 3896def mpclmul : Flag<["-"], "mpclmul">, Group<m_x86_Features_Group>; 3897def mno_pclmul : Flag<["-"], "mno-pclmul">, Group<m_x86_Features_Group>; 3898def mpconfig : Flag<["-"], "mpconfig">, Group<m_x86_Features_Group>; 3899def mno_pconfig : Flag<["-"], "mno-pconfig">, Group<m_x86_Features_Group>; 3900def mpopcnt : Flag<["-"], "mpopcnt">, Group<m_x86_Features_Group>; 3901def mno_popcnt : Flag<["-"], "mno-popcnt">, Group<m_x86_Features_Group>; 3902def mprefetchwt1 : Flag<["-"], "mprefetchwt1">, Group<m_x86_Features_Group>; 3903def mno_prefetchwt1 : Flag<["-"], "mno-prefetchwt1">, Group<m_x86_Features_Group>; 3904def mprfchw : Flag<["-"], "mprfchw">, Group<m_x86_Features_Group>; 3905def mno_prfchw : Flag<["-"], "mno-prfchw">, Group<m_x86_Features_Group>; 3906def mptwrite : Flag<["-"], "mptwrite">, Group<m_x86_Features_Group>; 3907def mno_ptwrite : Flag<["-"], "mno-ptwrite">, Group<m_x86_Features_Group>; 3908def mrdpid : Flag<["-"], "mrdpid">, Group<m_x86_Features_Group>; 3909def mno_rdpid : Flag<["-"], "mno-rdpid">, Group<m_x86_Features_Group>; 3910def mrdrnd : Flag<["-"], "mrdrnd">, Group<m_x86_Features_Group>; 3911def mno_rdrnd : Flag<["-"], "mno-rdrnd">, Group<m_x86_Features_Group>; 3912def mrtm : Flag<["-"], "mrtm">, Group<m_x86_Features_Group>; 3913def mno_rtm : Flag<["-"], "mno-rtm">, Group<m_x86_Features_Group>; 3914def mrdseed : Flag<["-"], "mrdseed">, Group<m_x86_Features_Group>; 3915def mno_rdseed : Flag<["-"], "mno-rdseed">, Group<m_x86_Features_Group>; 3916def msahf : Flag<["-"], "msahf">, Group<m_x86_Features_Group>; 3917def mno_sahf : Flag<["-"], "mno-sahf">, Group<m_x86_Features_Group>; 3918def mserialize : Flag<["-"], "mserialize">, Group<m_x86_Features_Group>; 3919def mno_serialize : Flag<["-"], "mno-serialize">, Group<m_x86_Features_Group>; 3920def msgx : Flag<["-"], "msgx">, Group<m_x86_Features_Group>; 3921def mno_sgx : Flag<["-"], "mno-sgx">, Group<m_x86_Features_Group>; 3922def msha : Flag<["-"], "msha">, Group<m_x86_Features_Group>; 3923def mno_sha : Flag<["-"], "mno-sha">, Group<m_x86_Features_Group>; 3924def mtbm : Flag<["-"], "mtbm">, Group<m_x86_Features_Group>; 3925def mno_tbm : Flag<["-"], "mno-tbm">, Group<m_x86_Features_Group>; 3926def mtsxldtrk : Flag<["-"], "mtsxldtrk">, Group<m_x86_Features_Group>; 3927def mno_tsxldtrk : Flag<["-"], "mno-tsxldtrk">, Group<m_x86_Features_Group>; 3928def muintr : Flag<["-"], "muintr">, Group<m_x86_Features_Group>; 3929def mno_uintr : Flag<["-"], "mno-uintr">, Group<m_x86_Features_Group>; 3930def mvaes : Flag<["-"], "mvaes">, Group<m_x86_Features_Group>; 3931def mno_vaes : Flag<["-"], "mno-vaes">, Group<m_x86_Features_Group>; 3932def mvpclmulqdq : Flag<["-"], "mvpclmulqdq">, Group<m_x86_Features_Group>; 3933def mno_vpclmulqdq : Flag<["-"], "mno-vpclmulqdq">, Group<m_x86_Features_Group>; 3934def mwaitpkg : Flag<["-"], "mwaitpkg">, Group<m_x86_Features_Group>; 3935def mno_waitpkg : Flag<["-"], "mno-waitpkg">, Group<m_x86_Features_Group>; 3936def mxop : Flag<["-"], "mxop">, Group<m_x86_Features_Group>; 3937def mno_xop : Flag<["-"], "mno-xop">, Group<m_x86_Features_Group>; 3938def mxsave : Flag<["-"], "mxsave">, Group<m_x86_Features_Group>; 3939def mno_xsave : Flag<["-"], "mno-xsave">, Group<m_x86_Features_Group>; 3940def mxsavec : Flag<["-"], "mxsavec">, Group<m_x86_Features_Group>; 3941def mno_xsavec : Flag<["-"], "mno-xsavec">, Group<m_x86_Features_Group>; 3942def mxsaveopt : Flag<["-"], "mxsaveopt">, Group<m_x86_Features_Group>; 3943def mno_xsaveopt : Flag<["-"], "mno-xsaveopt">, Group<m_x86_Features_Group>; 3944def mxsaves : Flag<["-"], "mxsaves">, Group<m_x86_Features_Group>; 3945def mno_xsaves : Flag<["-"], "mno-xsaves">, Group<m_x86_Features_Group>; 3946def mshstk : Flag<["-"], "mshstk">, Group<m_x86_Features_Group>; 3947def mno_shstk : Flag<["-"], "mno-shstk">, Group<m_x86_Features_Group>; 3948def mretpoline_external_thunk : Flag<["-"], "mretpoline-external-thunk">, Group<m_x86_Features_Group>; 3949def mno_retpoline_external_thunk : Flag<["-"], "mno-retpoline-external-thunk">, Group<m_x86_Features_Group>; 3950def mvzeroupper : Flag<["-"], "mvzeroupper">, Group<m_x86_Features_Group>; 3951def mno_vzeroupper : Flag<["-"], "mno-vzeroupper">, Group<m_x86_Features_Group>; 3952 3953// These are legacy user-facing driver-level option spellings. They are always 3954// aliases for options that are spelled using the more common Unix / GNU flag 3955// style of double-dash and equals-joined flags. 3956def gcc_toolchain_legacy_spelling : Separate<["-"], "gcc-toolchain">, Alias<gcc_toolchain>; 3957def target_legacy_spelling : Separate<["-"], "target">, Alias<target>; 3958 3959// Special internal option to handle -Xlinker --no-demangle. 3960def Z_Xlinker__no_demangle : Flag<["-"], "Z-Xlinker-no-demangle">, 3961 Flags<[Unsupported, NoArgumentUnused]>; 3962 3963// Special internal option to allow forwarding arbitrary arguments to linker. 3964def Zlinker_input : Separate<["-"], "Zlinker-input">, 3965 Flags<[Unsupported, NoArgumentUnused]>; 3966 3967// Reserved library options. 3968def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">, 3969 Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>; 3970def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">, 3971 Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>; 3972 3973// Ignored options 3974multiclass BooleanFFlag<string name> { 3975 def f#NAME : Flag<["-"], "f"#name>; 3976 def fno_#NAME : Flag<["-"], "fno-"#name>; 3977} 3978 3979defm : BooleanFFlag<"keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>; 3980 3981def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<f_Group>; 3982 3983// The default value matches BinutilsVersion in MCAsmInfo.h. 3984def fbinutils_version_EQ : Joined<["-"], "fbinutils-version=">, 3985 MetaVarName<"<major.minor>">, Group<f_Group>, Flags<[CC1Option]>, 3986 HelpText<"Produced object files can use all ELF features supported by this " 3987 "binutils version and newer. If -fno-integrated-as is specified, the " 3988 "generated assembly will consider GNU as support. 'none' means that all ELF " 3989 "features can be used, regardless of binutils support. Defaults to 2.26.">; 3990def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>, Flags<[CoreOption, LinkOption]>; 3991def ld_path_EQ : Joined<["--"], "ld-path=">, Group<Link_Group>; 3992 3993defm align_labels : BooleanFFlag<"align-labels">, Group<clang_ignored_gcc_optimization_f_Group>; 3994def falign_labels_EQ : Joined<["-"], "falign-labels=">, Group<clang_ignored_gcc_optimization_f_Group>; 3995defm align_loops : BooleanFFlag<"align-loops">, Group<clang_ignored_gcc_optimization_f_Group>; 3996def falign_loops_EQ : Joined<["-"], "falign-loops=">, Group<clang_ignored_gcc_optimization_f_Group>; 3997defm align_jumps : BooleanFFlag<"align-jumps">, Group<clang_ignored_gcc_optimization_f_Group>; 3998def falign_jumps_EQ : Joined<["-"], "falign-jumps=">, Group<clang_ignored_gcc_optimization_f_Group>; 3999 4000// FIXME: This option should be supported and wired up to our diognostics, but 4001// ignore it for now to avoid breaking builds that use it. 4002def fdiagnostics_show_location_EQ : Joined<["-"], "fdiagnostics-show-location=">, Group<clang_ignored_f_Group>; 4003 4004defm fcheck_new : BooleanFFlag<"check-new">, Group<clang_ignored_f_Group>; 4005defm caller_saves : BooleanFFlag<"caller-saves">, Group<clang_ignored_gcc_optimization_f_Group>; 4006defm reorder_blocks : BooleanFFlag<"reorder-blocks">, Group<clang_ignored_gcc_optimization_f_Group>; 4007defm branch_count_reg : BooleanFFlag<"branch-count-reg">, Group<clang_ignored_gcc_optimization_f_Group>; 4008defm default_inline : BooleanFFlag<"default-inline">, Group<clang_ignored_gcc_optimization_f_Group>; 4009defm fat_lto_objects : BooleanFFlag<"fat-lto-objects">, Group<clang_ignored_gcc_optimization_f_Group>; 4010defm float_store : BooleanFFlag<"float-store">, Group<clang_ignored_gcc_optimization_f_Group>; 4011defm friend_injection : BooleanFFlag<"friend-injection">, Group<clang_ignored_f_Group>; 4012defm function_attribute_list : BooleanFFlag<"function-attribute-list">, Group<clang_ignored_f_Group>; 4013defm gcse : BooleanFFlag<"gcse">, Group<clang_ignored_gcc_optimization_f_Group>; 4014defm gcse_after_reload: BooleanFFlag<"gcse-after-reload">, Group<clang_ignored_gcc_optimization_f_Group>; 4015defm gcse_las: BooleanFFlag<"gcse-las">, Group<clang_ignored_gcc_optimization_f_Group>; 4016defm gcse_sm: BooleanFFlag<"gcse-sm">, Group<clang_ignored_gcc_optimization_f_Group>; 4017defm gnu : BooleanFFlag<"gnu">, Group<clang_ignored_f_Group>; 4018defm implicit_templates : BooleanFFlag<"implicit-templates">, Group<clang_ignored_f_Group>; 4019defm implement_inlines : BooleanFFlag<"implement-inlines">, Group<clang_ignored_f_Group>; 4020defm merge_constants : BooleanFFlag<"merge-constants">, Group<clang_ignored_gcc_optimization_f_Group>; 4021defm modulo_sched : BooleanFFlag<"modulo-sched">, Group<clang_ignored_gcc_optimization_f_Group>; 4022defm modulo_sched_allow_regmoves : BooleanFFlag<"modulo-sched-allow-regmoves">, 4023 Group<clang_ignored_gcc_optimization_f_Group>; 4024defm inline_functions_called_once : BooleanFFlag<"inline-functions-called-once">, 4025 Group<clang_ignored_gcc_optimization_f_Group>; 4026def finline_limit_EQ : Joined<["-"], "finline-limit=">, Group<clang_ignored_gcc_optimization_f_Group>; 4027defm finline_limit : BooleanFFlag<"inline-limit">, Group<clang_ignored_gcc_optimization_f_Group>; 4028defm inline_small_functions : BooleanFFlag<"inline-small-functions">, 4029 Group<clang_ignored_gcc_optimization_f_Group>; 4030defm ipa_cp : BooleanFFlag<"ipa-cp">, 4031 Group<clang_ignored_gcc_optimization_f_Group>; 4032defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>; 4033defm semantic_interposition : BoolFOption<"semantic-interposition", 4034 LangOpts<"SemanticInterposition">, DefaultFalse, 4035 PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>>; 4036defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>; 4037defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>; 4038defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>; 4039defm prefetch_loop_arrays : BooleanFFlag<"prefetch-loop-arrays">, Group<clang_ignored_gcc_optimization_f_Group>; 4040defm printf : BooleanFFlag<"printf">, Group<clang_ignored_f_Group>; 4041defm profile : BooleanFFlag<"profile">, Group<clang_ignored_f_Group>; 4042defm profile_correction : BooleanFFlag<"profile-correction">, Group<clang_ignored_gcc_optimization_f_Group>; 4043defm profile_generate_sampling : BooleanFFlag<"profile-generate-sampling">, Group<clang_ignored_f_Group>; 4044defm profile_reusedist : BooleanFFlag<"profile-reusedist">, Group<clang_ignored_f_Group>; 4045defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_optimization_f_Group>; 4046defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>; 4047defm rename_registers : BooleanFFlag<"rename-registers">, Group<clang_ignored_gcc_optimization_f_Group>; 4048defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>; 4049defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_gcc_optimization_f_Group>; 4050defm schedule_insns2 : BooleanFFlag<"schedule-insns2">, Group<clang_ignored_gcc_optimization_f_Group>; 4051defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>; 4052defm signaling_nans : BooleanFFlag<"signaling-nans">, Group<clang_ignored_gcc_optimization_f_Group>; 4053defm single_precision_constant : BooleanFFlag<"single-precision-constant">, 4054 Group<clang_ignored_gcc_optimization_f_Group>; 4055defm spec_constr_count : BooleanFFlag<"spec-constr-count">, Group<clang_ignored_f_Group>; 4056defm stack_check : BooleanFFlag<"stack-check">, Group<clang_ignored_f_Group>; 4057defm strength_reduce : 4058 BooleanFFlag<"strength-reduce">, Group<clang_ignored_gcc_optimization_f_Group>; 4059defm tls_model : BooleanFFlag<"tls-model">, Group<clang_ignored_f_Group>; 4060defm tracer : BooleanFFlag<"tracer">, Group<clang_ignored_gcc_optimization_f_Group>; 4061defm tree_dce : BooleanFFlag<"tree-dce">, Group<clang_ignored_gcc_optimization_f_Group>; 4062defm tree_salias : BooleanFFlag<"tree-salias">, Group<clang_ignored_f_Group>; 4063defm tree_ter : BooleanFFlag<"tree-ter">, Group<clang_ignored_gcc_optimization_f_Group>; 4064defm tree_vectorizer_verbose : BooleanFFlag<"tree-vectorizer-verbose">, Group<clang_ignored_f_Group>; 4065defm tree_vrp : BooleanFFlag<"tree-vrp">, Group<clang_ignored_gcc_optimization_f_Group>; 4066defm unroll_all_loops : BooleanFFlag<"unroll-all-loops">, Group<clang_ignored_gcc_optimization_f_Group>; 4067defm unsafe_loop_optimizations : BooleanFFlag<"unsafe-loop-optimizations">, 4068 Group<clang_ignored_gcc_optimization_f_Group>; 4069defm unswitch_loops : BooleanFFlag<"unswitch-loops">, Group<clang_ignored_gcc_optimization_f_Group>; 4070defm use_linker_plugin : BooleanFFlag<"use-linker-plugin">, Group<clang_ignored_gcc_optimization_f_Group>; 4071defm vect_cost_model : BooleanFFlag<"vect-cost-model">, Group<clang_ignored_gcc_optimization_f_Group>; 4072defm variable_expansion_in_unroller : BooleanFFlag<"variable-expansion-in-unroller">, 4073 Group<clang_ignored_gcc_optimization_f_Group>; 4074defm web : BooleanFFlag<"web">, Group<clang_ignored_gcc_optimization_f_Group>; 4075defm whole_program : BooleanFFlag<"whole-program">, Group<clang_ignored_gcc_optimization_f_Group>; 4076defm devirtualize : BooleanFFlag<"devirtualize">, Group<clang_ignored_gcc_optimization_f_Group>; 4077defm devirtualize_speculatively : BooleanFFlag<"devirtualize-speculatively">, 4078 Group<clang_ignored_gcc_optimization_f_Group>; 4079 4080// Generic gfortran options. 4081def A_DASH : Joined<["-"], "A-">, Group<gfortran_Group>; 4082def J : JoinedOrSeparate<["-"], "J">, Flags<[RenderJoined]>, Group<gfortran_Group>; 4083def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>; 4084def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>; 4085def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>; 4086 4087// "f" options with values for gfortran. 4088def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>; 4089def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>; 4090def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>; 4091def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>; 4092def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<gfortran_Group>; 4093def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>; 4094def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>; 4095def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>; 4096def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>; 4097def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>; 4098def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>; 4099def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>; 4100def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>; 4101def fmax_stack_var_size_EQ : Joined<["-"], "fmax-stack-var-size=">, Group<gfortran_Group>; 4102def fmax_subrecord_length_EQ : Joined<["-"], "fmax-subrecord-length=">, Group<gfortran_Group>; 4103def frecord_marker_EQ : Joined<["-"], "frecord-marker=">, Group<gfortran_Group>; 4104 4105// "f" flags for gfortran. 4106defm aggressive_function_elimination : BooleanFFlag<"aggressive-function-elimination">, Group<gfortran_Group>; 4107defm align_commons : BooleanFFlag<"align-commons">, Group<gfortran_Group>; 4108defm all_intrinsics : BooleanFFlag<"all-intrinsics">, Group<gfortran_Group>; 4109defm automatic : BooleanFFlag<"automatic">, Group<gfortran_Group>; 4110defm backslash : BooleanFFlag<"backslash">, Group<gfortran_Group>; 4111defm backtrace : BooleanFFlag<"backtrace">, Group<gfortran_Group>; 4112defm bounds_check : BooleanFFlag<"bounds-check">, Group<gfortran_Group>; 4113defm check_array_temporaries : BooleanFFlag<"check-array-temporaries">, Group<gfortran_Group>; 4114defm cray_pointer : BooleanFFlag<"cray-pointer">, Group<gfortran_Group>; 4115defm d_lines_as_code : BooleanFFlag<"d-lines-as-code">, Group<gfortran_Group>; 4116defm d_lines_as_comments : BooleanFFlag<"d-lines-as-comments">, Group<gfortran_Group>; 4117defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>; 4118defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>; 4119defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>; 4120defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>; 4121defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>; 4122defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>; 4123defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>; 4124defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>; 4125defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>; 4126defm fixed_form : BooleanFFlag<"fixed-form">, Group<gfortran_Group>; 4127defm free_form : BooleanFFlag<"free-form">, Group<gfortran_Group>; 4128defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>; 4129defm implicit_none : BooleanFFlag<"implicit-none">, Group<gfortran_Group>; 4130defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>; 4131defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>; 4132defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>; 4133defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>; 4134defm module_private : BooleanFFlag<"module-private">, Group<gfortran_Group>; 4135defm pack_derived : BooleanFFlag<"pack-derived">, Group<gfortran_Group>; 4136defm protect_parens : BooleanFFlag<"protect-parens">, Group<gfortran_Group>; 4137defm range_check : BooleanFFlag<"range-check">, Group<gfortran_Group>; 4138defm real_4_real_10 : BooleanFFlag<"real-4-real-10">, Group<gfortran_Group>; 4139defm real_4_real_16 : BooleanFFlag<"real-4-real-16">, Group<gfortran_Group>; 4140defm real_4_real_8 : BooleanFFlag<"real-4-real-8">, Group<gfortran_Group>; 4141defm real_8_real_10 : BooleanFFlag<"real-8-real-10">, Group<gfortran_Group>; 4142defm real_8_real_16 : BooleanFFlag<"real-8-real-16">, Group<gfortran_Group>; 4143defm real_8_real_4 : BooleanFFlag<"real-8-real-4">, Group<gfortran_Group>; 4144defm realloc_lhs : BooleanFFlag<"realloc-lhs">, Group<gfortran_Group>; 4145defm recursive : BooleanFFlag<"recursive">, Group<gfortran_Group>; 4146defm repack_arrays : BooleanFFlag<"repack-arrays">, Group<gfortran_Group>; 4147defm second_underscore : BooleanFFlag<"second-underscore">, Group<gfortran_Group>; 4148defm sign_zero : BooleanFFlag<"sign-zero">, Group<gfortran_Group>; 4149defm stack_arrays : BooleanFFlag<"stack-arrays">, Group<gfortran_Group>; 4150defm underscoring : BooleanFFlag<"underscoring">, Group<gfortran_Group>; 4151defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>; 4152 4153// C++ SYCL options 4154defm sycl : BoolOption<"f", "sycl", 4155 LangOpts<"SYCL">, DefaultFalse, 4156 PosFlag<SetTrue, [CC1Option], "Enable">, NegFlag<SetFalse, [], "Disable">, 4157 BothFlags<[CoreOption], " SYCL kernels compilation for device">>, 4158 Group<sycl_Group>; 4159def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>, 4160 HelpText<"SYCL language standard to compile for.">, Values<"2017,121,1.2.1,sycl-1.2.1">, 4161 NormalizedValues<["SYCL_2017", "SYCL_2017", "SYCL_2017", "SYCL_2017"]>, NormalizedValuesScope<"LangOptions">, 4162 MarshallingInfoString<LangOpts<"SYCLVersion">, "SYCL_None">, ShouldParseIf<fsycl.KeyPath>, AutoNormalizeEnum; 4163 4164//===----------------------------------------------------------------------===// 4165// FlangOption and FC1 Options 4166//===----------------------------------------------------------------------===// 4167def test_io : Flag<["-"], "test-io">, Flags<[HelpHidden, FlangOption, FC1Option, FlangOnlyOption]>, Group<Action_Group>, 4168 HelpText<"Run the InputOuputTest action. Use for development and testing only.">; 4169 4170//===----------------------------------------------------------------------===// 4171// CC1 Options 4172//===----------------------------------------------------------------------===// 4173 4174let Flags = [CC1Option, NoDriverOption] in { 4175 4176//===----------------------------------------------------------------------===// 4177// Target Options 4178//===----------------------------------------------------------------------===// 4179 4180let Flags = [CC1Option, CC1AsOption, NoDriverOption] in { 4181 4182def target_cpu : Separate<["-"], "target-cpu">, 4183 HelpText<"Target a specific cpu type">, 4184 MarshallingInfoString<TargetOpts<"CPU">>; 4185def tune_cpu : Separate<["-"], "tune-cpu">, 4186 HelpText<"Tune for a specific cpu type">, 4187 MarshallingInfoString<TargetOpts<"TuneCPU">>; 4188def target_feature : Separate<["-"], "target-feature">, 4189 HelpText<"Target specific attributes">, 4190 MarshallingInfoStringVector<TargetOpts<"FeaturesAsWritten">>; 4191def triple : Separate<["-"], "triple">, 4192 HelpText<"Specify target triple (e.g. i686-apple-darwin9)">, 4193 MarshallingInfoString<TargetOpts<"Triple">, "llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple())">, 4194 AlwaysEmit, Normalizer<"normalizeTriple">; 4195def target_abi : Separate<["-"], "target-abi">, 4196 HelpText<"Target a particular ABI type">, 4197 MarshallingInfoString<TargetOpts<"ABI">>; 4198def target_sdk_version_EQ : Joined<["-"], "target-sdk-version=">, 4199 HelpText<"The version of target SDK used for compilation">; 4200 4201} 4202 4203def target_linker_version : Separate<["-"], "target-linker-version">, 4204 HelpText<"Target linker version">, 4205 MarshallingInfoString<TargetOpts<"LinkerVersion">>; 4206def triple_EQ : Joined<["-"], "triple=">, Alias<triple>; 4207def mfpmath : Separate<["-"], "mfpmath">, 4208 HelpText<"Which unit to use for fp math">, 4209 MarshallingInfoString<TargetOpts<"FPMath">>; 4210 4211def fpadding_on_unsigned_fixed_point : Flag<["-"], "fpadding-on-unsigned-fixed-point">, 4212 HelpText<"Force each unsigned fixed point type to have an extra bit of padding to align their scales with those of signed fixed point types">; 4213def fno_padding_on_unsigned_fixed_point : Flag<["-"], "fno-padding-on-unsigned-fixed-point">; 4214 4215//===----------------------------------------------------------------------===// 4216// Analyzer Options 4217//===----------------------------------------------------------------------===// 4218 4219def analysis_UnoptimizedCFG : Flag<["-"], "unoptimized-cfg">, 4220 HelpText<"Generate unoptimized CFGs for all analyses">, 4221 MarshallingInfoFlag<AnalyzerOpts<"UnoptimizedCFG">>; 4222def analysis_CFGAddImplicitDtors : Flag<["-"], "cfg-add-implicit-dtors">, 4223 HelpText<"Add C++ implicit destructors to CFGs for all analyses">; 4224 4225def analyzer_store : Separate<["-"], "analyzer-store">, 4226 HelpText<"Source Code Analysis - Abstract Memory Store Models">; 4227def analyzer_store_EQ : Joined<["-"], "analyzer-store=">, Alias<analyzer_store>; 4228 4229def analyzer_constraints : Separate<["-"], "analyzer-constraints">, 4230 HelpText<"Source Code Analysis - Symbolic Constraint Engines">; 4231def analyzer_constraints_EQ : Joined<["-"], "analyzer-constraints=">, 4232 Alias<analyzer_constraints>; 4233 4234def analyzer_output : Separate<["-"], "analyzer-output">, 4235 HelpText<"Source Code Analysis - Output Options">; 4236def analyzer_output_EQ : Joined<["-"], "analyzer-output=">, 4237 Alias<analyzer_output>; 4238 4239def analyzer_purge : Separate<["-"], "analyzer-purge">, 4240 HelpText<"Source Code Analysis - Dead Symbol Removal Frequency">; 4241def analyzer_purge_EQ : Joined<["-"], "analyzer-purge=">, Alias<analyzer_purge>; 4242 4243def analyzer_opt_analyze_headers : Flag<["-"], "analyzer-opt-analyze-headers">, 4244 HelpText<"Force the static analyzer to analyze functions defined in header files">, 4245 MarshallingInfoFlag<AnalyzerOpts<"AnalyzeAll">>; 4246def analyzer_opt_analyze_nested_blocks : Flag<["-"], "analyzer-opt-analyze-nested-blocks">, 4247 HelpText<"Analyze the definitions of blocks in addition to functions">, 4248 MarshallingInfoFlag<AnalyzerOpts<"AnalyzeNestedBlocks">>; 4249def analyzer_display_progress : Flag<["-"], "analyzer-display-progress">, 4250 HelpText<"Emit verbose output about the analyzer's progress">, 4251 MarshallingInfoFlag<AnalyzerOpts<"AnalyzerDisplayProgress">>; 4252def analyze_function : Separate<["-"], "analyze-function">, 4253 HelpText<"Run analysis on specific function (for C++ include parameters in name)">, 4254 MarshallingInfoString<AnalyzerOpts<"AnalyzeSpecificFunction">>; 4255def analyze_function_EQ : Joined<["-"], "analyze-function=">, Alias<analyze_function>; 4256def trim_egraph : Flag<["-"], "trim-egraph">, 4257 HelpText<"Only show error-related paths in the analysis graph">, 4258 MarshallingInfoFlag<AnalyzerOpts<"TrimGraph">>; 4259def analyzer_viz_egraph_graphviz : Flag<["-"], "analyzer-viz-egraph-graphviz">, 4260 HelpText<"Display exploded graph using GraphViz">, 4261 MarshallingInfoFlag<AnalyzerOpts<"visualizeExplodedGraphWithGraphViz">>; 4262def analyzer_dump_egraph : Separate<["-"], "analyzer-dump-egraph">, 4263 HelpText<"Dump exploded graph to the specified file">, 4264 MarshallingInfoString<AnalyzerOpts<"DumpExplodedGraphTo">>; 4265def analyzer_dump_egraph_EQ : Joined<["-"], "analyzer-dump-egraph=">, Alias<analyzer_dump_egraph>; 4266 4267def analyzer_inline_max_stack_depth : Separate<["-"], "analyzer-inline-max-stack-depth">, 4268 HelpText<"Bound on stack depth while inlining (4 by default)">, 4269 // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls). 4270 MarshallingInfoStringInt<AnalyzerOpts<"InlineMaxStackDepth">, "5">; 4271def analyzer_inline_max_stack_depth_EQ : Joined<["-"], "analyzer-inline-max-stack-depth=">, 4272 Alias<analyzer_inline_max_stack_depth>; 4273 4274def analyzer_inlining_mode : Separate<["-"], "analyzer-inlining-mode">, 4275 HelpText<"Specify the function selection heuristic used during inlining">; 4276def analyzer_inlining_mode_EQ : Joined<["-"], "analyzer-inlining-mode=">, Alias<analyzer_inlining_mode>; 4277 4278def analyzer_disable_retry_exhausted : Flag<["-"], "analyzer-disable-retry-exhausted">, 4279 HelpText<"Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)">, 4280 MarshallingInfoFlag<AnalyzerOpts<"NoRetryExhausted">>; 4281 4282def analyzer_max_loop : Separate<["-"], "analyzer-max-loop">, 4283 HelpText<"The maximum number of times the analyzer will go through a loop">, 4284 MarshallingInfoStringInt<AnalyzerOpts<"maxBlockVisitOnPath">, "4">; 4285def analyzer_stats : Flag<["-"], "analyzer-stats">, 4286 HelpText<"Print internal analyzer statistics.">, 4287 MarshallingInfoFlag<AnalyzerOpts<"PrintStats">>; 4288 4289def analyzer_checker : Separate<["-"], "analyzer-checker">, 4290 HelpText<"Choose analyzer checkers to enable">, 4291 ValuesCode<[{ 4292 const char *Values = 4293 #define GET_CHECKERS 4294 #define CHECKER(FULLNAME, CLASS, HT, DOC_URI, IS_HIDDEN) FULLNAME "," 4295 #include "clang/StaticAnalyzer/Checkers/Checkers.inc" 4296 #undef GET_CHECKERS 4297 #define GET_PACKAGES 4298 #define PACKAGE(FULLNAME) FULLNAME "," 4299 #include "clang/StaticAnalyzer/Checkers/Checkers.inc" 4300 #undef GET_PACKAGES 4301 ; 4302 }]>; 4303def analyzer_checker_EQ : Joined<["-"], "analyzer-checker=">, 4304 Alias<analyzer_checker>; 4305 4306def analyzer_disable_checker : Separate<["-"], "analyzer-disable-checker">, 4307 HelpText<"Choose analyzer checkers to disable">; 4308def analyzer_disable_checker_EQ : Joined<["-"], "analyzer-disable-checker=">, 4309 Alias<analyzer_disable_checker>; 4310 4311def analyzer_disable_all_checks : Flag<["-"], "analyzer-disable-all-checks">, 4312 HelpText<"Disable all static analyzer checks">, 4313 MarshallingInfoFlag<AnalyzerOpts<"DisableAllCheckers">>; 4314 4315def analyzer_checker_help : Flag<["-"], "analyzer-checker-help">, 4316 HelpText<"Display the list of analyzer checkers that are available">, 4317 MarshallingInfoFlag<AnalyzerOpts<"ShowCheckerHelp">>; 4318 4319def analyzer_checker_help_alpha : Flag<["-"], "analyzer-checker-help-alpha">, 4320 HelpText<"Display the list of in development analyzer checkers. These " 4321 "are NOT considered safe, they are unstable and will emit incorrect " 4322 "reports. Enable ONLY FOR DEVELOPMENT purposes">, 4323 MarshallingInfoFlag<AnalyzerOpts<"ShowCheckerHelpAlpha">>; 4324 4325def analyzer_checker_help_developer : Flag<["-"], "analyzer-checker-help-developer">, 4326 HelpText<"Display the list of developer-only checkers such as modeling " 4327 "and debug checkers">, 4328 MarshallingInfoFlag<AnalyzerOpts<"ShowCheckerHelpDeveloper">>; 4329 4330def analyzer_config_help : Flag<["-"], "analyzer-config-help">, 4331 HelpText<"Display the list of -analyzer-config options. These are meant for " 4332 "development purposes only!">, 4333 MarshallingInfoFlag<AnalyzerOpts<"ShowConfigOptionsList">>; 4334 4335def analyzer_list_enabled_checkers : Flag<["-"], "analyzer-list-enabled-checkers">, 4336 HelpText<"Display the list of enabled analyzer checkers">, 4337 MarshallingInfoFlag<AnalyzerOpts<"ShowEnabledCheckerList">>; 4338 4339def analyzer_config : Separate<["-"], "analyzer-config">, 4340 HelpText<"Choose analyzer options to enable">; 4341 4342def analyzer_checker_option_help : Flag<["-"], "analyzer-checker-option-help">, 4343 HelpText<"Display the list of checker and package options">, 4344 MarshallingInfoFlag<AnalyzerOpts<"ShowCheckerOptionList">>; 4345 4346def analyzer_checker_option_help_alpha : Flag<["-"], "analyzer-checker-option-help-alpha">, 4347 HelpText<"Display the list of in development checker and package options. " 4348 "These are NOT considered safe, they are unstable and will emit " 4349 "incorrect reports. Enable ONLY FOR DEVELOPMENT purposes">, 4350 MarshallingInfoFlag<AnalyzerOpts<"ShowCheckerOptionAlphaList">>; 4351 4352def analyzer_checker_option_help_developer : Flag<["-"], "analyzer-checker-option-help-developer">, 4353 HelpText<"Display the list of checker and package options meant for " 4354 "development purposes only">, 4355 MarshallingInfoFlag<AnalyzerOpts<"ShowCheckerOptionDeveloperList">>; 4356 4357def analyzer_config_compatibility_mode : Separate<["-"], "analyzer-config-compatibility-mode">, 4358 HelpText<"Don't emit errors on invalid analyzer-config inputs">, 4359 Values<"true,false">, NormalizedValues<[[{false}], [{true}]]>, 4360 MarshallingInfoString<AnalyzerOpts<"ShouldEmitErrorsOnInvalidConfigValue">, [{true}]>, 4361 AutoNormalizeEnum; 4362 4363def analyzer_config_compatibility_mode_EQ : Joined<["-"], "analyzer-config-compatibility-mode=">, 4364 Alias<analyzer_config_compatibility_mode>; 4365 4366def analyzer_werror : Flag<["-"], "analyzer-werror">, 4367 HelpText<"Emit analyzer results as errors rather than warnings">, 4368 MarshallingInfoFlag<AnalyzerOpts<"AnalyzerWerror">>; 4369 4370//===----------------------------------------------------------------------===// 4371// Migrator Options 4372//===----------------------------------------------------------------------===// 4373def migrator_no_nsalloc_error : Flag<["-"], "no-ns-alloc-error">, 4374 HelpText<"Do not error on use of NSAllocateCollectable/NSReallocateCollectable">, 4375 MarshallingInfoFlag<MigratorOpts<"NoNSAllocReallocError">>; 4376 4377def migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">, 4378 HelpText<"Do not remove finalize method in gc mode">, 4379 MarshallingInfoFlag<MigratorOpts<"NoFinalizeRemoval">>; 4380 4381//===----------------------------------------------------------------------===// 4382// CodeGen Options 4383//===----------------------------------------------------------------------===// 4384 4385let Flags = [CC1Option, CC1AsOption, NoDriverOption] in { 4386def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">, 4387 Values<"line-tables-only,line-directives-only,constructor,limited,standalone,unused-types">, 4388 NormalizedValuesScope<"codegenoptions">, 4389 NormalizedValues<["DebugLineTablesOnly", "DebugDirectivesOnly", "DebugInfoConstructor", 4390 "LimitedDebugInfo", "FullDebugInfo", "UnusedTypeInfo"]>, 4391 MarshallingInfoString<CodeGenOpts<"DebugInfo">, "NoDebugInfo">, AutoNormalizeEnum; 4392def debug_info_macro : Flag<["-"], "debug-info-macro">, 4393 HelpText<"Emit macro debug information">, 4394 MarshallingInfoFlag<CodeGenOpts<"MacroDebugInfo">>; 4395def default_function_attr : Separate<["-"], "default-function-attr">, 4396 HelpText<"Apply given attribute to all functions">, 4397 MarshallingInfoStringVector<CodeGenOpts<"DefaultFunctionAttrs">>; 4398def dwarf_version_EQ : Joined<["-"], "dwarf-version=">, 4399 MarshallingInfoStringInt<CodeGenOpts<"DwarfVersion">>; 4400def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">, 4401 Values<"gdb,lldb,sce">, 4402 NormalizedValuesScope<"llvm::DebuggerKind">, NormalizedValues<["GDB", "LLDB", "SCE"]>, 4403 MarshallingInfoString<CodeGenOpts<"DebuggerTuning">, "Default">, AutoNormalizeEnum; 4404def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">, 4405 HelpText<"The string to embed in the Dwarf debug flags record.">, 4406 MarshallingInfoString<CodeGenOpts<"DwarfDebugFlags">>; 4407def record_command_line : Separate<["-"], "record-command-line">, 4408 HelpText<"The string to embed in the .LLVM.command.line section.">, 4409 MarshallingInfoString<CodeGenOpts<"RecordCommandLine">>; 4410def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">, 4411 HelpText<"DWARF debug sections compression type">, Values<"none,zlib,zlib-gnu">, 4412 NormalizedValuesScope<"llvm::DebugCompressionType">, NormalizedValues<["None", "Z", "GNU"]>, 4413 MarshallingInfoString<CodeGenOpts<"CompressDebugSections">, "None">, AutoNormalizeEnum; 4414def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">, 4415 Alias<compress_debug_sections_EQ>, AliasArgs<["zlib"]>; 4416def mno_exec_stack : Flag<["-"], "mnoexecstack">, 4417 HelpText<"Mark the file as not needing an executable stack">, 4418 MarshallingInfoFlag<CodeGenOpts<"NoExecStack">>; 4419def massembler_no_warn : Flag<["-"], "massembler-no-warn">, 4420 HelpText<"Make assembler not emit warnings">, 4421 MarshallingInfoFlag<CodeGenOpts<"NoWarn">>; 4422def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">, 4423 HelpText<"Make assembler warnings fatal">, 4424 MarshallingInfoFlag<CodeGenOpts<"FatalWarnings">>; 4425def mrelax_relocations : Flag<["--"], "mrelax-relocations">, 4426 HelpText<"Use relaxable elf relocations">, 4427 MarshallingInfoFlag<CodeGenOpts<"RelaxELFRelocations">>; 4428def msave_temp_labels : Flag<["-"], "msave-temp-labels">, 4429 HelpText<"Save temporary labels in the symbol table. " 4430 "Note this may change .s semantics and shouldn't generally be used " 4431 "on compiler-generated code.">, 4432 MarshallingInfoFlag<CodeGenOpts<"SaveTempLabels">>; 4433def mrelocation_model : Separate<["-"], "mrelocation-model">, 4434 HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">, 4435 NormalizedValuesScope<"llvm::Reloc">, 4436 NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>, 4437 MarshallingInfoString<CodeGenOpts<"RelocationModel">, "PIC_">, 4438 AutoNormalizeEnum; 4439def fno_math_builtin : Flag<["-"], "fno-math-builtin">, 4440 HelpText<"Disable implicit builtin knowledge of math functions">, 4441 MarshallingInfoFlag<LangOpts<"NoMathBuiltin">>; 4442def fuse_ctor_homing: Flag<["-"], "fuse-ctor-homing">, 4443 HelpText<"Use constructor homing if we are using limited debug info already">; 4444} 4445 4446def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">, 4447 HelpText<"Don't run the LLVM IR verifier pass">, 4448 MarshallingInfoNegativeFlag<CodeGenOpts<"VerifyModule">>; 4449def disable_llvm_passes : Flag<["-"], "disable-llvm-passes">, 4450 HelpText<"Use together with -emit-llvm to get pristine LLVM IR from the " 4451 "frontend by not running any LLVM passes at all">, 4452 MarshallingInfoFlag<CodeGenOpts<"DisableLLVMPasses">>; 4453def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">, 4454 Alias<disable_llvm_passes>; 4455def disable_lifetimemarkers : Flag<["-"], "disable-lifetime-markers">, 4456 HelpText<"Disable lifetime-markers emission even when optimizations are " 4457 "enabled">, 4458 MarshallingInfoFlag<CodeGenOpts<"DisableLifetimeMarkers">>; 4459def disable_O0_optnone : Flag<["-"], "disable-O0-optnone">, 4460 HelpText<"Disable adding the optnone attribute to functions at O0">, 4461 MarshallingInfoFlag<CodeGenOpts<"DisableO0ImplyOptNone">>; 4462def disable_red_zone : Flag<["-"], "disable-red-zone">, 4463 HelpText<"Do not emit code that uses the red zone.">, 4464 MarshallingInfoFlag<CodeGenOpts<"DisableRedZone">>; 4465def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">, 4466 HelpText<"Generate debug info with external references to clang modules" 4467 " or precompiled headers">, 4468 MarshallingInfoFlag<CodeGenOpts<"DebugTypeExtRefs">>; 4469def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">, 4470 HelpText<"Generate explicit import from anonymous namespace to containing" 4471 " scope">, 4472 MarshallingInfoFlag<CodeGenOpts<"DebugExplicitImport">>; 4473def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">, 4474 HelpText<"Emit complete descriptions of template parameters in forward" 4475 " declarations">, 4476 MarshallingInfoFlag<CodeGenOpts<"DebugFwdTemplateParams">>; 4477def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">, 4478 HelpText<"Emit an error if a C++ static local initializer would need a guard variable">, 4479 MarshallingInfoFlag<CodeGenOpts<"ForbidGuardVariables">>; 4480def no_implicit_float : Flag<["-"], "no-implicit-float">, 4481 HelpText<"Don't generate implicit floating point instructions">, 4482 MarshallingInfoFlag<CodeGenOpts<"NoImplicitFloat">>; 4483def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">, 4484 HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">, 4485 MarshallingInfoFlag<LangOpts<"DumpVTableLayouts">>; 4486def fmerge_functions : Flag<["-"], "fmerge-functions">, 4487 HelpText<"Permit merging of identical functions when optimizing.">, 4488 MarshallingInfoFlag<CodeGenOpts<"MergeFunctions">>; 4489def coverage_data_file : Separate<["-"], "coverage-data-file">, 4490 HelpText<"Emit coverage data to this filename.">, 4491 MarshallingInfoString<CodeGenOpts<"CoverageDataFile">>, 4492 ShouldParseIf<!strconcat(fprofile_arcs.KeyPath, "||", ftest_coverage.KeyPath)>; 4493def coverage_data_file_EQ : Joined<["-"], "coverage-data-file=">, 4494 Alias<coverage_data_file>; 4495def coverage_notes_file : Separate<["-"], "coverage-notes-file">, 4496 HelpText<"Emit coverage notes to this filename.">, 4497 MarshallingInfoString<CodeGenOpts<"CoverageNotesFile">>, 4498 ShouldParseIf<!strconcat(fprofile_arcs.KeyPath, "||", ftest_coverage.KeyPath)>; 4499def coverage_notes_file_EQ : Joined<["-"], "coverage-notes-file=">, 4500 Alias<coverage_notes_file>; 4501def coverage_version_EQ : Joined<["-"], "coverage-version=">, 4502 HelpText<"Four-byte version string for gcov files.">; 4503def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">, 4504 HelpText<"Dump the coverage mapping records, for testing">, 4505 MarshallingInfoFlag<CodeGenOpts<"DumpCoverageMapping">>; 4506def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">, 4507 HelpText<"Use register sized accesses to bit-fields, when possible.">, 4508 MarshallingInfoFlag<CodeGenOpts<"UseRegisterSizedBitfieldAccess">>; 4509def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">, 4510 HelpText<"Turn off Type Based Alias Analysis">, 4511 MarshallingInfoFlag<CodeGenOpts<"RelaxedAliasing">>; 4512def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">, 4513 HelpText<"Turn off struct-path aware Type Based Alias Analysis">, 4514 MarshallingInfoNegativeFlag<CodeGenOpts<"StructPathTBAA">>; 4515def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">, 4516 HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">; 4517def mdebug_pass : Separate<["-"], "mdebug-pass">, 4518 HelpText<"Enable additional debug output">, 4519 MarshallingInfoString<CodeGenOpts<"DebugPass">>; 4520def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">, 4521 HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">, 4522 NormalizedValuesScope<"CodeGenOptions::FramePointerKind">, NormalizedValues<["All", "NonLeaf", "None"]>, 4523 MarshallingInfoString<CodeGenOpts<"FramePointer">, "None">, AutoNormalizeEnum; 4524def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">, 4525 HelpText<"Disable tail call optimization, keeping the call stack accurate">, 4526 MarshallingInfoFlag<CodeGenOpts<"DisableTailCalls">>; 4527def menable_no_infinities : Flag<["-"], "menable-no-infs">, 4528 HelpText<"Allow optimization to assume there are no infinities.">, 4529 MarshallingInfoFlag<LangOpts<"NoHonorInfs">>, ImpliedByAnyOf<[ffinite_math_only.KeyPath]>; 4530def menable_no_nans : Flag<["-"], "menable-no-nans">, 4531 HelpText<"Allow optimization to assume there are no NaNs.">, 4532 MarshallingInfoFlag<LangOpts<"NoHonorNaNs">>, ImpliedByAnyOf<[ffinite_math_only.KeyPath]>; 4533def mreassociate : Flag<["-"], "mreassociate">, 4534 HelpText<"Allow reassociation transformations for floating-point instructions">, 4535 MarshallingInfoFlag<LangOpts<"AllowFPReassoc">>, ImpliedByAnyOf<[menable_unsafe_fp_math.KeyPath]>; 4536def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">, 4537 HelpText<"Use IEEE 754 quadruple-precision for long double">, 4538 MarshallingInfoFlag<LangOpts<"PPCIEEELongDouble">>; 4539def mfloat_abi : Separate<["-"], "mfloat-abi">, 4540 HelpText<"The float ABI to use">, 4541 MarshallingInfoString<CodeGenOpts<"FloatABI">>; 4542def mtp : Separate<["-"], "mtp">, 4543 HelpText<"Mode for reading thread pointer">; 4544def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">, 4545 HelpText<"Limit float precision to the given value">, 4546 MarshallingInfoString<CodeGenOpts<"LimitFloatPrecision">>; 4547def split_stacks : Flag<["-"], "split-stacks">, 4548 HelpText<"Try to use a split stack if possible.">, 4549 MarshallingInfoFlag<CodeGenOpts<"EnableSegmentedStacks">>; 4550def mregparm : Separate<["-"], "mregparm">, 4551 HelpText<"Limit the number of registers available for integer arguments">, 4552 MarshallingInfoStringInt<CodeGenOpts<"NumRegisterParameters">>; 4553def msmall_data_limit : Separate<["-"], "msmall-data-limit">, 4554 HelpText<"Put global and static data smaller than the limit into a special section">, 4555 MarshallingInfoStringInt<CodeGenOpts<"SmallDataLimit">>; 4556def munwind_tables : Flag<["-"], "munwind-tables">, 4557 HelpText<"Generate unwinding tables for all functions">, 4558 MarshallingInfoFlag<CodeGenOpts<"UnwindTables">>; 4559def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">, 4560 HelpText<"Emit complete constructors and destructors as aliases when possible">, 4561 MarshallingInfoFlag<CodeGenOpts<"CXXCtorDtorAliases">>; 4562def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">, 4563 HelpText<"Link the given bitcode file before performing optimizations.">; 4564def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">, 4565 HelpText<"Link and internalize needed symbols from the given bitcode file " 4566 "before performing optimizations.">; 4567def mlink_cuda_bitcode : Separate<["-"], "mlink-cuda-bitcode">, 4568 Alias<mlink_builtin_bitcode>; 4569def vectorize_loops : Flag<["-"], "vectorize-loops">, 4570 HelpText<"Run the Loop vectorization passes">, 4571 MarshallingInfoFlag<CodeGenOpts<"VectorizeLoop">>; 4572def vectorize_slp : Flag<["-"], "vectorize-slp">, 4573 HelpText<"Run the SLP vectorization passes">, 4574 MarshallingInfoFlag<CodeGenOpts<"VectorizeSLP">>; 4575def dependent_lib : Joined<["--"], "dependent-lib=">, 4576 HelpText<"Add dependent library">, 4577 MarshallingInfoStringVector<CodeGenOpts<"DependentLibraries">>; 4578def linker_option : Joined<["--"], "linker-option=">, 4579 HelpText<"Add linker option">, 4580 MarshallingInfoStringVector<CodeGenOpts<"LinkerOptions">>; 4581def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">, 4582 HelpText<"Sanitizer coverage type">, 4583 MarshallingInfoStringInt<CodeGenOpts<"SanitizeCoverageType">>; 4584def fsanitize_coverage_indirect_calls 4585 : Flag<["-"], "fsanitize-coverage-indirect-calls">, 4586 HelpText<"Enable sanitizer coverage for indirect calls">, 4587 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageIndirectCalls">>; 4588def fsanitize_coverage_trace_bb 4589 : Flag<["-"], "fsanitize-coverage-trace-bb">, 4590 HelpText<"Enable basic block tracing in sanitizer coverage">, 4591 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceBB">>; 4592def fsanitize_coverage_trace_cmp 4593 : Flag<["-"], "fsanitize-coverage-trace-cmp">, 4594 HelpText<"Enable cmp instruction tracing in sanitizer coverage">, 4595 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceCmp">>; 4596def fsanitize_coverage_trace_div 4597 : Flag<["-"], "fsanitize-coverage-trace-div">, 4598 HelpText<"Enable div instruction tracing in sanitizer coverage">, 4599 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceDiv">>; 4600def fsanitize_coverage_trace_gep 4601 : Flag<["-"], "fsanitize-coverage-trace-gep">, 4602 HelpText<"Enable gep instruction tracing in sanitizer coverage">, 4603 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTraceGep">>; 4604def fsanitize_coverage_8bit_counters 4605 : Flag<["-"], "fsanitize-coverage-8bit-counters">, 4606 HelpText<"Enable frequency counters in sanitizer coverage">, 4607 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverage8bitCounters">>; 4608def fsanitize_coverage_inline_8bit_counters 4609 : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">, 4610 HelpText<"Enable inline 8-bit counters in sanitizer coverage">, 4611 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageInline8bitCounters">>; 4612def fsanitize_coverage_inline_bool_flag 4613 : Flag<["-"], "fsanitize-coverage-inline-bool-flag">, 4614 HelpText<"Enable inline bool flag in sanitizer coverage">, 4615 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageInlineBoolFlag">>; 4616def fsanitize_coverage_pc_table 4617 : Flag<["-"], "fsanitize-coverage-pc-table">, 4618 HelpText<"Create a table of coverage-instrumented PCs">, 4619 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoveragePCTable">>; 4620def fsanitize_coverage_trace_pc 4621 : Flag<["-"], "fsanitize-coverage-trace-pc">, 4622 HelpText<"Enable PC tracing in sanitizer coverage">, 4623 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTracePC">>; 4624def fsanitize_coverage_trace_pc_guard 4625 : Flag<["-"], "fsanitize-coverage-trace-pc-guard">, 4626 HelpText<"Enable PC tracing with guard in sanitizer coverage">, 4627 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageTracePCGuard">>; 4628def fsanitize_coverage_no_prune 4629 : Flag<["-"], "fsanitize-coverage-no-prune">, 4630 HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">, 4631 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageNoPrune">>; 4632def fsanitize_coverage_stack_depth 4633 : Flag<["-"], "fsanitize-coverage-stack-depth">, 4634 HelpText<"Enable max stack depth tracing">, 4635 MarshallingInfoFlag<CodeGenOpts<"SanitizeCoverageStackDepth">>; 4636def fpatchable_function_entry_offset_EQ 4637 : Joined<["-"], "fpatchable-function-entry-offset=">, MetaVarName<"<M>">, 4638 HelpText<"Generate M NOPs before function entry">, 4639 MarshallingInfoStringInt<CodeGenOpts<"PatchableFunctionEntryOffset">>; 4640def fprofile_instrument_EQ : Joined<["-"], "fprofile-instrument=">, 4641 HelpText<"Enable PGO instrumentation. The accepted value is clang, llvm, " 4642 "or none">, Values<"none,clang,llvm,csllvm">, 4643 NormalizedValuesScope<"CodeGenOptions">, 4644 NormalizedValues<["ProfileNone", "ProfileClangInstr", "ProfileIRInstr", "ProfileCSIRInstr"]>, 4645 MarshallingInfoString<CodeGenOpts<"ProfileInstr">, "ProfileNone">, AutoNormalizeEnum; 4646def fprofile_instrument_path_EQ : Joined<["-"], "fprofile-instrument-path=">, 4647 HelpText<"Generate instrumented code to collect execution counts into " 4648 "<file> (overridden by LLVM_PROFILE_FILE env var)">, 4649 MarshallingInfoString<CodeGenOpts<"InstrProfileOutput">>; 4650def fprofile_instrument_use_path_EQ : 4651 Joined<["-"], "fprofile-instrument-use-path=">, 4652 HelpText<"Specify the profile path in PGO use compilation">, 4653 MarshallingInfoString<CodeGenOpts<"ProfileInstrumentUsePath">>; 4654def flto_visibility_public_std: 4655 Flag<["-"], "flto-visibility-public-std">, 4656 HelpText<"Use public LTO visibility for classes in std and stdext namespaces">, 4657 MarshallingInfoFlag<CodeGenOpts<"LTOVisibilityPublicStd">>; 4658defm lto_unit : BoolOption<"f", "lto-unit", 4659 CodeGenOpts<"LTOUnit">, DefaultFalse, 4660 PosFlag<SetTrue, [CC1Option], "Emit IR to support LTO unit features (CFI, whole program vtable opt)">, 4661 NegFlag<SetFalse>>; 4662defm debug_pass_manager : BoolOption<"f", "debug-pass-manager", 4663 CodeGenOpts<"DebugPassManager">, DefaultFalse, 4664 PosFlag<SetTrue, [], "Prints debug information for the new pass manager">, 4665 NegFlag<SetFalse, [], "Disables debug printing for the new pass manager">>; 4666def fexperimental_debug_variable_locations : Flag<["-"], 4667 "fexperimental-debug-variable-locations">, 4668 HelpText<"Use experimental new value-tracking variable locations">, 4669 MarshallingInfoFlag<CodeGenOpts<"ValueTrackingVariableLocations">>; 4670// The driver option takes the key as a parameter to the -msign-return-address= 4671// and -mbranch-protection= options, but CC1 has a separate option so we 4672// don't have to parse the parameter twice. 4673def msign_return_address_key_EQ : Joined<["-"], "msign-return-address-key=">, 4674 Values<"a_key,b_key">; 4675def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">, 4676 MarshallingInfoFlag<LangOpts<"BranchTargetEnforcement">>; 4677def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">, 4678 MarshallingInfoNegativeFlag<LangOpts<"DllExportInlines">>; 4679def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">, 4680 HelpText<"Emit Windows Control Flow Guard tables only (no checks)">, 4681 MarshallingInfoFlag<CodeGenOpts<"ControlFlowGuardNoChecks">>; 4682def cfguard : Flag<["-"], "cfguard">, 4683 HelpText<"Emit Windows Control Flow Guard tables and checks">, 4684 MarshallingInfoFlag<CodeGenOpts<"ControlFlowGuard">>; 4685 4686def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">, 4687 Group<f_Group>; 4688 4689//===----------------------------------------------------------------------===// 4690// Dependency Output Options 4691//===----------------------------------------------------------------------===// 4692 4693def sys_header_deps : Flag<["-"], "sys-header-deps">, 4694 HelpText<"Include system headers in dependency output">, 4695 MarshallingInfoFlag<DependencyOutputOpts<"IncludeSystemHeaders">>; 4696def module_file_deps : Flag<["-"], "module-file-deps">, 4697 HelpText<"Include module files in dependency output">, 4698 MarshallingInfoFlag<DependencyOutputOpts<"IncludeModuleFiles">>; 4699def header_include_file : Separate<["-"], "header-include-file">, 4700 HelpText<"Filename (or -) to write header include output to">, 4701 MarshallingInfoString<DependencyOutputOpts<"HeaderIncludeOutputFile">>; 4702def show_includes : Flag<["--"], "show-includes">, 4703 HelpText<"Print cl.exe style /showIncludes to stdout">; 4704 4705//===----------------------------------------------------------------------===// 4706// Diagnostic Options 4707//===----------------------------------------------------------------------===// 4708 4709def diagnostic_log_file : Separate<["-"], "diagnostic-log-file">, 4710 HelpText<"Filename (or -) to log diagnostics to">, 4711 MarshallingInfoString<DiagnosticOpts<"DiagnosticLogFile">>; 4712def diagnostic_serialized_file : Separate<["-"], "serialize-diagnostic-file">, 4713 MetaVarName<"<filename>">, 4714 HelpText<"File for serializing diagnostics in a binary format">; 4715 4716def fdiagnostics_format : Separate<["-"], "fdiagnostics-format">, 4717 HelpText<"Change diagnostic formatting to match IDE and command line tools">, Values<"clang,msvc,msvc-fallback,vi">, 4718 NormalizedValuesScope<"DiagnosticOptions">, NormalizedValues<["Clang", "MSVC", "MSVC", "Vi"]>, 4719 MarshallingInfoString<DiagnosticOpts<"Format">, "Clang">, AutoNormalizeEnum; 4720def fdiagnostics_show_category : Separate<["-"], "fdiagnostics-show-category">, 4721 HelpText<"Print diagnostic category">, Values<"none,id,name">, 4722 NormalizedValues<["0", "1", "2"]>, 4723 MarshallingInfoString<DiagnosticOpts<"ShowCategories">, "0">, AutoNormalizeEnum; 4724def fno_diagnostics_use_presumed_location : Flag<["-"], "fno-diagnostics-use-presumed-location">, 4725 HelpText<"Ignore #line directives when displaying diagnostic locations">, 4726 MarshallingInfoNegativeFlag<DiagnosticOpts<"ShowPresumedLoc">>; 4727def ftabstop : Separate<["-"], "ftabstop">, MetaVarName<"<N>">, 4728 HelpText<"Set the tab stop distance.">, 4729 MarshallingInfoStringInt<DiagnosticOpts<"TabStop">, "DiagnosticOptions::DefaultTabStop">; 4730def ferror_limit : Separate<["-"], "ferror-limit">, MetaVarName<"<N>">, 4731 HelpText<"Set the maximum number of errors to emit before stopping (0 = no limit).">, 4732 MarshallingInfoStringInt<DiagnosticOpts<"ErrorLimit">>; 4733def fmacro_backtrace_limit : Separate<["-"], "fmacro-backtrace-limit">, MetaVarName<"<N>">, 4734 HelpText<"Set the maximum number of entries to print in a macro expansion backtrace (0 = no limit).">, 4735 MarshallingInfoStringInt<DiagnosticOpts<"MacroBacktraceLimit">, "DiagnosticOptions::DefaultMacroBacktraceLimit">; 4736def ftemplate_backtrace_limit : Separate<["-"], "ftemplate-backtrace-limit">, MetaVarName<"<N>">, 4737 HelpText<"Set the maximum number of entries to print in a template instantiation backtrace (0 = no limit).">, 4738 MarshallingInfoStringInt<DiagnosticOpts<"TemplateBacktraceLimit">, "DiagnosticOptions::DefaultTemplateBacktraceLimit">; 4739def fconstexpr_backtrace_limit : Separate<["-"], "fconstexpr-backtrace-limit">, MetaVarName<"<N>">, 4740 HelpText<"Set the maximum number of entries to print in a constexpr evaluation backtrace (0 = no limit).">, 4741 MarshallingInfoStringInt<DiagnosticOpts<"ConstexprBacktraceLimit">, "DiagnosticOptions::DefaultConstexprBacktraceLimit">; 4742def fspell_checking_limit : Separate<["-"], "fspell-checking-limit">, MetaVarName<"<N>">, 4743 HelpText<"Set the maximum number of times to perform spell checking on unrecognized identifiers (0 = no limit).">, 4744 MarshallingInfoStringInt<DiagnosticOpts<"SpellCheckingLimit">, "DiagnosticOptions::DefaultSpellCheckingLimit">; 4745def fcaret_diagnostics_max_lines : 4746 Separate<["-"], "fcaret-diagnostics-max-lines">, MetaVarName<"<N>">, 4747 HelpText<"Set the maximum number of source lines to show in a caret diagnostic">, 4748 MarshallingInfoStringInt<DiagnosticOpts<"SnippetLineLimit">, "DiagnosticOptions::DefaultSnippetLineLimit">; 4749def verify_EQ : CommaJoined<["-"], "verify=">, 4750 MetaVarName<"<prefixes>">, 4751 HelpText<"Verify diagnostic output using comment directives that start with" 4752 " prefixes in the comma-separated sequence <prefixes>">, 4753 MarshallingInfoStringVector<DiagnosticOpts<"VerifyPrefixes">>; 4754def verify : Flag<["-"], "verify">, 4755 HelpText<"Equivalent to -verify=expected">; 4756def verify_ignore_unexpected : Flag<["-"], "verify-ignore-unexpected">, 4757 HelpText<"Ignore unexpected diagnostic messages">; 4758def verify_ignore_unexpected_EQ : CommaJoined<["-"], "verify-ignore-unexpected=">, 4759 HelpText<"Ignore unexpected diagnostic messages">; 4760def Wno_rewrite_macros : Flag<["-"], "Wno-rewrite-macros">, 4761 HelpText<"Silence ObjC rewriting warnings">, 4762 MarshallingInfoFlag<DiagnosticOpts<"NoRewriteMacros">>; 4763 4764//===----------------------------------------------------------------------===// 4765// Frontend Options 4766//===----------------------------------------------------------------------===// 4767 4768// This isn't normally used, it is just here so we can parse a 4769// CompilerInvocation out of a driver-derived argument vector. 4770def cc1 : Flag<["-"], "cc1">; 4771def cc1as : Flag<["-"], "cc1as">; 4772 4773def ast_merge : Separate<["-"], "ast-merge">, 4774 MetaVarName<"<ast file>">, 4775 HelpText<"Merge the given AST file into the translation unit being compiled.">, 4776 MarshallingInfoStringVector<FrontendOpts<"ASTMergeFiles">>; 4777def aux_target_cpu : Separate<["-"], "aux-target-cpu">, 4778 HelpText<"Target a specific auxiliary cpu type">; 4779def aux_target_feature : Separate<["-"], "aux-target-feature">, 4780 HelpText<"Target specific auxiliary attributes">; 4781def aux_triple : Separate<["-"], "aux-triple">, 4782 HelpText<"Auxiliary target triple.">, 4783 MarshallingInfoString<FrontendOpts<"AuxTriple">>; 4784def code_completion_at : Separate<["-"], "code-completion-at">, 4785 MetaVarName<"<file>:<line>:<column>">, 4786 HelpText<"Dump code-completion information at a location">; 4787def remap_file : Separate<["-"], "remap-file">, 4788 MetaVarName<"<from>;<to>">, 4789 HelpText<"Replace the contents of the <from> file with the contents of the <to> file">; 4790def code_completion_at_EQ : Joined<["-"], "code-completion-at=">, 4791 Alias<code_completion_at>; 4792def code_completion_macros : Flag<["-"], "code-completion-macros">, 4793 HelpText<"Include macros in code-completion results">, 4794 MarshallingInfoFlag<FrontendOpts<"CodeCompleteOpts.IncludeMacros">>; 4795def code_completion_patterns : Flag<["-"], "code-completion-patterns">, 4796 HelpText<"Include code patterns in code-completion results">, 4797 MarshallingInfoFlag<FrontendOpts<"CodeCompleteOpts.IncludeCodePatterns">>; 4798def no_code_completion_globals : Flag<["-"], "no-code-completion-globals">, 4799 HelpText<"Do not include global declarations in code-completion results.">, 4800 MarshallingInfoNegativeFlag<FrontendOpts<"CodeCompleteOpts.IncludeGlobals">>; 4801def no_code_completion_ns_level_decls : Flag<["-"], "no-code-completion-ns-level-decls">, 4802 HelpText<"Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.">, 4803 MarshallingInfoNegativeFlag<FrontendOpts<"CodeCompleteOpts.IncludeNamespaceLevelDecls">>; 4804def code_completion_brief_comments : Flag<["-"], "code-completion-brief-comments">, 4805 HelpText<"Include brief documentation comments in code-completion results.">, 4806 MarshallingInfoFlag<FrontendOpts<"CodeCompleteOpts.IncludeBriefComments">>; 4807def code_completion_with_fixits : Flag<["-"], "code-completion-with-fixits">, 4808 HelpText<"Include code completion results which require small fix-its.">, 4809 MarshallingInfoFlag<FrontendOpts<"CodeCompleteOpts.IncludeFixIts">>; 4810def disable_free : Flag<["-"], "disable-free">, 4811 HelpText<"Disable freeing of memory on exit">, 4812 MarshallingInfoFlag<FrontendOpts<"DisableFree">>; 4813def discard_value_names : Flag<["-"], "discard-value-names">, 4814 HelpText<"Discard value names in LLVM IR">, 4815 MarshallingInfoFlag<CodeGenOpts<"DiscardValueNames">>; 4816def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">, 4817 HelpText<"Load the named plugin (dynamic shared object)">; 4818def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">, 4819 HelpText<"Use the named plugin action instead of the default action (use \"help\" to list available options)">; 4820def plugin_arg : JoinedAndSeparate<["-"], "plugin-arg-">, 4821 MetaVarName<"<name> <arg>">, 4822 HelpText<"Pass <arg> to plugin <name>">; 4823def add_plugin : Separate<["-"], "add-plugin">, MetaVarName<"<name>">, 4824 HelpText<"Use the named plugin action in addition to the default action">, 4825 MarshallingInfoStringVector<FrontendOpts<"AddPluginActions">>; 4826def ast_dump_filter : Separate<["-"], "ast-dump-filter">, 4827 MetaVarName<"<dump_filter>">, 4828 HelpText<"Use with -ast-dump or -ast-print to dump/print only AST declaration" 4829 " nodes having a certain substring in a qualified name. Use" 4830 " -ast-list to list all filterable declaration node names.">, 4831 MarshallingInfoString<FrontendOpts<"ASTDumpFilter">>; 4832def fno_modules_global_index : Flag<["-"], "fno-modules-global-index">, 4833 HelpText<"Do not automatically generate or update the global module index">, 4834 MarshallingInfoNegativeFlag<FrontendOpts<"UseGlobalModuleIndex">>; 4835def fno_modules_error_recovery : Flag<["-"], "fno-modules-error-recovery">, 4836 HelpText<"Do not automatically import modules for error recovery">, 4837 MarshallingInfoNegativeFlag<LangOpts<"ModulesErrorRecovery">>; 4838def fmodule_map_file_home_is_cwd : Flag<["-"], "fmodule-map-file-home-is-cwd">, 4839 HelpText<"Use the current working directory as the home directory of " 4840 "module maps specified by -fmodule-map-file=<FILE>">, 4841 MarshallingInfoFlag<HeaderSearchOpts<"ModuleMapFileHomeIsCwd">>; 4842def fmodule_feature : Separate<["-"], "fmodule-feature">, 4843 MetaVarName<"<feature>">, 4844 HelpText<"Enable <feature> in module map requires declarations">, 4845 MarshallingInfoStringVector<LangOpts<"ModuleFeatures">>; 4846def fmodules_embed_file_EQ : Joined<["-"], "fmodules-embed-file=">, 4847 MetaVarName<"<file>">, 4848 HelpText<"Embed the contents of the specified file into the module file " 4849 "being compiled.">, 4850 MarshallingInfoStringVector<FrontendOpts<"ModulesEmbedFiles">>; 4851def fmodules_embed_all_files : Joined<["-"], "fmodules-embed-all-files">, 4852 HelpText<"Embed the contents of all files read by this compilation into " 4853 "the produced module file.">, 4854 MarshallingInfoFlag<FrontendOpts<"ModulesEmbedAllFiles">>; 4855def fmodules_local_submodule_visibility : 4856 Flag<["-"], "fmodules-local-submodule-visibility">, 4857 HelpText<"Enforce name visibility rules across submodules of the same " 4858 "top-level module.">; 4859def fmodules_codegen : 4860 Flag<["-"], "fmodules-codegen">, 4861 HelpText<"Generate code for uses of this module that assumes an explicit " 4862 "object file will be built for the module">, 4863 MarshallingInfoFlag<LangOpts<"ModulesCodegen">>; 4864def fmodules_debuginfo : 4865 Flag<["-"], "fmodules-debuginfo">, 4866 HelpText<"Generate debug info for types in an object file built from this " 4867 "module and do not generate them elsewhere">, 4868 MarshallingInfoFlag<LangOpts<"ModulesDebugInfo">>; 4869def fmodule_format_EQ : Joined<["-"], "fmodule-format=">, 4870 HelpText<"Select the container format for clang modules and PCH. " 4871 "Supported options are 'raw' and 'obj'.">, 4872 MarshallingInfoString<HeaderSearchOpts<"ModuleFormat">, [{"raw"}]>; 4873def ftest_module_file_extension_EQ : 4874 Joined<["-"], "ftest-module-file-extension=">, 4875 HelpText<"introduce a module file extension for testing purposes. " 4876 "The argument is parsed as blockname:major:minor:hashed:user info">; 4877def fconcepts_ts : Flag<["-"], "fconcepts-ts">, 4878 HelpText<"Enable C++ Extensions for Concepts. (deprecated - use -std=c++2a)">; 4879def fno_concept_satisfaction_caching : Flag<["-"], 4880 "fno-concept-satisfaction-caching">, 4881 HelpText<"Disable satisfaction caching for C++2a Concepts.">, 4882 MarshallingInfoNegativeFlag<LangOpts<"ConceptSatisfactionCaching">>; 4883 4884defm recovery_ast : BoolOption<"f", "recovery-ast", 4885 LangOpts<"RecoveryAST">, DefaultTrue, 4886 NegFlag<SetFalse>, PosFlag<SetTrue, [], "Preserve expressions in AST rather " 4887 "than dropping them when encountering semantic errors">>; 4888defm recovery_ast_type : BoolOption<"f", "recovery-ast-type", 4889 LangOpts<"RecoveryASTType">, DefaultTrue, 4890 NegFlag<SetFalse>, PosFlag<SetTrue, [], "Preserve the type for recovery " 4891 "expressions when possible">>; 4892 4893let Group = Action_Group in { 4894 4895def Eonly : Flag<["-"], "Eonly">, 4896 HelpText<"Just run preprocessor, no output (for timings)">; 4897def dump_raw_tokens : Flag<["-"], "dump-raw-tokens">, 4898 HelpText<"Lex file in raw mode and dump raw tokens">; 4899def analyze : Flag<["-"], "analyze">, 4900 HelpText<"Run static analysis engine">; 4901def dump_tokens : Flag<["-"], "dump-tokens">, 4902 HelpText<"Run preprocessor, dump internal rep of tokens">; 4903def init_only : Flag<["-"], "init-only">, 4904 HelpText<"Only execute frontend initialization">; 4905def fixit : Flag<["-"], "fixit">, 4906 HelpText<"Apply fix-it advice to the input source">; 4907def fixit_EQ : Joined<["-"], "fixit=">, 4908 HelpText<"Apply fix-it advice creating a file with the given suffix">; 4909def print_preamble : Flag<["-"], "print-preamble">, 4910 HelpText<"Print the \"preamble\" of a file, which is a candidate for implicit" 4911 " precompiled headers.">; 4912def emit_html : Flag<["-"], "emit-html">, 4913 HelpText<"Output input source as HTML">; 4914def ast_print : Flag<["-"], "ast-print">, 4915 HelpText<"Build ASTs and then pretty-print them">; 4916def ast_list : Flag<["-"], "ast-list">, 4917 HelpText<"Build ASTs and print the list of declaration node qualified names">; 4918def ast_dump : Flag<["-"], "ast-dump">, 4919 HelpText<"Build ASTs and then debug dump them">; 4920def ast_dump_EQ : Joined<["-"], "ast-dump=">, 4921 HelpText<"Build ASTs and then debug dump them in the specified format. " 4922 "Supported formats include: default, json">; 4923def ast_dump_all : Flag<["-"], "ast-dump-all">, 4924 HelpText<"Build ASTs and then debug dump them, forcing deserialization">; 4925def ast_dump_all_EQ : Joined<["-"], "ast-dump-all=">, 4926 HelpText<"Build ASTs and then debug dump them in the specified format, " 4927 "forcing deserialization. Supported formats include: default, json">; 4928def ast_dump_decl_types : Flag<["-"], "ast-dump-decl-types">, 4929 HelpText<"Include declaration types in AST dumps">, 4930 MarshallingInfoFlag<FrontendOpts<"ASTDumpDeclTypes">>; 4931def templight_dump : Flag<["-"], "templight-dump">, 4932 HelpText<"Dump templight information to stdout">; 4933def ast_dump_lookups : Flag<["-"], "ast-dump-lookups">, 4934 HelpText<"Build ASTs and then debug dump their name lookup tables">, 4935 MarshallingInfoFlag<FrontendOpts<"ASTDumpLookups">>; 4936def ast_view : Flag<["-"], "ast-view">, 4937 HelpText<"Build ASTs and view them with GraphViz">; 4938def emit_module : Flag<["-"], "emit-module">, 4939 HelpText<"Generate pre-compiled module file from a module map">; 4940def emit_module_interface : Flag<["-"], "emit-module-interface">, 4941 HelpText<"Generate pre-compiled module file from a C++ module interface">; 4942def emit_header_module : Flag<["-"], "emit-header-module">, 4943 HelpText<"Generate pre-compiled module file from a set of header files">; 4944def emit_pch : Flag<["-"], "emit-pch">, 4945 HelpText<"Generate pre-compiled header file">; 4946def emit_llvm_bc : Flag<["-"], "emit-llvm-bc">, 4947 HelpText<"Build ASTs then convert to LLVM, emit .bc file">; 4948def emit_llvm_only : Flag<["-"], "emit-llvm-only">, 4949 HelpText<"Build ASTs and convert to LLVM, discarding output">; 4950def emit_codegen_only : Flag<["-"], "emit-codegen-only">, 4951 HelpText<"Generate machine code, but discard output">; 4952def rewrite_test : Flag<["-"], "rewrite-test">, 4953 HelpText<"Rewriter playground">; 4954def rewrite_macros : Flag<["-"], "rewrite-macros">, 4955 HelpText<"Expand macros without full preprocessing">; 4956def migrate : Flag<["-"], "migrate">, 4957 HelpText<"Migrate source code">; 4958def compiler_options_dump : Flag<["-"], "compiler-options-dump">, 4959 HelpText<"Dump the compiler configuration options">; 4960def print_dependency_directives_minimized_source : Flag<["-"], 4961 "print-dependency-directives-minimized-source">, 4962 HelpText<"Print the output of the dependency directives source minimizer">; 4963} 4964 4965defm emit_llvm_uselists : BoolOption<"", "emit-llvm-uselists", 4966 CodeGenOpts<"EmitLLVMUseLists">, DefaultFalse, 4967 PosFlag<SetTrue, [], "Preserve">, 4968 NegFlag<SetFalse, [], "Don't preserve">, 4969 BothFlags<[], " order of LLVM use-lists when serializing">>; 4970 4971def mt_migrate_directory : Separate<["-"], "mt-migrate-directory">, 4972 HelpText<"Directory for temporary files produced during ARC or ObjC migration">, 4973 MarshallingInfoString<FrontendOpts<"MTMigrateDir">>; 4974 4975def arcmt_action_EQ : Joined<["-"], "arcmt-action=">, Flags<[CC1Option, NoDriverOption]>, 4976 HelpText<"The ARC migration action to take">, Values<"check,modify,migrate">, 4977 NormalizedValuesScope<"FrontendOptions">, 4978 NormalizedValues<["ARCMT_Check", "ARCMT_Modify", "ARCMT_Migrate"]>, 4979 MarshallingInfoString<FrontendOpts<"ARCMTAction">, "ARCMT_None">, 4980 AutoNormalizeEnum; 4981 4982def opt_record_file : Separate<["-"], "opt-record-file">, 4983 HelpText<"File name to use for YAML optimization record output">, 4984 MarshallingInfoString<CodeGenOpts<"OptRecordFile">>; 4985def opt_record_passes : Separate<["-"], "opt-record-passes">, 4986 HelpText<"Only record remark information for passes whose names match the given regular expression">; 4987def opt_record_format : Separate<["-"], "opt-record-format">, 4988 HelpText<"The format used for serializing remarks (default: YAML)">; 4989 4990def print_stats : Flag<["-"], "print-stats">, 4991 HelpText<"Print performance metrics and statistics">, 4992 MarshallingInfoFlag<FrontendOpts<"ShowStats">>; 4993def stats_file : Joined<["-"], "stats-file=">, 4994 HelpText<"Filename to write statistics to">, 4995 MarshallingInfoString<FrontendOpts<"StatsFile">>; 4996def fdump_record_layouts : Flag<["-"], "fdump-record-layouts">, 4997 HelpText<"Dump record layout information">; 4998def fdump_record_layouts_simple : Flag<["-"], "fdump-record-layouts-simple">, 4999 HelpText<"Dump record layout information in a simple form used for testing">, 5000 MarshallingInfoFlag<LangOpts<"DumpRecordLayoutsSimple">>; 5001def fix_what_you_can : Flag<["-"], "fix-what-you-can">, 5002 HelpText<"Apply fix-it advice even in the presence of unfixable errors">, 5003 MarshallingInfoFlag<FrontendOpts<"FixWhatYouCan">>; 5004def fix_only_warnings : Flag<["-"], "fix-only-warnings">, 5005 HelpText<"Apply fix-it advice only for warnings, not errors">, 5006 MarshallingInfoFlag<FrontendOpts<"FixOnlyWarnings">>; 5007def fixit_recompile : Flag<["-"], "fixit-recompile">, 5008 HelpText<"Apply fix-it changes and recompile">, 5009 MarshallingInfoFlag<FrontendOpts<"FixAndRecompile">>; 5010def fixit_to_temp : Flag<["-"], "fixit-to-temporary">, 5011 HelpText<"Apply fix-it changes to temporary files">, 5012 MarshallingInfoFlag<FrontendOpts<"FixToTemporaries">>; 5013 5014def foverride_record_layout_EQ : Joined<["-"], "foverride-record-layout=">, 5015 HelpText<"Override record layouts with those in the given file">, 5016 MarshallingInfoString<FrontendOpts<"OverrideRecordLayoutsFile">>; 5017def pch_through_header_EQ : Joined<["-"], "pch-through-header=">, 5018 HelpText<"Stop PCH generation after including this file. When using a PCH, " 5019 "skip tokens until after this file is included.">, 5020 MarshallingInfoString<PreprocessorOpts<"PCHThroughHeader">>; 5021def pch_through_hdrstop_create : Flag<["-"], "pch-through-hdrstop-create">, 5022 HelpText<"When creating a PCH, stop PCH generation after #pragma hdrstop.">, 5023 MarshallingInfoFlag<PreprocessorOpts<"PCHWithHdrStopCreate">>; 5024def pch_through_hdrstop_use : Flag<["-"], "pch-through-hdrstop-use">, 5025 HelpText<"When using a PCH, skip tokens until after a #pragma hdrstop.">; 5026def fno_pch_timestamp : Flag<["-"], "fno-pch-timestamp">, 5027 HelpText<"Disable inclusion of timestamp in precompiled headers">, 5028 MarshallingInfoNegativeFlag<FrontendOpts<"IncludeTimestamps">>; 5029def building_pch_with_obj : Flag<["-"], "building-pch-with-obj">, 5030 HelpText<"This compilation is part of building a PCH with corresponding object file.">, 5031 MarshallingInfoFlag<LangOpts<"BuildingPCHWithObjectFile">>; 5032 5033def aligned_alloc_unavailable : Flag<["-"], "faligned-alloc-unavailable">, 5034 HelpText<"Aligned allocation/deallocation functions are unavailable">; 5035 5036//===----------------------------------------------------------------------===// 5037// Language Options 5038//===----------------------------------------------------------------------===// 5039 5040let Flags = [CC1Option, CC1AsOption, NoDriverOption] in { 5041 5042def version : Flag<["-"], "version">, 5043 HelpText<"Print the compiler version">, 5044 MarshallingInfoFlag<FrontendOpts<"ShowVersion">>; 5045def main_file_name : Separate<["-"], "main-file-name">, 5046 HelpText<"Main file name to use for debug info and source if missing">, 5047 MarshallingInfoString<CodeGenOpts<"MainFileName">>; 5048def split_dwarf_output : Separate<["-"], "split-dwarf-output">, 5049 HelpText<"File name to use for split dwarf debug info output">, 5050 MarshallingInfoString<CodeGenOpts<"SplitDwarfOutput">>; 5051 5052} 5053 5054def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">, 5055 HelpText<"Weakly link in the blocks runtime">, 5056 MarshallingInfoFlag<LangOpts<"BlocksRuntimeOptional">>; 5057def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">, 5058 HelpText<"Assume all functions with C linkage do not unwind">, 5059 MarshallingInfoFlag<LangOpts<"ExternCNoUnwind">>; 5060def split_dwarf_file : Separate<["-"], "split-dwarf-file">, 5061 HelpText<"Name of the split dwarf debug info file to encode in the object file">, 5062 MarshallingInfoString<CodeGenOpts<"SplitDwarfFile">>; 5063def fno_wchar : Flag<["-"], "fno-wchar">, 5064 HelpText<"Disable C++ builtin type wchar_t">; 5065def fconstant_string_class : Separate<["-"], "fconstant-string-class">, 5066 MetaVarName<"<class name>">, 5067 HelpText<"Specify the class to use for constant Objective-C string objects.">, 5068 MarshallingInfoString<LangOpts<"ObjCConstantStringClass">>; 5069def fobjc_arc_cxxlib_EQ : Joined<["-"], "fobjc-arc-cxxlib=">, 5070 HelpText<"Objective-C++ Automatic Reference Counting standard library kind">, Values<"libc++,libstdc++,none">, 5071 NormalizedValues<["ARCXX_libcxx", "ARCXX_libstdcxx", "ARCXX_nolib"]>, 5072 MarshallingInfoString<PreprocessorOpts<"ObjCXXARCStandardLibrary">, "ARCXX_nolib">, AutoNormalizeEnum; 5073def fobjc_runtime_has_weak : Flag<["-"], "fobjc-runtime-has-weak">, 5074 HelpText<"The target Objective-C runtime supports ARC weak operations">; 5075def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">, 5076 HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">, 5077 NormalizedValuesScope<"CodeGenOptions">, NormalizedValues<["Legacy", "NonLegacy", "Mixed"]>, 5078 MarshallingInfoString<CodeGenOpts<"ObjCDispatchMethod">, "Legacy">, AutoNormalizeEnum; 5079def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">, 5080 HelpText<"disable the default synthesis of Objective-C properties">, 5081 MarshallingInfoNegativeFlag<LangOpts<"ObjCDefaultSynthProperties">>; 5082def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">, 5083 HelpText<"enable extended encoding of block type signature">, 5084 MarshallingInfoFlag<LangOpts<"EncodeExtendedBlockSig">>; 5085def function_alignment : Separate<["-"], "function-alignment">, 5086 HelpText<"default alignment for functions">, 5087 MarshallingInfoStringInt<LangOpts<"FunctionAlignment">>; 5088def pic_level : Separate<["-"], "pic-level">, 5089 HelpText<"Value for __PIC__">; 5090def pic_is_pie : Flag<["-"], "pic-is-pie">, 5091 HelpText<"File is for a position independent executable">, 5092 MarshallingInfoFlag<LangOpts<"PIE">>; 5093def fhalf_no_semantic_interposition : Flag<["-"], "fhalf-no-semantic-interposition">, 5094 HelpText<"Like -fno-semantic-interposition but don't use local aliases">, 5095 MarshallingInfoFlag<LangOpts<"HalfNoSemanticInterposition">>; 5096def fno_validate_pch : Flag<["-"], "fno-validate-pch">, 5097 HelpText<"Disable validation of precompiled headers">, 5098 MarshallingInfoFlag<PreprocessorOpts<"DisablePCHOrModuleValidation">, "DisableValidationForModuleKind::None">, 5099 Normalizer<"makeFlagToValueNormalizer(DisableValidationForModuleKind::All)">; 5100def fallow_pcm_with_errors : Flag<["-"], "fallow-pcm-with-compiler-errors">, 5101 HelpText<"Accept a PCM file that was created with compiler errors">, 5102 MarshallingInfoFlag<FrontendOpts<"AllowPCMWithCompilerErrors">>; 5103def fallow_pch_with_errors : Flag<["-"], "fallow-pch-with-compiler-errors">, 5104 HelpText<"Accept a PCH file that was created with compiler errors">, 5105 MarshallingInfoFlag<PreprocessorOpts<"AllowPCHWithCompilerErrors">>, 5106 ImpliedByAnyOf<[fallow_pcm_with_errors.KeyPath]>; 5107def dump_deserialized_pch_decls : Flag<["-"], "dump-deserialized-decls">, 5108 HelpText<"Dump declarations that are deserialized from PCH, for testing">, 5109 MarshallingInfoFlag<PreprocessorOpts<"DumpDeserializedPCHDecls">>; 5110def error_on_deserialized_pch_decl : Separate<["-"], "error-on-deserialized-decl">, 5111 HelpText<"Emit error if a specific declaration is deserialized from PCH, for testing">; 5112def error_on_deserialized_pch_decl_EQ : Joined<["-"], "error-on-deserialized-decl=">, 5113 Alias<error_on_deserialized_pch_decl>; 5114def static_define : Flag<["-"], "static-define">, 5115 HelpText<"Should __STATIC__ be defined">, 5116 MarshallingInfoFlag<LangOpts<"Static">>; 5117def stack_protector : Separate<["-"], "stack-protector">, 5118 HelpText<"Enable stack protectors">, Values<"0,1,2,3">, 5119 NormalizedValuesScope<"LangOptions">, 5120 NormalizedValues<["SSPOff", "SSPOn", "SSPStrong", "SSPReq"]>, 5121 MarshallingInfoString<LangOpts<"StackProtector">, "SSPOff">, AutoNormalizeEnum; 5122def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">, 5123 HelpText<"Lower bound for a buffer to be considered for stack protection">, 5124 MarshallingInfoStringInt<CodeGenOpts<"SSPBufferSize">, "8">; 5125def fvisibility : Separate<["-"], "fvisibility">, 5126 HelpText<"Default type and symbol visibility">, 5127 MarshallingInfoVisibility<LangOpts<"ValueVisibilityMode">, "DefaultVisibility">; 5128def ftype_visibility : Separate<["-"], "ftype-visibility">, 5129 HelpText<"Default type visibility">, 5130 MarshallingInfoVisibility<LangOpts<"TypeVisibilityMode">, fvisibility.KeyPath>; 5131def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">, 5132 HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">, 5133 MarshallingInfoFlag<LangOpts<"SetVisibilityForExternDecls">>; 5134def ftemplate_depth : Separate<["-"], "ftemplate-depth">, 5135 HelpText<"Maximum depth of recursive template instantiation">, 5136 MarshallingInfoStringInt<LangOpts<"InstantiationDepth">, "1024">; 5137def foperator_arrow_depth : Separate<["-"], "foperator-arrow-depth">, 5138 HelpText<"Maximum number of 'operator->'s to call for a member access">, 5139 MarshallingInfoStringInt<LangOpts<"ArrowDepth">, "256">; 5140def fconstexpr_depth : Separate<["-"], "fconstexpr-depth">, 5141 HelpText<"Maximum depth of recursive constexpr function calls">, 5142 MarshallingInfoStringInt<LangOpts<"ConstexprCallDepth">, "512">; 5143def fconstexpr_steps : Separate<["-"], "fconstexpr-steps">, 5144 HelpText<"Maximum number of steps in constexpr function evaluation">, 5145 MarshallingInfoStringInt<LangOpts<"ConstexprStepLimit">, "1048576">; 5146def fbracket_depth : Separate<["-"], "fbracket-depth">, 5147 HelpText<"Maximum nesting level for parentheses, brackets, and braces">, 5148 MarshallingInfoStringInt<LangOpts<"BracketDepth">, "256">; 5149defm const_strings : BoolOption<"f", "const-strings", 5150 LangOpts<"ConstStrings">, DefaultFalse, 5151 PosFlag<SetTrue, [CC1Option], "Use">, NegFlag<SetFalse, [], "Don't use">, 5152 BothFlags<[], " a const qualified type for string literals in C and ObjC">>; 5153def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">, 5154 HelpText<"Ignore bit-field types when aligning structures">, 5155 MarshallingInfoFlag<LangOpts<"NoBitFieldTypeAlign">>; 5156def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">, 5157 HelpText<"Use a fake address space map; OpenCL testing purposes only">, 5158 MarshallingInfoFlag<LangOpts<"FakeAddressSpaceMap">>; 5159def faddress_space_map_mangling_EQ : Joined<["-"], "faddress-space-map-mangling=">, MetaVarName<"<yes|no|target>">, 5160 HelpText<"Set the mode for address space map based mangling; OpenCL testing purposes only">, 5161 Values<"target,no,yes">, NormalizedValuesScope<"LangOptions">, 5162 NormalizedValues<["ASMM_Target", "ASMM_Off", "ASMM_On"]>, 5163 MarshallingInfoString<LangOpts<"AddressSpaceMapMangling">, "ASMM_Target">, AutoNormalizeEnum; 5164def funknown_anytype : Flag<["-"], "funknown-anytype">, 5165 HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">, 5166 MarshallingInfoFlag<LangOpts<"ParseUnknownAnytype">>; 5167def fdebugger_support : Flag<["-"], "fdebugger-support">, 5168 HelpText<"Enable special debugger support behavior">, 5169 MarshallingInfoFlag<LangOpts<"DebuggerSupport">>; 5170def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">, 5171 HelpText<"Enable casting unknown expression results to id">, 5172 MarshallingInfoFlag<LangOpts<"DebuggerCastResultToId">>; 5173def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">, 5174 HelpText<"Enable special debugger support for Objective-C subscripting and literals">, 5175 MarshallingInfoFlag<LangOpts<"DebuggerObjCLiteral">>; 5176def fdeprecated_macro : Flag<["-"], "fdeprecated-macro">, 5177 HelpText<"Defines the __DEPRECATED macro">; 5178def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">, 5179 HelpText<"Undefines the __DEPRECATED macro">; 5180def fobjc_subscripting_legacy_runtime : Flag<["-"], "fobjc-subscripting-legacy-runtime">, 5181 HelpText<"Allow Objective-C array and dictionary subscripting in legacy runtime">; 5182// TODO: Enforce values valid for MSVtorDispMode. 5183def vtordisp_mode_EQ : Joined<["-"], "vtordisp-mode=">, 5184 HelpText<"Control vtordisp placement on win32 targets">, 5185 MarshallingInfoStringInt<LangOpts<"VtorDispMode">, "1">; 5186def fnative_half_type: Flag<["-"], "fnative-half-type">, 5187 HelpText<"Use the native half type for __fp16 instead of promoting to float">, 5188 MarshallingInfoFlag<LangOpts<"NativeHalfType">>, 5189 ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath]>; 5190def fnative_half_arguments_and_returns : Flag<["-"], "fnative-half-arguments-and-returns">, 5191 HelpText<"Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)">, 5192 MarshallingInfoFlag<LangOpts<"NativeHalfArgsAndReturns">>, 5193 ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath]>; 5194def fallow_half_arguments_and_returns : Flag<["-"], "fallow-half-arguments-and-returns">, 5195 HelpText<"Allow function arguments and returns of type half">, 5196 MarshallingInfoFlag<LangOpts<"HalfArgsAndReturns">>, 5197 ImpliedByAnyOf<[fnative_half_arguments_and_returns.KeyPath]>; 5198def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">, 5199 HelpText<"Set default calling convention">, Values<"cdecl,fastcall,stdcall,vectorcall,regcall">, 5200 NormalizedValuesScope<"LangOptions">, 5201 NormalizedValues<["DCC_CDecl", "DCC_FastCall", "DCC_StdCall", "DCC_VectorCall", "DCC_RegCall"]>, 5202 MarshallingInfoString<LangOpts<"DefaultCallingConv">, "DCC_None">, AutoNormalizeEnum; 5203 5204// These options cannot be marshalled, because they are used to set up the LangOptions defaults. 5205def finclude_default_header : Flag<["-"], "finclude-default-header">, 5206 HelpText<"Include default header file for OpenCL">; 5207def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">, 5208 HelpText<"Add OpenCL builtin function declarations (experimental)">; 5209 5210def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">, 5211 HelpText<"Preserve 3-component vector type">, 5212 MarshallingInfoFlag<CodeGenOpts<"PreserveVec3Type">>; 5213def fwchar_type_EQ : Joined<["-"], "fwchar-type=">, 5214 HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">, 5215 NormalizedValues<["1", "2", "4"]>, 5216 MarshallingInfoString<LangOpts<"WCharSize">, "0">, AutoNormalizeEnum; 5217defm signed_wchar : BoolOption<"f", "signed-wchar", 5218 LangOpts<"WCharIsSigned">, DefaultTrue, 5219 NegFlag<SetFalse, [CC1Option], "Use an unsigned">, PosFlag<SetTrue, [], "Use a signed">, 5220 BothFlags<[], " type for wchar_t">>; 5221def fcompatibility_qualified_id_block_param_type_checking : Flag<["-"], "fcompatibility-qualified-id-block-type-checking">, 5222 HelpText<"Allow using blocks with parameters of more specific type than " 5223 "the type system guarantees when a parameter is qualified id">, 5224 MarshallingInfoFlag<LangOpts<"CompatibilityQualifiedIdBlockParamTypeChecking">>; 5225def fpass_by_value_is_noalias: Flag<["-"], "fpass-by-value-is-noalias">, 5226 HelpText<"Allows assuming by-value parameters do not alias any other value. " 5227 "Has no effect on non-trivially-copyable classes in C++.">, Group<f_Group>, 5228 MarshallingInfoFlag<CodeGenOpts<"PassByValueIsNoAlias">>; 5229 5230// FIXME: Remove these entirely once functionality/tests have been excised. 5231def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>, 5232 HelpText<"Use GC exclusively for Objective-C related memory management">; 5233def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>, 5234 HelpText<"Enable Objective-C garbage collection">; 5235 5236//===----------------------------------------------------------------------===// 5237// Header Search Options 5238//===----------------------------------------------------------------------===// 5239 5240def nostdsysteminc : Flag<["-"], "nostdsysteminc">, 5241 HelpText<"Disable standard system #include directories">, 5242 MarshallingInfoNegativeFlag<HeaderSearchOpts<"UseStandardSystemIncludes">>; 5243def fdisable_module_hash : Flag<["-"], "fdisable-module-hash">, 5244 HelpText<"Disable the module hash">, 5245 MarshallingInfoFlag<HeaderSearchOpts<"DisableModuleHash">>; 5246def fmodules_hash_content : Flag<["-"], "fmodules-hash-content">, 5247 HelpText<"Enable hashing the content of a module file">, 5248 MarshallingInfoFlag<HeaderSearchOpts<"ModulesHashContent">>; 5249def fmodules_strict_context_hash : Flag<["-"], "fmodules-strict-context-hash">, 5250 HelpText<"Enable hashing of all compiler options that could impact the " 5251 "semantics of a module in an implicit build">, 5252 MarshallingInfoFlag<HeaderSearchOpts<"ModulesStrictContextHash">>; 5253def c_isystem : JoinedOrSeparate<["-"], "c-isystem">, MetaVarName<"<directory>">, 5254 HelpText<"Add directory to the C SYSTEM include search path">; 5255def objc_isystem : JoinedOrSeparate<["-"], "objc-isystem">, 5256 MetaVarName<"<directory>">, 5257 HelpText<"Add directory to the ObjC SYSTEM include search path">; 5258def objcxx_isystem : JoinedOrSeparate<["-"], "objcxx-isystem">, 5259 MetaVarName<"<directory>">, 5260 HelpText<"Add directory to the ObjC++ SYSTEM include search path">; 5261def internal_isystem : JoinedOrSeparate<["-"], "internal-isystem">, 5262 MetaVarName<"<directory>">, 5263 HelpText<"Add directory to the internal system include search path; these " 5264 "are assumed to not be user-provided and are used to model system " 5265 "and standard headers' paths.">; 5266def internal_externc_isystem : JoinedOrSeparate<["-"], "internal-externc-isystem">, 5267 MetaVarName<"<directory>">, 5268 HelpText<"Add directory to the internal system include search path with " 5269 "implicit extern \"C\" semantics; these are assumed to not be " 5270 "user-provided and are used to model system and standard headers' " 5271 "paths.">; 5272 5273//===----------------------------------------------------------------------===// 5274// Preprocessor Options 5275//===----------------------------------------------------------------------===// 5276 5277def chain_include : Separate<["-"], "chain-include">, MetaVarName<"<file>">, 5278 HelpText<"Include and chain a header file after turning it into PCH">; 5279def preamble_bytes_EQ : Joined<["-"], "preamble-bytes=">, 5280 HelpText<"Assume that the precompiled header is a precompiled preamble " 5281 "covering the first N bytes of the main file">; 5282def detailed_preprocessing_record : Flag<["-"], "detailed-preprocessing-record">, 5283 HelpText<"include a detailed record of preprocessing actions">, 5284 MarshallingInfoFlag<PreprocessorOpts<"DetailedRecord">>; 5285def setup_static_analyzer : Flag<["-"], "setup-static-analyzer">, 5286 HelpText<"Set up preprocessor for static analyzer (done automatically when static analyzer is run).">, 5287 MarshallingInfoFlag<PreprocessorOpts<"SetUpStaticAnalyzer">>; 5288def disable_pragma_debug_crash : Flag<["-"], "disable-pragma-debug-crash">, 5289 HelpText<"Disable any #pragma clang __debug that can lead to crashing behavior. This is meant for testing.">, 5290 MarshallingInfoFlag<PreprocessorOpts<"DisablePragmaDebugCrash">>; 5291 5292//===----------------------------------------------------------------------===// 5293// OpenCL Options 5294//===----------------------------------------------------------------------===// 5295 5296def cl_ext_EQ : CommaJoined<["-"], "cl-ext=">, 5297 HelpText<"OpenCL only. Enable or disable OpenCL extensions. The argument is a comma-separated sequence of one or more extension names, each prefixed by '+' or '-'.">, 5298 MarshallingInfoStringVector<TargetOpts<"OpenCLExtensionsAsWritten">>; 5299 5300//===----------------------------------------------------------------------===// 5301// CUDA Options 5302//===----------------------------------------------------------------------===// 5303 5304def fcuda_is_device : Flag<["-"], "fcuda-is-device">, 5305 HelpText<"Generate code for CUDA device">, 5306 MarshallingInfoFlag<LangOpts<"CUDAIsDevice">>; 5307def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">, 5308 HelpText<"Incorporate CUDA device-side binary into host object file.">, 5309 MarshallingInfoString<CodeGenOpts<"CudaGpuBinaryFileName">>; 5310def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">, 5311 HelpText<"Allow variadic functions in CUDA device code.">, 5312 MarshallingInfoFlag<LangOpts<"CUDAAllowVariadicFunctions">>; 5313def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">, 5314 HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">, 5315 MarshallingInfoNegativeFlag<LangOpts<"CUDAHostDeviceConstexpr">>; 5316 5317//===----------------------------------------------------------------------===// 5318// OpenMP Options 5319//===----------------------------------------------------------------------===// 5320 5321def fopenmp_is_device : Flag<["-"], "fopenmp-is-device">, 5322 HelpText<"Generate code only for an OpenMP target device.">; 5323def fopenmp_host_ir_file_path : Separate<["-"], "fopenmp-host-ir-file-path">, 5324 HelpText<"Path to the IR file produced by the frontend for the host.">; 5325 5326//===----------------------------------------------------------------------===// 5327// SYCL Options 5328//===----------------------------------------------------------------------===// 5329 5330def fsycl_is_device : Flag<["-"], "fsycl-is-device">, 5331 HelpText<"Generate code for SYCL device.">, 5332 MarshallingInfoFlag<LangOpts<"SYCLIsDevice">>, 5333 ShouldParseIf<fsycl.KeyPath>; 5334 5335} // let Flags = [CC1Option, NoDriverOption] 5336 5337defm cuda_approx_transcendentals : BoolFOption<"cuda-approx-transcendentals", 5338 LangOpts<"CUDADeviceApproxTranscendentals">, DefaultFalse, 5339 PosFlag<SetTrue, [CC1Option], "Use">, NegFlag<SetFalse, [], "Don't use">, 5340 BothFlags<[], " approximate transcendental functions">>, 5341 ShouldParseIf<fcuda_is_device.KeyPath>; 5342 5343//===----------------------------------------------------------------------===// 5344// Frontend Options - cc1 + fc1 5345//===----------------------------------------------------------------------===// 5346let Flags = [CC1Option, FC1Option, NoDriverOption] in { 5347let Group = Action_Group in { 5348 5349def emit_obj : Flag<["-"], "emit-obj">, 5350 HelpText<"Emit native object files">; 5351 5352} // let Group = Action_Group 5353} // let Flags = [CC1Option, FC1Option, NoDriverOption] 5354 5355//===----------------------------------------------------------------------===// 5356// cc1as-only Options 5357//===----------------------------------------------------------------------===// 5358 5359let Flags = [CC1AsOption, NoDriverOption] in { 5360 5361// Language Options 5362def n : Flag<["-"], "n">, 5363 HelpText<"Don't automatically start assembly file with a text section">; 5364 5365// Frontend Options 5366def filetype : Separate<["-"], "filetype">, 5367 HelpText<"Specify the output file type ('asm', 'null', or 'obj')">; 5368 5369// Transliterate Options 5370def output_asm_variant : Separate<["-"], "output-asm-variant">, 5371 HelpText<"Select the asm variant index to use for output">; 5372def show_encoding : Flag<["-"], "show-encoding">, 5373 HelpText<"Show instruction encoding information in transliterate mode">; 5374def show_inst : Flag<["-"], "show-inst">, 5375 HelpText<"Show internal instruction representation in transliterate mode">; 5376 5377// Assemble Options 5378def dwarf_debug_producer : Separate<["-"], "dwarf-debug-producer">, 5379 HelpText<"The string to embed in the Dwarf debug AT_producer record.">; 5380 5381def defsym : Separate<["-"], "defsym">, 5382 HelpText<"Define a value for a symbol">; 5383 5384} // let Flags = [CC1AsOption] 5385 5386//===----------------------------------------------------------------------===// 5387// clang-cl Options 5388//===----------------------------------------------------------------------===// 5389 5390def cl_Group : OptionGroup<"<clang-cl options>">, Flags<[CLOption]>, 5391 HelpText<"CL.EXE COMPATIBILITY OPTIONS">; 5392 5393def cl_compile_Group : OptionGroup<"<clang-cl compile-only options>">, 5394 Group<cl_Group>; 5395 5396def cl_ignored_Group : OptionGroup<"<clang-cl ignored options>">, 5397 Group<cl_Group>; 5398 5399class CLFlag<string name> : Option<["/", "-"], name, KIND_FLAG>, 5400 Group<cl_Group>, Flags<[CLOption, NoXarchOption]>; 5401 5402class CLCompileFlag<string name> : Option<["/", "-"], name, KIND_FLAG>, 5403 Group<cl_compile_Group>, Flags<[CLOption, NoXarchOption]>; 5404 5405class CLIgnoredFlag<string name> : Option<["/", "-"], name, KIND_FLAG>, 5406 Group<cl_ignored_Group>, Flags<[CLOption, NoXarchOption]>; 5407 5408class CLJoined<string name> : Option<["/", "-"], name, KIND_JOINED>, 5409 Group<cl_Group>, Flags<[CLOption, NoXarchOption]>; 5410 5411class CLCompileJoined<string name> : Option<["/", "-"], name, KIND_JOINED>, 5412 Group<cl_compile_Group>, Flags<[CLOption, NoXarchOption]>; 5413 5414class CLIgnoredJoined<string name> : Option<["/", "-"], name, KIND_JOINED>, 5415 Group<cl_ignored_Group>, Flags<[CLOption, NoXarchOption, HelpHidden]>; 5416 5417class CLJoinedOrSeparate<string name> : Option<["/", "-"], name, 5418 KIND_JOINED_OR_SEPARATE>, Group<cl_Group>, Flags<[CLOption, NoXarchOption]>; 5419 5420class CLCompileJoinedOrSeparate<string name> : Option<["/", "-"], name, 5421 KIND_JOINED_OR_SEPARATE>, Group<cl_compile_Group>, 5422 Flags<[CLOption, NoXarchOption]>; 5423 5424class CLRemainingArgsJoined<string name> : Option<["/", "-"], name, 5425 KIND_REMAINING_ARGS_JOINED>, Group<cl_Group>, Flags<[CLOption, NoXarchOption]>; 5426 5427// Aliases: 5428// (We don't put any of these in cl_compile_Group as the options they alias are 5429// already in the right group.) 5430 5431def _SLASH_Brepro : CLFlag<"Brepro">, 5432 HelpText<"Do not write current time into COFF output (breaks link.exe /incremental)">, 5433 Alias<mno_incremental_linker_compatible>; 5434def _SLASH_Brepro_ : CLFlag<"Brepro-">, 5435 HelpText<"Write current time into COFF output (default)">, 5436 Alias<mincremental_linker_compatible>; 5437def _SLASH_C : CLFlag<"C">, 5438 HelpText<"Do not discard comments when preprocessing">, Alias<C>; 5439def _SLASH_c : CLFlag<"c">, HelpText<"Compile only">, Alias<c>; 5440def _SLASH_d1PP : CLFlag<"d1PP">, 5441 HelpText<"Retain macro definitions in /E mode">, Alias<dD>; 5442def _SLASH_d1reportAllClassLayout : CLFlag<"d1reportAllClassLayout">, 5443 HelpText<"Dump record layout information">, 5444 Alias<Xclang>, AliasArgs<["-fdump-record-layouts"]>; 5445def _SLASH_diagnostics_caret : CLFlag<"diagnostics:caret">, 5446 HelpText<"Enable caret and column diagnostics (default)">; 5447def _SLASH_diagnostics_column : CLFlag<"diagnostics:column">, 5448 HelpText<"Disable caret diagnostics but keep column info">; 5449def _SLASH_diagnostics_classic : CLFlag<"diagnostics:classic">, 5450 HelpText<"Disable column and caret diagnostics">; 5451def _SLASH_D : CLJoinedOrSeparate<"D">, HelpText<"Define macro">, 5452 MetaVarName<"<macro[=value]>">, Alias<D>; 5453def _SLASH_E : CLFlag<"E">, HelpText<"Preprocess to stdout">, Alias<E>; 5454def _SLASH_fp_except : CLFlag<"fp:except">, HelpText<"">, Alias<ftrapping_math>; 5455def _SLASH_fp_except_ : CLFlag<"fp:except-">, 5456 HelpText<"">, Alias<fno_trapping_math>; 5457def _SLASH_fp_fast : CLFlag<"fp:fast">, HelpText<"">, Alias<ffast_math>; 5458def _SLASH_fp_precise : CLFlag<"fp:precise">, 5459 HelpText<"">, Alias<fno_fast_math>; 5460def _SLASH_fp_strict : CLFlag<"fp:strict">, HelpText<"">, Alias<fno_fast_math>; 5461def _SLASH_GA : CLFlag<"GA">, Alias<ftlsmodel_EQ>, AliasArgs<["local-exec"]>, 5462 HelpText<"Assume thread-local variables are defined in the executable">; 5463def _SLASH_GR : CLFlag<"GR">, HelpText<"Emit RTTI data (default)">; 5464def _SLASH_GR_ : CLFlag<"GR-">, HelpText<"Do not emit RTTI data">; 5465def _SLASH_GF : CLIgnoredFlag<"GF">, 5466 HelpText<"Enable string pooling (default)">; 5467def _SLASH_GF_ : CLFlag<"GF-">, HelpText<"Disable string pooling">, 5468 Alias<fwritable_strings>; 5469def _SLASH_GS : CLFlag<"GS">, 5470 HelpText<"Enable buffer security check (default)">; 5471def _SLASH_GS_ : CLFlag<"GS-">, HelpText<"Disable buffer security check">; 5472def : CLFlag<"Gs">, HelpText<"Use stack probes (default)">, 5473 Alias<mstack_probe_size>, AliasArgs<["4096"]>; 5474def _SLASH_Gs : CLJoined<"Gs">, 5475 HelpText<"Set stack probe size (default 4096)">, Alias<mstack_probe_size>; 5476def _SLASH_Gy : CLFlag<"Gy">, HelpText<"Put each function in its own section">, 5477 Alias<ffunction_sections>; 5478def _SLASH_Gy_ : CLFlag<"Gy-">, 5479 HelpText<"Do not put each function in its own section (default)">, 5480 Alias<fno_function_sections>; 5481def _SLASH_Gw : CLFlag<"Gw">, HelpText<"Put each data item in its own section">, 5482 Alias<fdata_sections>; 5483def _SLASH_Gw_ : CLFlag<"Gw-">, 5484 HelpText<"Do not put each data item in its own section (default)">, 5485 Alias<fno_data_sections>; 5486def _SLASH_help : CLFlag<"help">, Alias<help>, 5487 HelpText<"Display available options">; 5488def _SLASH_HELP : CLFlag<"HELP">, Alias<help>; 5489def _SLASH_I : CLJoinedOrSeparate<"I">, 5490 HelpText<"Add directory to include search path">, MetaVarName<"<dir>">, 5491 Alias<I>; 5492def _SLASH_J : CLFlag<"J">, HelpText<"Make char type unsigned">, 5493 Alias<funsigned_char>; 5494 5495// The _SLASH_O option handles all the /O flags, but we also provide separate 5496// aliased options to provide separate help messages. 5497def _SLASH_O : CLJoined<"O">, 5498 HelpText<"Set multiple /O flags at once; e.g. '/O2y-' for '/O2 /Oy-'">, 5499 MetaVarName<"<flags>">; 5500def : CLFlag<"O1">, Alias<_SLASH_O>, AliasArgs<["1"]>, 5501 HelpText<"Optimize for size (like /Og /Os /Oy /Ob2 /GF /Gy)">; 5502def : CLFlag<"O2">, Alias<_SLASH_O>, AliasArgs<["2"]>, 5503 HelpText<"Optimize for speed (like /Og /Oi /Ot /Oy /Ob2 /GF /Gy)">; 5504def : CLFlag<"Ob0">, Alias<_SLASH_O>, AliasArgs<["b0"]>, 5505 HelpText<"Disable function inlining">; 5506def : CLFlag<"Ob1">, Alias<_SLASH_O>, AliasArgs<["b1"]>, 5507 HelpText<"Only inline functions explicitly or implicitly marked inline">; 5508def : CLFlag<"Ob2">, Alias<_SLASH_O>, AliasArgs<["b2"]>, 5509 HelpText<"Inline functions as deemed beneficial by the compiler">; 5510def : CLFlag<"Od">, Alias<_SLASH_O>, AliasArgs<["d"]>, 5511 HelpText<"Disable optimization">; 5512def : CLFlag<"Og">, Alias<_SLASH_O>, AliasArgs<["g"]>, 5513 HelpText<"No effect">; 5514def : CLFlag<"Oi">, Alias<_SLASH_O>, AliasArgs<["i"]>, 5515 HelpText<"Enable use of builtin functions">; 5516def : CLFlag<"Oi-">, Alias<_SLASH_O>, AliasArgs<["i-"]>, 5517 HelpText<"Disable use of builtin functions">; 5518def : CLFlag<"Os">, Alias<_SLASH_O>, AliasArgs<["s"]>, 5519 HelpText<"Optimize for size">; 5520def : CLFlag<"Ot">, Alias<_SLASH_O>, AliasArgs<["t"]>, 5521 HelpText<"Optimize for speed">; 5522def : CLFlag<"Ox">, Alias<_SLASH_O>, AliasArgs<["x"]>, 5523 HelpText<"Deprecated (like /Og /Oi /Ot /Oy /Ob2); use /O2">; 5524def : CLFlag<"Oy">, Alias<_SLASH_O>, AliasArgs<["y"]>, 5525 HelpText<"Enable frame pointer omission (x86 only)">; 5526def : CLFlag<"Oy-">, Alias<_SLASH_O>, AliasArgs<["y-"]>, 5527 HelpText<"Disable frame pointer omission (x86 only, default)">; 5528 5529def _SLASH_QUESTION : CLFlag<"?">, Alias<help>, 5530 HelpText<"Display available options">; 5531def _SLASH_Qvec : CLFlag<"Qvec">, 5532 HelpText<"Enable the loop vectorization passes">, Alias<fvectorize>; 5533def _SLASH_Qvec_ : CLFlag<"Qvec-">, 5534 HelpText<"Disable the loop vectorization passes">, Alias<fno_vectorize>; 5535def _SLASH_showIncludes : CLFlag<"showIncludes">, 5536 HelpText<"Print info about included files to stderr">; 5537def _SLASH_showIncludes_user : CLFlag<"showIncludes:user">, 5538 HelpText<"Like /showIncludes but omit system headers">; 5539def _SLASH_showFilenames : CLFlag<"showFilenames">, 5540 HelpText<"Print the name of each compiled file">; 5541def _SLASH_showFilenames_ : CLFlag<"showFilenames-">, 5542 HelpText<"Do not print the name of each compiled file (default)">; 5543def _SLASH_source_charset : CLCompileJoined<"source-charset:">, 5544 HelpText<"Set source encoding, supports only UTF-8">, 5545 Alias<finput_charset_EQ>; 5546def _SLASH_execution_charset : CLCompileJoined<"execution-charset:">, 5547 HelpText<"Set runtime encoding, supports only UTF-8">, 5548 Alias<fexec_charset_EQ>; 5549def _SLASH_std : CLCompileJoined<"std:">, 5550 HelpText<"Set C++ version (c++14,c++17,c++latest)">; 5551def _SLASH_U : CLJoinedOrSeparate<"U">, HelpText<"Undefine macro">, 5552 MetaVarName<"<macro>">, Alias<U>; 5553def _SLASH_validate_charset : CLFlag<"validate-charset">, 5554 Alias<W_Joined>, AliasArgs<["invalid-source-encoding"]>; 5555def _SLASH_validate_charset_ : CLFlag<"validate-charset-">, 5556 Alias<W_Joined>, AliasArgs<["no-invalid-source-encoding"]>; 5557def _SLASH_W0 : CLFlag<"W0">, HelpText<"Disable all warnings">, Alias<w>; 5558def _SLASH_W1 : CLFlag<"W1">, HelpText<"Enable -Wall">, Alias<Wall>; 5559def _SLASH_W2 : CLFlag<"W2">, HelpText<"Enable -Wall">, Alias<Wall>; 5560def _SLASH_W3 : CLFlag<"W3">, HelpText<"Enable -Wall">, Alias<Wall>; 5561def _SLASH_W4 : CLFlag<"W4">, HelpText<"Enable -Wall and -Wextra">, Alias<WCL4>; 5562def _SLASH_Wall : CLFlag<"Wall">, HelpText<"Enable -Weverything">, 5563 Alias<W_Joined>, AliasArgs<["everything"]>; 5564def _SLASH_WX : CLFlag<"WX">, HelpText<"Treat warnings as errors">, 5565 Alias<W_Joined>, AliasArgs<["error"]>; 5566def _SLASH_WX_ : CLFlag<"WX-">, 5567 HelpText<"Do not treat warnings as errors (default)">, 5568 Alias<W_Joined>, AliasArgs<["no-error"]>; 5569def _SLASH_w_flag : CLFlag<"w">, HelpText<"Disable all warnings">, Alias<w>; 5570def _SLASH_wd4005 : CLFlag<"wd4005">, Alias<W_Joined>, 5571 AliasArgs<["no-macro-redefined"]>; 5572def _SLASH_wd4018 : CLFlag<"wd4018">, Alias<W_Joined>, 5573 AliasArgs<["no-sign-compare"]>; 5574def _SLASH_wd4100 : CLFlag<"wd4100">, Alias<W_Joined>, 5575 AliasArgs<["no-unused-parameter"]>; 5576def _SLASH_wd4910 : CLFlag<"wd4910">, Alias<W_Joined>, 5577 AliasArgs<["no-dllexport-explicit-instantiation-decl"]>; 5578def _SLASH_wd4996 : CLFlag<"wd4996">, Alias<W_Joined>, 5579 AliasArgs<["no-deprecated-declarations"]>; 5580def _SLASH_vd : CLJoined<"vd">, HelpText<"Control vtordisp placement">, 5581 Alias<vtordisp_mode_EQ>; 5582def _SLASH_X : CLFlag<"X">, 5583 HelpText<"Do not add %INCLUDE% to include search path">, Alias<nostdlibinc>; 5584def _SLASH_Zc_sizedDealloc : CLFlag<"Zc:sizedDealloc">, 5585 HelpText<"Enable C++14 sized global deallocation functions">, 5586 Alias<fsized_deallocation>; 5587def _SLASH_Zc_sizedDealloc_ : CLFlag<"Zc:sizedDealloc-">, 5588 HelpText<"Disable C++14 sized global deallocation functions">, 5589 Alias<fno_sized_deallocation>; 5590def _SLASH_Zc_alignedNew : CLFlag<"Zc:alignedNew">, 5591 HelpText<"Enable C++17 aligned allocation functions">, 5592 Alias<faligned_allocation>; 5593def _SLASH_Zc_alignedNew_ : CLFlag<"Zc:alignedNew-">, 5594 HelpText<"Disable C++17 aligned allocation functions">, 5595 Alias<fno_aligned_allocation>; 5596def _SLASH_Zc_char8_t : CLFlag<"Zc:char8_t">, 5597 HelpText<"Enable char8_t from C++2a">, 5598 Alias<fchar8__t>; 5599def _SLASH_Zc_char8_t_ : CLFlag<"Zc:char8_t-">, 5600 HelpText<"Disable char8_t from c++2a">, 5601 Alias<fno_char8__t>; 5602def _SLASH_Zc_strictStrings : CLFlag<"Zc:strictStrings">, 5603 HelpText<"Treat string literals as const">, Alias<W_Joined>, 5604 AliasArgs<["error=c++11-compat-deprecated-writable-strings"]>; 5605def _SLASH_Zc_threadSafeInit : CLFlag<"Zc:threadSafeInit">, 5606 HelpText<"Enable thread-safe initialization of static variables">, 5607 Alias<fthreadsafe_statics>; 5608def _SLASH_Zc_threadSafeInit_ : CLFlag<"Zc:threadSafeInit-">, 5609 HelpText<"Disable thread-safe initialization of static variables">, 5610 Alias<fno_threadsafe_statics>; 5611def _SLASH_Zc_trigraphs : CLFlag<"Zc:trigraphs">, 5612 HelpText<"Enable trigraphs">, Alias<ftrigraphs>; 5613def _SLASH_Zc_trigraphs_off : CLFlag<"Zc:trigraphs-">, 5614 HelpText<"Disable trigraphs (default)">, Alias<fno_trigraphs>; 5615def _SLASH_Zc_twoPhase : CLFlag<"Zc:twoPhase">, 5616 HelpText<"Enable two-phase name lookup in templates">, 5617 Alias<fno_delayed_template_parsing>; 5618def _SLASH_Zc_twoPhase_ : CLFlag<"Zc:twoPhase-">, 5619 HelpText<"Disable two-phase name lookup in templates (default)">, 5620 Alias<fdelayed_template_parsing>; 5621def _SLASH_Z7 : CLFlag<"Z7">, 5622 HelpText<"Enable CodeView debug information in object files">; 5623def _SLASH_Zi : CLFlag<"Zi">, Alias<_SLASH_Z7>, 5624 HelpText<"Like /Z7">; 5625def _SLASH_Zp : CLJoined<"Zp">, 5626 HelpText<"Set default maximum struct packing alignment">, 5627 Alias<fpack_struct_EQ>; 5628def _SLASH_Zp_flag : CLFlag<"Zp">, 5629 HelpText<"Set default maximum struct packing alignment to 1">, 5630 Alias<fpack_struct_EQ>, AliasArgs<["1"]>; 5631def _SLASH_Zs : CLFlag<"Zs">, HelpText<"Syntax-check only">, 5632 Alias<fsyntax_only>; 5633def _SLASH_openmp_ : CLFlag<"openmp-">, 5634 HelpText<"Disable OpenMP support">, Alias<fno_openmp>; 5635def _SLASH_openmp : CLFlag<"openmp">, HelpText<"Enable OpenMP support">, 5636 Alias<fopenmp>; 5637def _SLASH_openmp_experimental : CLFlag<"openmp:experimental">, 5638 HelpText<"Enable OpenMP support with experimental SIMD support">, 5639 Alias<fopenmp>; 5640def _SLASH_tune : CLCompileJoined<"tune:">, 5641 HelpText<"Set CPU for optimization without affecting instruction set">, 5642 Alias<mtune_EQ>; 5643 5644// Non-aliases: 5645 5646def _SLASH_arch : CLCompileJoined<"arch:">, 5647 HelpText<"Set architecture for code generation">; 5648 5649def _SLASH_M_Group : OptionGroup<"</M group>">, Group<cl_compile_Group>; 5650def _SLASH_volatile_Group : OptionGroup<"</volatile group>">, 5651 Group<cl_compile_Group>; 5652 5653def _SLASH_EH : CLJoined<"EH">, HelpText<"Set exception handling model">; 5654def _SLASH_EP : CLFlag<"EP">, 5655 HelpText<"Disable linemarker output and preprocess to stdout">; 5656def _SLASH_FA : CLFlag<"FA">, 5657 HelpText<"Output assembly code file during compilation">; 5658def _SLASH_Fa : CLJoined<"Fa">, 5659 HelpText<"Set assembly output file name (with /FA)">, 5660 MetaVarName<"<file or dir/>">; 5661def _SLASH_fallback : CLCompileFlag<"fallback">, 5662 HelpText<"Fall back to cl.exe if clang-cl fails to compile">; 5663def _SLASH_FI : CLJoinedOrSeparate<"FI">, 5664 HelpText<"Include file before parsing">, Alias<include_>; 5665def _SLASH_Fe : CLJoined<"Fe">, 5666 HelpText<"Set output executable file name">, 5667 MetaVarName<"<file or dir/>">; 5668def _SLASH_Fe_COLON : CLJoined<"Fe:">, Alias<_SLASH_Fe>; 5669def _SLASH_Fi : CLCompileJoined<"Fi">, 5670 HelpText<"Set preprocess output file name (with /P)">, 5671 MetaVarName<"<file>">; 5672def _SLASH_Fo : CLCompileJoined<"Fo">, 5673 HelpText<"Set output object file (with /c)">, 5674 MetaVarName<"<file or dir/>">; 5675def _SLASH_guard : CLJoined<"guard:">, 5676 HelpText<"Enable Control Flow Guard with /guard:cf, or only the table with /guard:cf,nochecks">; 5677def _SLASH_GX : CLFlag<"GX">, 5678 HelpText<"Deprecated; use /EHsc">; 5679def _SLASH_GX_ : CLFlag<"GX-">, 5680 HelpText<"Deprecated (like not passing /EH)">; 5681def _SLASH_imsvc : CLJoinedOrSeparate<"imsvc">, 5682 HelpText<"Add <dir> to system include search path, as if in %INCLUDE%">, 5683 MetaVarName<"<dir>">; 5684def _SLASH_LD : CLFlag<"LD">, HelpText<"Create DLL">; 5685def _SLASH_LDd : CLFlag<"LDd">, HelpText<"Create debug DLL">; 5686def _SLASH_link : CLRemainingArgsJoined<"link">, 5687 HelpText<"Forward options to the linker">, MetaVarName<"<options>">; 5688def _SLASH_MD : Option<["/", "-"], "MD", KIND_FLAG>, Group<_SLASH_M_Group>, 5689 Flags<[CLOption, NoXarchOption]>, HelpText<"Use DLL run-time">; 5690def _SLASH_MDd : Option<["/", "-"], "MDd", KIND_FLAG>, Group<_SLASH_M_Group>, 5691 Flags<[CLOption, NoXarchOption]>, HelpText<"Use DLL debug run-time">; 5692def _SLASH_MT : Option<["/", "-"], "MT", KIND_FLAG>, Group<_SLASH_M_Group>, 5693 Flags<[CLOption, NoXarchOption]>, HelpText<"Use static run-time">; 5694def _SLASH_MTd : Option<["/", "-"], "MTd", KIND_FLAG>, Group<_SLASH_M_Group>, 5695 Flags<[CLOption, NoXarchOption]>, HelpText<"Use static debug run-time">; 5696def _SLASH_o : CLJoinedOrSeparate<"o">, 5697 HelpText<"Deprecated (set output file name); use /Fe or /Fe">, 5698 MetaVarName<"<file or dir/>">; 5699def _SLASH_P : CLFlag<"P">, HelpText<"Preprocess to file">; 5700def _SLASH_Tc : CLCompileJoinedOrSeparate<"Tc">, 5701 HelpText<"Treat <file> as C source file">, MetaVarName<"<file>">; 5702def _SLASH_TC : CLCompileFlag<"TC">, HelpText<"Treat all source files as C">; 5703def _SLASH_Tp : CLCompileJoinedOrSeparate<"Tp">, 5704 HelpText<"Treat <file> as C++ source file">, MetaVarName<"<file>">; 5705def _SLASH_TP : CLCompileFlag<"TP">, HelpText<"Treat all source files as C++">; 5706def _SLASH_vctoolsdir : CLJoinedOrSeparate<"vctoolsdir">, 5707 HelpText<"Path to the VCToolChain">, MetaVarName<"<dir>">; 5708def _SLASH_volatile_iso : Option<["/", "-"], "volatile:iso", KIND_FLAG>, 5709 Group<_SLASH_volatile_Group>, Flags<[CLOption, NoXarchOption]>, 5710 HelpText<"Volatile loads and stores have standard semantics">; 5711def _SLASH_vmb : CLFlag<"vmb">, 5712 HelpText<"Use a best-case representation method for member pointers">; 5713def _SLASH_vmg : CLFlag<"vmg">, 5714 HelpText<"Use a most-general representation for member pointers">; 5715def _SLASH_vms : CLFlag<"vms">, 5716 HelpText<"Set the default most-general representation to single inheritance">; 5717def _SLASH_vmm : CLFlag<"vmm">, 5718 HelpText<"Set the default most-general representation to " 5719 "multiple inheritance">; 5720def _SLASH_vmv : CLFlag<"vmv">, 5721 HelpText<"Set the default most-general representation to " 5722 "virtual inheritance">; 5723def _SLASH_volatile_ms : Option<["/", "-"], "volatile:ms", KIND_FLAG>, 5724 Group<_SLASH_volatile_Group>, Flags<[CLOption, NoXarchOption]>, 5725 HelpText<"Volatile loads and stores have acquire and release semantics">; 5726def _SLASH_clang : CLJoined<"clang:">, 5727 HelpText<"Pass <arg> to the clang driver">, MetaVarName<"<arg>">; 5728def _SLASH_Zl : CLFlag<"Zl">, 5729 HelpText<"Do not let object file auto-link default libraries">; 5730 5731def _SLASH_Yc : CLJoined<"Yc">, 5732 HelpText<"Generate a pch file for all code up to and including <filename>">, 5733 MetaVarName<"<filename>">; 5734def _SLASH_Yu : CLJoined<"Yu">, 5735 HelpText<"Load a pch file and use it instead of all code up to " 5736 "and including <filename>">, 5737 MetaVarName<"<filename>">; 5738def _SLASH_Y_ : CLFlag<"Y-">, 5739 HelpText<"Disable precompiled headers, overrides /Yc and /Yu">; 5740def _SLASH_Zc_dllexportInlines : CLFlag<"Zc:dllexportInlines">, 5741 HelpText<"dllexport/dllimport inline member functions of dllexport/import classes (default)">; 5742def _SLASH_Zc_dllexportInlines_ : CLFlag<"Zc:dllexportInlines-">, 5743 HelpText<"Do not dllexport/dllimport inline member functions of dllexport/import classes">; 5744def _SLASH_Fp : CLJoined<"Fp">, 5745 HelpText<"Set pch file name (with /Yc and /Yu)">, MetaVarName<"<file>">; 5746 5747def _SLASH_Gd : CLFlag<"Gd">, 5748 HelpText<"Set __cdecl as a default calling convention">; 5749def _SLASH_Gr : CLFlag<"Gr">, 5750 HelpText<"Set __fastcall as a default calling convention">; 5751def _SLASH_Gz : CLFlag<"Gz">, 5752 HelpText<"Set __stdcall as a default calling convention">; 5753def _SLASH_Gv : CLFlag<"Gv">, 5754 HelpText<"Set __vectorcall as a default calling convention">; 5755def _SLASH_Gregcall : CLFlag<"Gregcall">, 5756 HelpText<"Set __regcall as a default calling convention">; 5757 5758// Ignored: 5759 5760def _SLASH_analyze_ : CLIgnoredFlag<"analyze-">; 5761def _SLASH_bigobj : CLIgnoredFlag<"bigobj">; 5762def _SLASH_cgthreads : CLIgnoredJoined<"cgthreads">; 5763def _SLASH_d2FastFail : CLIgnoredFlag<"d2FastFail">; 5764def _SLASH_d2Zi_PLUS : CLIgnoredFlag<"d2Zi+">; 5765def _SLASH_errorReport : CLIgnoredJoined<"errorReport">; 5766def _SLASH_FC : CLIgnoredFlag<"FC">; 5767def _SLASH_Fd : CLIgnoredJoined<"Fd">; 5768def _SLASH_FS : CLIgnoredFlag<"FS">; 5769def _SLASH_JMC : CLIgnoredFlag<"JMC">; 5770def _SLASH_kernel_ : CLIgnoredFlag<"kernel-">; 5771def _SLASH_nologo : CLIgnoredFlag<"nologo">; 5772def _SLASH_permissive_ : CLIgnoredFlag<"permissive-">; 5773def _SLASH_RTC : CLIgnoredJoined<"RTC">; 5774def _SLASH_sdl : CLIgnoredFlag<"sdl">; 5775def _SLASH_sdl_ : CLIgnoredFlag<"sdl-">; 5776def _SLASH_utf8 : CLIgnoredFlag<"utf-8">, 5777 HelpText<"Set source and runtime encoding to UTF-8 (default)">; 5778def _SLASH_w : CLIgnoredJoined<"w">; 5779def _SLASH_Zc___cplusplus : CLIgnoredFlag<"Zc:__cplusplus">; 5780def _SLASH_Zc_auto : CLIgnoredFlag<"Zc:auto">; 5781def _SLASH_Zc_forScope : CLIgnoredFlag<"Zc:forScope">; 5782def _SLASH_Zc_inline : CLIgnoredFlag<"Zc:inline">; 5783def _SLASH_Zc_rvalueCast : CLIgnoredFlag<"Zc:rvalueCast">; 5784def _SLASH_Zc_ternary : CLIgnoredFlag<"Zc:ternary">; 5785def _SLASH_Zc_wchar_t : CLIgnoredFlag<"Zc:wchar_t">; 5786def _SLASH_ZH_MD5 : CLIgnoredFlag<"ZH:MD5">; 5787def _SLASH_ZH_SHA1 : CLIgnoredFlag<"ZH:SHA1">; 5788def _SLASH_ZH_SHA_256 : CLIgnoredFlag<"ZH:SHA_256">; 5789def _SLASH_Zm : CLIgnoredJoined<"Zm">; 5790def _SLASH_Zo : CLIgnoredFlag<"Zo">; 5791def _SLASH_Zo_ : CLIgnoredFlag<"Zo-">; 5792 5793 5794// Unsupported: 5795 5796def _SLASH_await : CLFlag<"await">; 5797def _SLASH_constexpr : CLJoined<"constexpr:">; 5798def _SLASH_AI : CLJoinedOrSeparate<"AI">; 5799def _SLASH_Bt : CLFlag<"Bt">; 5800def _SLASH_Bt_plus : CLFlag<"Bt+">; 5801def _SLASH_clr : CLJoined<"clr">; 5802def _SLASH_d2 : CLJoined<"d2">; 5803def _SLASH_doc : CLJoined<"doc">; 5804def _SLASH_FA_joined : CLJoined<"FA">; 5805def _SLASH_favor : CLJoined<"favor">; 5806def _SLASH_F : CLJoinedOrSeparate<"F">; 5807def _SLASH_Fm : CLJoined<"Fm">; 5808def _SLASH_Fr : CLJoined<"Fr">; 5809def _SLASH_FR : CLJoined<"FR">; 5810def _SLASH_FU : CLJoinedOrSeparate<"FU">; 5811def _SLASH_Fx : CLFlag<"Fx">; 5812def _SLASH_G1 : CLFlag<"G1">; 5813def _SLASH_G2 : CLFlag<"G2">; 5814def _SLASH_Ge : CLFlag<"Ge">; 5815def _SLASH_Gh : CLFlag<"Gh">; 5816def _SLASH_GH : CLFlag<"GH">; 5817def _SLASH_GL : CLFlag<"GL">; 5818def _SLASH_GL_ : CLFlag<"GL-">; 5819def _SLASH_Gm : CLFlag<"Gm">; 5820def _SLASH_Gm_ : CLFlag<"Gm-">; 5821def _SLASH_GT : CLFlag<"GT">; 5822def _SLASH_GZ : CLFlag<"GZ">; 5823def _SLASH_H : CLFlag<"H">; 5824def _SLASH_homeparams : CLFlag<"homeparams">; 5825def _SLASH_hotpatch : CLFlag<"hotpatch">; 5826def _SLASH_kernel : CLFlag<"kernel">; 5827def _SLASH_LN : CLFlag<"LN">; 5828def _SLASH_MP : CLJoined<"MP">; 5829def _SLASH_Qfast_transcendentals : CLFlag<"Qfast_transcendentals">; 5830def _SLASH_QIfist : CLFlag<"QIfist">; 5831def _SLASH_QIntel_jcc_erratum : CLFlag<"QIntel-jcc-erratum">; 5832def _SLASH_Qimprecise_fwaits : CLFlag<"Qimprecise_fwaits">; 5833def _SLASH_Qpar : CLFlag<"Qpar">; 5834def _SLASH_Qpar_report : CLJoined<"Qpar-report">; 5835def _SLASH_Qsafe_fp_loads : CLFlag<"Qsafe_fp_loads">; 5836def _SLASH_Qspectre : CLFlag<"Qspectre">; 5837def _SLASH_Qspectre_load : CLFlag<"Qspectre-load">; 5838def _SLASH_Qspectre_load_cf : CLFlag<"Qspectre-load-cf">; 5839def _SLASH_Qvec_report : CLJoined<"Qvec-report">; 5840def _SLASH_u : CLFlag<"u">; 5841def _SLASH_V : CLFlag<"V">; 5842def _SLASH_WL : CLFlag<"WL">; 5843def _SLASH_Wp64 : CLFlag<"Wp64">; 5844def _SLASH_Yd : CLFlag<"Yd">; 5845def _SLASH_Yl : CLJoined<"Yl">; 5846def _SLASH_Za : CLFlag<"Za">; 5847def _SLASH_Zc : CLJoined<"Zc:">; 5848def _SLASH_Ze : CLFlag<"Ze">; 5849def _SLASH_Zg : CLFlag<"Zg">; 5850def _SLASH_ZI : CLFlag<"ZI">; 5851def _SLASH_ZW : CLJoined<"ZW">; 5852