/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Option Parsing Definitions                                                 *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

/////////
// Prefixes

#ifdef PREFIX
#define COMMA ,
PREFIX(prefix_0, {llvm::StringLiteral("")})
PREFIX(prefix_1, {llvm::StringLiteral("-") COMMA llvm::StringLiteral("")})
PREFIX(prefix_4, {llvm::StringLiteral("-") COMMA llvm::StringLiteral("--") COMMA llvm::StringLiteral("")})
PREFIX(prefix_3, {llvm::StringLiteral("--") COMMA llvm::StringLiteral("")})
PREFIX(prefix_5, {llvm::StringLiteral("--") COMMA llvm::StringLiteral("/") COMMA llvm::StringLiteral("-") COMMA llvm::StringLiteral("")})
PREFIX(prefix_2, {llvm::StringLiteral("/") COMMA llvm::StringLiteral("-") COMMA llvm::StringLiteral("")})
#undef COMMA
#endif // PREFIX

/////////
// Prefix Union

#ifdef PREFIX_UNION
#define COMMA ,
PREFIX_UNION({
llvm::StringLiteral("-") COMMA llvm::StringLiteral("--") COMMA llvm::StringLiteral("/") COMMA llvm::StringLiteral("")})
#undef COMMA
#endif // PREFIX_UNION

/////////
// ValuesCode

#ifdef OPTTABLE_VALUES_CODE
#define VALUES_CODE analyzer_checker_Values

    static constexpr const char VALUES_CODE [] =
    #define GET_CHECKERS
    #define CHECKER(FULLNAME, CLASS, HT, DOC_URI, IS_HIDDEN)  FULLNAME ","
    #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
    #undef GET_CHECKERS
    #define GET_PACKAGES
    #define PACKAGE(FULLNAME)  FULLNAME ","
    #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
    #undef GET_PACKAGES
    ;
  
#undef VALUES_CODE
#define VALUES_CODE std_EQ_Values

    static constexpr const char VALUES_CODE [] =
    #define LANGSTANDARD(id, name, lang, desc, features) name ","
    #define LANGSTANDARD_ALIAS(id, alias) alias ","
    #include "clang/Basic/LangStandards.def"
    ;
  
#undef VALUES_CODE
#endif
/////////
// Groups

#ifdef OPTION
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<action group>", Action_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<CompileOnly group>", CompileOnly_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<g group>", DebugInfo_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<W/R group>", Diag_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<I group>", I_Group, Group, IncludePath_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<I/i group>", IncludePath_Group, Group, Preprocessor_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<T/e/s/t/u group>", Link_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<LongDouble group>", LongDouble_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<M group>", M_Group, Group, Preprocessor_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<O group>", O_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<Preprocessor group>", Preprocessor_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<R group>", R_Group, Group, Diag_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<R (with value) group>", R_value_Group, Group, R_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<Static analyzer group>", StaticAnalyzer_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<T group>", T_Group, Group, Link_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<W group>", W_Group, Group, Diag_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<W (with value) group>", W_value_Group, Group, W_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "</M group>", _SLASH_M_Group, Group, cl_compile_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "</volatile group>", _SLASH_volatile_Group, Group, cl_compile_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang-cl options>", cl_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0,
       "CL.EXE COMPATIBILITY OPTIONS", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang-cl compile-only options>", cl_compile_Group, Group, cl_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang-cl ignored options>", cl_ignored_Group, Group, cl_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang i group>", clang_i_Group, Group, i_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang ignored f group>", clang_ignored_f_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang_ignored_gcc_optimization_f_Group>", clang_ignored_gcc_optimization_f_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang legacy flags>", clang_ignored_legacy_options_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang ignored m group>", clang_ignored_m_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<CUDA group>", cuda_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<d group>", d_Group, Group, Preprocessor_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "clang-dxc options", dxc_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0,
       "dxc compatibility options.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<f group>", f_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<f (clang-only) group>", f_clang_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<flang ignored W group>", flang_ignored_w_Group, Group, W_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<gN group>", gN_Group, Group, g_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<gTune group>", gTune_Group, Group, g_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<g group>", g_Group, Group, DebugInfo_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<g flags group>", g_flags_Group, Group, DebugInfo_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<gfortran group>", gfortran_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<ggdbN group>", ggdbN_Group, Group, gN_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<HIP group>", hip_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<HLSL group>", hlsl_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<i group>", i_Group, Group, IncludePath_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang internal options>", internal_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang debug/development internal options>", internal_debug_Group, Group, internal_Group, INVALID, nullptr, 0, 0, 0,
       "DEBUG/DEVELOPMENT OPTIONS", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<clang driver internal options>", internal_driver_Group, Group, internal_Group, INVALID, nullptr, 0, 0, 0,
       "DRIVER OPTIONS", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<m group>", m_Group, Group, CompileOnly_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<aarch64 features group>", m_aarch64_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<amdgpu features group>", m_amdgpu_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<arm features group>", m_arm_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<hexagon features group>", m_hexagon_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<hexagon features group>", m_hexagon_Features_HVX_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<m libc group>", m_libc_Group, Group, m_mips_Features_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<loongarch features group>", m_loongarch_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<m68k features group>", m_m68k_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<mips features group>", m_mips_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<ppc features group>", m_ppc_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<riscv features group>", m_riscv_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<sparc features group>", m_sparc_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<ve features group>", m_ve_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<wasm driver features group>", m_wasm_Features_Driver_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<wasm features group>", m_wasm_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<x86 AVX10 features group>", m_x86_AVX10_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<x86 features group>", m_x86_Features_Group, Group, m_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<offload group>", offload_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<opencl group>", opencl_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<pedantic group>", pedantic_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<reserved libs group>", reserved_lib_Group, Group, INVALID, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<SYCL group>", sycl_Group, Group, f_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(llvm::ArrayRef<llvm::StringLiteral>(), "<u group>", u_Group, Group, Link_Group, INVALID, nullptr, 0, 0, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)

//////////
// Options

OPTION(prefix_0, "<input>", INPUT, Input, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_0, "<unknown>", UNKNOWN, Unknown, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-###", _HASH_HASH_HASH, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Print (but do not run) the commands to run for this compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/?", _SLASH_QUESTION, Flag, cl_Group, help, nullptr, NoXarchOption, CLOption, 0,
       "Display available options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-A-", A_DASH, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-add-plugin", add_plugin, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the named plugin action in addition to the default action", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>", nullptr)
OPTION(prefix_2, "/AI", _SLASH_AI, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-alias_list", alias_list, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--all-warnings", _all_warnings, Flag, INVALID, Wall, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-all_load", all__load, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-allowable_client", allowable__client, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--amdgpu-arch-tool=", amdgpu_arch_tool_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Tool used for detecting AMD GPU arch in the system.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyze-function=", analyze_function_EQ, Joined, INVALID, analyze_function, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyze-function", analyze_function, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run analysis on specific function (for C++ include parameters in name)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/analyze-", _SLASH_analyze_, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker-help-alpha", analyzer_checker_help_alpha, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of in development analyzer checkers. These are NOT considered safe, they are unstable and will emit incorrect reports. Enable ONLY FOR DEVELOPMENT purposes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker-help-developer", analyzer_checker_help_developer, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of developer-only checkers such as modeling and debug checkers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker-help", analyzer_checker_help, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of analyzer checkers that are available", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker-option-help-alpha", analyzer_checker_option_help_alpha, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of in development checker and package options. These are NOT considered safe, they are unstable and will emit incorrect reports. Enable ONLY FOR DEVELOPMENT purposes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker-option-help-developer", analyzer_checker_option_help_developer, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of checker and package options meant for development purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker-option-help", analyzer_checker_option_help, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of checker and package options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker=", analyzer_checker_EQ, Joined, INVALID, analyzer_checker, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-checker", analyzer_checker, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Choose analyzer checkers to enable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, analyzer_checker_Values)
OPTION(prefix_1, "-analyzer-config-compatibility-mode=", analyzer_config_compatibility_mode_EQ, Joined, INVALID, analyzer_config_compatibility_mode, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-config-compatibility-mode", analyzer_config_compatibility_mode, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't emit errors on invalid analyzer-config inputs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "true,false")
OPTION(prefix_1, "-analyzer-config-help", analyzer_config_help, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of -analyzer-config options. These are meant for development purposes only!", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-config", analyzer_config, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Choose analyzer options to enable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-constraints=", analyzer_constraints_EQ, Joined, INVALID, analyzer_constraints, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-constraints", analyzer_constraints, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Source Code Analysis - Symbolic Constraint Engines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-disable-all-checks", analyzer_disable_all_checks, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable all static analyzer checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-disable-checker=", analyzer_disable_checker_EQ, Joined, INVALID, analyzer_disable_checker, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-disable-checker", analyzer_disable_checker, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Choose analyzer checkers to disable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-disable-retry-exhausted", analyzer_disable_retry_exhausted, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-display-progress", analyzer_display_progress, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit verbose output about the analyzer's progress", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-dump-egraph=", analyzer_dump_egraph_EQ, Joined, INVALID, analyzer_dump_egraph, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-dump-egraph", analyzer_dump_egraph, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump exploded graph to the specified file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-inline-max-stack-depth=", analyzer_inline_max_stack_depth_EQ, Joined, INVALID, analyzer_inline_max_stack_depth, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-inline-max-stack-depth", analyzer_inline_max_stack_depth, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Bound on stack depth while inlining (4 by default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-inlining-mode=", analyzer_inlining_mode_EQ, Joined, INVALID, analyzer_inlining_mode, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-inlining-mode", analyzer_inlining_mode, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Specify the function selection heuristic used during inlining", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-list-enabled-checkers", analyzer_list_enabled_checkers, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of enabled analyzer checkers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-max-loop", analyzer_max_loop, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The maximum number of times the analyzer will go through a loop", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--analyzer-no-default-checks", _analyzer_no_default_checks, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-note-analysis-entry-points", analyzer_note_analysis_entry_points, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add a note for each bug report to denote their analysis entry points", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-opt-analyze-headers", analyzer_opt_analyze_headers, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Force the static analyzer to analyze functions defined in header files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-output=", analyzer_output_EQ, Joined, INVALID, analyzer_output, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--analyzer-output", _analyzer_output, JoinedOrSeparate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Static analyzer report output format (html|plist|plist-multi-file|plist-html|sarif|sarif-html|text).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-output", analyzer_output, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Source Code Analysis - Output Options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-purge=", analyzer_purge_EQ, Joined, INVALID, analyzer_purge, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-purge", analyzer_purge, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Source Code Analysis - Dead Symbol Removal Frequency", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-stats", analyzer_stats, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print internal analyzer statistics.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-viz-egraph-graphviz", analyzer_viz_egraph_graphviz, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display exploded graph using GraphViz", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyzer-werror", analyzer_werror, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit analyzer results as errors rather than warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--analyze", _analyze, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "Run the static analyzer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-analyze", analyze, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Run static analysis engine", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-ansi", ansi, Flag, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/arch:", _SLASH_arch, Joined, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set architecture for code generation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-arch_errors_fatal", arch__errors__fatal, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-arch_only", arch__only, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-arch", arch, Separate, INVALID, INVALID, nullptr, NoXarchOption | TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-arcmt-action=", arcmt_action_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The ARC migration action to take", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "check,modify,migrate")
OPTION(prefix_1, "-arcmt-migrate-emit-errors", arcmt_migrate_emit_arc_errors, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit ARC errors even if the migrator can fix them", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-arcmt-migrate-report-output", arcmt_migrate_report_output, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Output path for the plist report", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/arm64EC", _SLASH_arm64EC, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set build target to arm64ec", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-as-secure-log-file", as_secure_log_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Emit .secure_log_unique directives to this filename.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--assemble", _assemble, Flag, INVALID, S, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--assert=", _assert_EQ, Joined, INVALID, A, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--assert", _assert, Separate, INVALID, A, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump-all=", ast_dump_all_EQ, Joined, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then debug dump them in the specified format, forcing deserialization. Supported formats include: default, json", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump-all", ast_dump_all, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then debug dump them, forcing deserialization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump-decl-types", ast_dump_decl_types, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Include declaration types in AST dumps", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump-filter=", ast_dump_filter_EQ, Joined, INVALID, ast_dump_filter, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump-filter", ast_dump_filter, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use with -ast-dump or -ast-print to dump/print only AST declaration nodes having a certain substring in a qualified name. Use -ast-list to list all filterable declaration node names.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dump_filter>", nullptr)
OPTION(prefix_1, "-ast-dump-lookups", ast_dump_lookups, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then debug dump their name lookup tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump=", ast_dump_EQ, Joined, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then debug dump them in the specified format. Supported formats include: default, json", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-dump", ast_dump, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then debug dump them", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-list", ast_list, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and print the list of declaration node qualified names", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-merge", ast_merge, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Merge the given AST file into the translation unit being compiled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<ast file>", nullptr)
OPTION(prefix_1, "-ast-print", ast_print, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then pretty-print them", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ast-view", ast_view, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and view them with GraphViz", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--autocomplete=", autocomplete, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-aux-target-cpu", aux_target_cpu, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Target a specific auxiliary cpu type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-aux-target-feature", aux_target_feature, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Target specific auxiliary attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-aux-triple", aux_triple, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Auxiliary target triple.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/await:", _SLASH_await_COLON, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/await", _SLASH_await, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-A", A, JoinedOrSeparate, gfortran_Group, INVALID, nullptr, RenderJoined, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/bigobj", _SLASH_bigobj, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-bind_at_load", bind__at__load, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--bootclasspath=", _bootclasspath_EQ, Joined, INVALID, fbootclasspath_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--bootclasspath", _bootclasspath, Separate, INVALID, fbootclasspath_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Brepro-", _SLASH_Brepro_, Flag, cl_Group, mincremental_linker_compatible, nullptr, NoXarchOption, CLOption, 0,
       "Write current time into COFF output (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Brepro", _SLASH_Brepro, Flag, cl_Group, mno_incremental_linker_compatible, nullptr, NoXarchOption, CLOption, 0,
       "Do not write current time into COFF output (breaks link.exe /incremental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Bt+", _SLASH_Bt_plus, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Bt", _SLASH_Bt, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-building-pch-with-obj", building_pch_with_obj, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "This compilation is part of building a PCH with corresponding object file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-bundle_loader", bundle__loader, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-bundle", bundle, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-B", B, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Search $prefix$file for executables, libraries, and data files. If $prefix is a directory, search $prefix/$file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<prefix>", nullptr)
OPTION(prefix_1, "-b", b, JoinedOrSeparate, Link_Group, INVALID, nullptr, LinkerInput, DefaultVis, 0,
       "Pass -b <arg> to the linker on AIX", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-c-isystem", c_isystem, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add directory to the C SYSTEM include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-canonical-prefixes", canonical_prefixes, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Use absolute paths for invoking subcommands (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cc1as", cc1as, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cc1", cc1, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-arcmt-check", ccc_arcmt_check, Flag, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis, 0,
       "Check for ARC migration issues that need manual handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-arcmt-migrate", ccc_arcmt_migrate, Separate, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis, 0,
       "Apply modifications and produces temporary files that conform to ARC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-arcmt-modify", ccc_arcmt_modify, Flag, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis, 0,
       "Apply modifications to files to conform to ARC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-gcc-name", ccc_gcc_name, Separate, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis, 0,
       "Name for native GCC compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<gcc-path>", nullptr)
OPTION(prefix_1, "-ccc-install-dir", ccc_install_dir, Separate, internal_debug_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Simulate installation in the given directory", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-objcmt-migrate", ccc_objcmt_migrate, Separate, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis, 0,
       "Apply modifications and produces temporary files to migrate to modern ObjC syntax", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-print-bindings", ccc_print_bindings, Flag, internal_debug_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Show bindings of tools to actions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-print-phases", ccc_print_phases, Flag, INVALID, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Dump list of actions to perform", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ccc-", ccc_, Joined, internal_Group, INVALID, nullptr, Unsupported | HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-CC", CC, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include comments from within macros in preprocessed output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cfg-add-implicit-dtors", analysis_CFGAddImplicitDtors, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add C++ implicit destructors to CFGs for all analyses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cfguard-no-checks", cfguard_no_checks, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit Windows Control Flow Guard tables only (no checks)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cfguard", cfguard, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit Windows Control Flow Guard tables and checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/cgthreads", _SLASH_cgthreads, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-chain-include", chain_include, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include and chain a header file after turning it into PCH", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-cl-denorms-are-zero", cl_denorms_are_zero, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "OpenCL only. Allow denormals to be flushed to zero.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-ext=", cl_ext_EQ, CommaJoined, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Enable or disable OpenCL extensions/optional features. The argument is a comma-separated sequence of one or more extension names, each prefixed by '+' or '-'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-fast-relaxed-math", cl_fast_relaxed_math, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-finite-math-only", cl_finite_math_only, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-fp32-correctly-rounded-divide-sqrt", cl_fp32_correctly_rounded_divide_sqrt, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-kernel-arg-info", cl_kernel_arg_info, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Generate kernel argument metadata.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-mad-enable", cl_mad_enable, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow use of less precise MAD computations in the generated binary.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-no-signed-zeros", cl_no_signed_zeros, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-no-stdinc", cl_no_stdinc, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "OpenCL only. Disables all standard includes containing non-native compiler types and functions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-opt-disable", cl_opt_disable, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. This option disables all optimizations. By default optimizations are enabled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-single-precision-constant", cl_single_precision_constant, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Treat double precision floating-point constant as single precision constant.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-std=", cl_std_EQ, Joined, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL language standard to compile for.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "cl,CL,cl1.0,CL1.0,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,cl3.0,CL3.0,clc++,CLC++,clc++1.0,CLC++1.0,clc++2021,CLC++2021")
OPTION(prefix_1, "-cl-strict-aliasing", cl_strict_aliasing, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. This option is added for compatibility with OpenCL 1.0.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-uniform-work-group-size", cl_uniform_work_group_size, Flag, opencl_Group, foffload_uniform_block, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cl-unsafe-math-optimizations", cl_unsafe_math_optimizations, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow unsafe floating-point optimizations.  Also implies -cl-no-signed-zeros and -cl-mad-enable.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/clang:", _SLASH_clang, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Pass <arg> to the clang driver", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_3, "--CLASSPATH=", _CLASSPATH_EQ, Joined, INVALID, fclasspath_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--classpath=", _classpath_EQ, Joined, INVALID, fclasspath_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--CLASSPATH", _CLASSPATH, Separate, INVALID, fclasspath_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--classpath", _classpath, Separate, INVALID, fclasspath_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-clear-ast-before-backend", clear_ast_before_backend, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Clear the Clang AST before running backend code generation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-client_name", client__name, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/clr", _SLASH_clr, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-code-completion-at=", code_completion_at_EQ, Joined, INVALID, code_completion_at, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-code-completion-at", code_completion_at, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump code-completion information at a location", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>:<line>:<column>", nullptr)
OPTION(prefix_1, "-code-completion-brief-comments", code_completion_brief_comments, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include brief documentation comments in code-completion results.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-code-completion-macros", code_completion_macros, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include macros in code-completion results", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-code-completion-patterns", code_completion_patterns, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include code patterns in code-completion results", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-code-completion-with-fixits", code_completion_with_fixits, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include code completion results which require small fix-its.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-combine", combine, Flag, INVALID, INVALID, nullptr, NoXarchOption | Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--comments-in-macros", _comments_in_macros, Flag, INVALID, CC, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--comments", _comments, Flag, INVALID, C, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-compatibility_version", compatibility__version, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-compiler-options-dump", compiler_options_dump, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Dump the compiler configuration options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--compile", _compile, Flag, INVALID, c, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-complex-range=", complex_range_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "full,improved,promoted,basic")
OPTION(prefix_4, "-compress-debug-sections=", compress_debug_sections_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "DWARF debug sections compression type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,zlib,zstd")
OPTION(prefix_4, "-compress-debug-sections", compress_debug_sections, Flag, INVALID, compress_debug_sections_EQ, "zlib\0", 0, CC1Option | CC1AsOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--config-system-dir=", config_system_dir_EQ, Joined, INVALID, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "System directory for configuration files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--config-user-dir=", config_user_dir_EQ, Joined, INVALID, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "User directory for configuration files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--config=", config, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Specify configuration file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_3, "--config", anonymous_94, Separate, INVALID, config, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--constant-cfstrings", _constant_cfstrings, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/constexpr:", _SLASH_constexpr, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-coverage-data-file=", anonymous_1859, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-coverage-notes-file=", anonymous_1861, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-coverage-version=", coverage_version_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Four-byte version string for gcov files.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-coverage", coverage, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cpp-precomp", cpp_precomp, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cpp", cpp, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Enable predefined and command line preprocessor macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--crel", crel, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Enable CREL relocation format (ELF only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-compile-host-device", cuda_compile_host_device, Flag, cuda_Group, offload_host_device, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Compile CUDA code for both host and device (default). Has no effect on non-CUDA compilations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-device-only", cuda_device_only, Flag, cuda_Group, offload_device_only, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Compile CUDA code for device only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-feature=", cuda_feature_EQ, Joined, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Manually specify the CUDA feature to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-gpu-arch=", cuda_gpu_arch_EQ, Joined, cuda_Group, offload_arch_EQ, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-host-only", cuda_host_only, Flag, cuda_Group, offload_host_only, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Compile CUDA code for host only. Has no effect on non-CUDA compilations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-include-ptx=", cuda_include_ptx_EQ, Joined, cuda_Group, INVALID, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0,
       "Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-noopt-device-debug", cuda_noopt_device_debug, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable device-side debug info generation. Disables ptxas optimizations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-path-ignore-env", cuda_path_ignore_env, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Ignore environment variables to detect CUDA installation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--cuda-path=", cuda_path_EQ, Joined, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "CUDA installation path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cuid=", cuid_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "An ID for compilation unit, which should be the same for the same compilation unit but different for different compilation units. It is used to externalize device-side static variables for single source offloading languages CUDA and HIP so that they can be accessed by the host code of the same compilation unit.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-current_version", current__version, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-cxx-isystem", cxx_isystem, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to the C++ SYSTEM include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-C", C, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include comments in preprocessed output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/C", _SLASH_C, Flag, cl_Group, C, nullptr, NoXarchOption, CLOption, 0,
       "Do not discard comments when preprocessing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-c", c, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | FlangOption, 0,
       "Only run preprocess, compile, and assemble steps", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/c", _SLASH_c, Flag, cl_Group, c, nullptr, NoXarchOption, CLOption, 0,
       "Compile only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/d1PP", _SLASH_d1PP, Flag, cl_Group, dD, nullptr, NoXarchOption, CLOption, 0,
       "Retain macro definitions in /E mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/d1reportAllClassLayout", _SLASH_d1reportAllClassLayout, Flag, cl_Group, Xclang, "-fdump-record-layouts\0", NoXarchOption, CLOption, 0,
       "Dump record layout information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/d1", _SLASH_d1, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/d2FastFail", _SLASH_d2FastFail, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/d2Zi+", _SLASH_d2Zi_PLUS, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/d2", _SLASH_d2, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-darwin-target-variant-sdk-version=", darwin_target_variant_sdk_version_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "The version of darwin target variant SDK used for compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-darwin-target-variant-triple", darwin_target_variant_triple, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Specify the darwin target variant triple", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-darwin-target-variant", darwin_target_variant, Separate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "Generate code for an additional runtime variant of the deployment target", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dA", dA, Flag, INVALID, fverbose_asm, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dD", dD, Flag, d_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print macro definitions in -E mode in addition to normal output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dead_strip", dead__strip, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-debug-forward-template-params", debug_forward_template_params, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit complete descriptions of template parameters in forward declarations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-debug-info-kind=", debug_info_kind_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-debug-info-macro", debug_info_macro, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Emit macro debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--debug=", _debug_EQ, Joined, INVALID, g_Flag, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-debugger-tuning=", debugger_tuning_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "gdb,lldb,sce,dbx")
OPTION(prefix_3, "--debug", _debug, Flag, INVALID, g_Flag, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-default-function-attr", default_function_attr, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Apply given attribute to all functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--define-macro=", _define_macro_EQ, Joined, INVALID, D, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--define-macro", _define_macro, Separate, INVALID, D, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--defsym", defsym, Separate, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "Define a value for a symbol", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--dependencies", _dependencies, Flag, INVALID, M, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dependency-dot", dependency_dot, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Filename to write DOT-formatted header dependencies to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dependency-file", dependency_file, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Filename (or -) to write dependency output to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--dependent-lib=", dependent_lib, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Add dependent library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-detailed-preprocessing-record", detailed_preprocessing_record, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "include a detailed record of preprocessing actions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dE", dE, Flag, d_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Print embed directives in -E mode in addition to normal output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-diagnostic-log-file", diagnostic_log_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename (or -) to log diagnostics to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/diagnostics:caret", _SLASH_diagnostics_caret, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Enable caret and column diagnostics (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/diagnostics:classic", _SLASH_diagnostics_classic, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable column and caret diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/diagnostics:column", _SLASH_diagnostics_column, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable caret diagnostics but keep column info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/diasdkdir", _SLASH_diasdkdir, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Path to the DIA SDK", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-disable-free", disable_free, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable freeing of memory on exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-lifetime-markers", disable_lifetimemarkers, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable lifetime-markers emission even when optimizations are enabled", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-llvm-optzns", disable_llvm_optzns, Flag, INVALID, disable_llvm_passes, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-llvm-passes", disable_llvm_passes, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use together with -emit-llvm to get pristine LLVM IR from the frontend by not running any LLVM passes at all", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-llvm-verifier", disable_llvm_verifier, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't run the LLVM IR verifier pass", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-O0-optnone", disable_O0_optnone, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable adding the optnone attribute to functions at O0", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-objc-default-synthesize-properties", disable_objc_default_synthesize_properties, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "disable the default synthesis of Objective-C properties", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-pragma-debug-crash", disable_pragma_debug_crash, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable any #pragma clang __debug that can lead to crashing behavior. This is meant for testing.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-disable-red-zone", disable_red_zone, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not emit code that uses the red zone.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-discard-value-names", discard_value_names, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Discard value names in LLVM IR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dI", dI, Flag, d_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print include directives in -E mode in addition to normal output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dM", dM, Flag, d_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Print macro definitions in -E mode instead of normal output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/doc", _SLASH_doc, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--driver-mode=", driver_mode, Joined, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | FlangOption | CLOption | DXCOption, 0,
       "Set the driver mode to either 'gcc', 'g++', 'cpp', 'cl' or 'flang'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dsym-dir", dsym_dir, JoinedOrSeparate, INVALID, INVALID, nullptr, NoXarchOption | RenderAsInput, DefaultVis, 0,
       "Directory to output dSYM's (if any) to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-dump-coverage-mapping", dump_coverage_mapping, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump the coverage mapping records, for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dump-deserialized-decls", dump_deserialized_pch_decls, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump declarations that are deserialized from PCH, for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dump-raw-tokens", dump_raw_tokens, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Lex file in raw mode and dump raw tokens", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dump-tokens", dump_tokens, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Run preprocessor, dump internal rep of tokens", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dumpdir", dumpdir, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use <dumpfpx> as a prefix to form auxiliary and dump file names", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dumppfx>", nullptr)
OPTION(prefix_1, "-dumpmachine", dumpmachine, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Display the compiler's target processor", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dumpspecs", dumpspecs, Flag, INVALID, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dumpversion", dumpversion, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Display the version of the compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dwarf-debug-flags", dwarf_debug_flags, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "The string to embed in the Dwarf debug flags record.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dwarf-debug-producer", dwarf_debug_producer, Separate, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "The string to embed in the Dwarf debug AT_producer record.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dwarf-explicit-import", dwarf_explicit_import, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate explicit import from anonymous namespace to containing scope", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dwarf-ext-refs", dwarf_ext_refs, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate debug info with external references to clang modules or precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dwarf-version=", dwarf_version_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--dxv-path=", dxc_validator_path_EQ, Joined, dxc_Group, INVALID, nullptr, 0, DefaultVis | DXCOption, 0,
       "DXIL validator installation path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--dyld-prefix=", _dyld_prefix_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--dyld-prefix", _dyld_prefix, Separate, INVALID, _dyld_prefix_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dylib_file", dylib__file, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dylinker_install_name", dylinker__install__name, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dylinker", dylinker, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dynamiclib", dynamiclib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-dynamic", dynamic, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-D", D, JoinedOrSeparate, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option | DXCOption, 0,
       "Define <macro> to <value> (or 1 if <value> omitted)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<macro>=<value>", nullptr)
OPTION(prefix_2, "/D", _SLASH_D, JoinedOrSeparate, cl_Group, D, nullptr, NoXarchOption, CLOption | DXCOption, 0,
       "Define macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<macro[=value]>", nullptr)
OPTION(prefix_1, "-d", d_Flag, Flag, d_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-d", d_Joined, Joined, d_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-EB", EB, Flag, INVALID, mbig_endian, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ehcontguard", ehcontguard, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit Windows EH Continuation Guard tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/EH", _SLASH_EH, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set exception handling model", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-EL", EL, Flag, INVALID, mlittle_endian, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--embed-dir=", embed_dir_EQ, Joined, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to embed search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-emit-ast", emit_ast, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Emit Clang AST files for source inputs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-cir", emit_cir, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then lower to ClangIR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-codegen-only", emit_codegen_only, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Generate machine code, but discard output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--emit-extension-symbol-graphs", emit_extension_symbol_graphs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate additional symbol graphs for extended modules.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-fir", emit_fir, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Build the parse tree, then lower it to FIR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-header-unit", emit_header_unit, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Generate C++20 header units from header files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-hlfir", emit_hlfir, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Build the parse tree, then lower it to HLFIR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-html", emit_html, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Output input source as HTML", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-interface-stubs", emit_interface_stubs, Flag, Action_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate Interface Stub Files.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-llvm-bc", emit_llvm_bc, Flag, Action_Group, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Build ASTs then convert to LLVM, emit .bc file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-llvm-only", emit_llvm_only, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and convert to LLVM, discarding output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-llvm-uselists", emit_llvm_uselists, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve order of LLVM use-lists when serializing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-llvm", emit_llvm, Flag, Action_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Use the LLVM representation for assembler and object files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-merged-ifs", emit_merged_ifs, Flag, Action_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate Interface Stub Files, emit merged text not binary.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-mlir", emit_mlir, Flag, INVALID, emit_fir, nullptr, 0, FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-module-interface", emit_module_interface, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Generate pre-compiled module file from a standard C++ module interface unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-module", emit_module, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Generate pre-compiled module file from a module map", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-obj", emit_obj, Flag, Action_Group, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Emit native object files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-pch", emit_pch, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Generate pre-compiled header file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/emit-pristine-llvm", emit_pristine_llvm, Flag, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Emit pristine LLVM IR from the frontend by not running any LLVM passes at all.Same as -S + -emit-llvm + -disable-llvm-passes.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-reduced-module-interface", emit_reduced_module_interface, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Generate reduced prebuilt module interface from a standard C++ module interface unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--emit-sgf-symbol-labels-for-testing", emit_sgf_symbol_labels_for_testing, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--emit-static-lib", emit_static_lib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable linker job to emit a static library.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-emit-symbol-graph", emit_symbol_graph, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate Extract API information as a side effect of compilation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/enable-16bit-types", enable_16bit_types, Flag, dxc_Group, fnative_half_type, nullptr, 0, DXCOption | DXCOption, 0,
       "Enable 16-bit types and disable min precision types.Available in HLSL 2018 and shader model 6.2.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-enable-noundef-analysis", enable_noundef_analysis, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable analyzing function argument and return types for mandatory definedness", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-enable-tlsdesc", enable_tlsdesc, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--encoding=", _encoding_EQ, Joined, INVALID, fencoding_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--encoding", _encoding, Separate, INVALID, fencoding_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--end-no-unused-arguments", end_no_unused_arguments, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Start emitting warnings for unused driver arguments", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--entry", _entry, Flag, INVALID, e, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Eonly", Eonly, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Just run preprocessor, no output (for timings)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/EP", _SLASH_EP, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable linemarker output and preprocess to stdout", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-error-on-deserialized-decl=", error_on_deserialized_pch_decl_EQ, Joined, INVALID, error_on_deserialized_pch_decl, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-error-on-deserialized-decl", error_on_deserialized_pch_decl, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit error if a specific declaration is deserialized from PCH, for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/errorReport", _SLASH_errorReport, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-exception-model=", exception_model_EQ, Joined, INVALID, exception_model, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-exception-model", exception_model, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The exception model", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "dwarf,sjlj,seh,wasm")
OPTION(prefix_2, "/execution-charset:", _SLASH_execution_charset, Joined, cl_compile_Group, fexec_charset_EQ, nullptr, NoXarchOption, CLOption, 0,
       "Set runtime encoding, supports only UTF-8", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/experimental:", _SLASH_experimental, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-exported_symbols_list", exported__symbols__list, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/exportHeader", _SLASH_exportHeader, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--extdirs=", _extdirs_EQ, Joined, INVALID, fextdirs_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--extdirs", _extdirs, Separate, INVALID, fextdirs_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/external:env:", _SLASH_external_env, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Add dirs in env var <var> to include search path with warnings suppressed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<var>", nullptr)
OPTION(prefix_2, "/external:I", _SLASH_external_COLON_I, JoinedOrSeparate, cl_Group, isystem, nullptr, NoXarchOption, CLOption, 0,
       "Add directory to include search path with warnings suppressed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_2, "/external:W0", _SLASH_external_W0, Flag, cl_Group, Wno_system_headers, nullptr, NoXarchOption, CLOption, 0,
       "Ignore warnings from system headers (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/external:W1", _SLASH_external_W1, Flag, cl_Group, Wsystem_headers, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wsystem-headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/external:W2", _SLASH_external_W2, Flag, cl_Group, Wsystem_headers, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wsystem-headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/external:W3", _SLASH_external_W3, Flag, cl_Group, Wsystem_headers, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wsystem-headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/external:W4", _SLASH_external_W4, Flag, cl_Group, Wsystem_headers, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wsystem-headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/external:", _SLASH_external, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--extra-warnings", _extra_warnings, Flag, INVALID, W_Joined, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--extract-api-ignores=", extract_api_ignores_EQ, CommaJoined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Comma separated list of files containing a new line separated list of API symbols to ignore when extracting API information.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-extract-api", extract_api, Flag, Action_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Extract API information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_5, "--E", dxc_entrypoint, JoinedOrSeparate, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Entry point name", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-E", E, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Only run the preprocessor", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/E", _SLASH_E, Flag, cl_Group, E, nullptr, NoXarchOption, CLOption, 0,
       "Preprocess to stdout", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-e", e, Separate, Link_Group, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faapcs-bitfield-load", ForceAAPCSBitfieldLoad, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faapcs-bitfield-width", faapcs_bitfield_width, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faccess-control", faccess_control, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faddress-space-map-mangling=", faddress_space_map_mangling_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set the mode for address space map based mangling; OpenCL testing purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "target,no,yes")
OPTION(prefix_1, "-faddrsig", faddrsig, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Emit an address-significance table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faggressive-function-elimination", faggressive_function_elimination, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-commons", falign_commons, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-functions=", falign_functions_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-functions", falign_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-jumps=", falign_jumps_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-jumps", falign_jumps, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-labels=", falign_labels_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-labels", falign_labels, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falign-loops=", falign_loops_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "N must be a power of two. Align loops to the boundary", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr)
OPTION(prefix_1, "-falign-loops", falign_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faligned-alloc-unavailable", aligned_alloc_unavailable, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Aligned allocation/deallocation functions are unavailable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faligned-allocation", faligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable C++17 aligned allocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faligned-new=", faligned_new_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faligned-new", anonymous_1128, Flag, INVALID, faligned_allocation, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fall-intrinsics", fall_intrinsics, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fallow-editor-placeholders", fallow_editor_placeholders, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Treat editor placeholders as valid source code", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fallow-pch-with-compiler-errors", fallow_pch_with_errors, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Accept a PCH file that was created with compiler errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fallow-pch-with-different-modules-cache-path", fallow_pch_with_different_modules_cache_path, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Accept a PCH file that was created with a different modules cache path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fallow-pcm-with-compiler-errors", fallow_pcm_with_errors, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Accept a PCM file that was created with compiler errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fallow-unsupported", fallow_unsupported, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-falternative-parameter-statement", falternative_parameter_statement, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Enable the old style PARAMETER statement", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-faltivec-src-compat=", altivec_src_compat, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Source-level compatibility for Altivec vectors (for PowerPC targets). This includes results of vector comparison (scalar for 'xl', vector for 'gcc') as well as behavior when initializing with a scalar (splatting for 'xl', element zero only for 'gcc'). For 'mixed', the compatibility is as 'gcc' for 'vector bool/vector pixel' and as 'xl' for other types. Current default is 'mixed'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "mixed,gcc,xl")
OPTION(prefix_1, "-faltivec", faltivec, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fanalyzed-objects-for-unparse", fanalyzed_objects_for_unparse, Flag, f_Group, INVALID, nullptr, 0, FC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fandroid-pad-segment", fandroid_pad_segment, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fansi-escape-codes", fansi_escape_codes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Use ANSI escape codes for diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapinotes-modules", fapinotes_modules, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable module-based external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapinotes-swift-version=", fapinotes_swift_version, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the Swift version to use when filtering API notes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<version>", nullptr)
OPTION(prefix_1, "-fapinotes", fapinotes, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapple-kext", fapple_kext, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use Apple's kernel extensions ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapple-link-rtlib", fapple_link_rtlib, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Force linking the clang builtins runtime library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapple-pragma-pack", fapple_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable Apple gcc-compatible #pragma pack handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapplication-extension", fapplication_extension, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Restrict code to those available for App Extensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapply-global-visibility-to-externs", fapply_global_visibility_to_externs, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply global symbol visibility to external declarations without an explicit visibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fapprox-func", fapprox_func, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow certain math function calls to be replaced with an approximately equivalent calculation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fasm-blocks", fasm_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fasm", fasm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fassociative-math", fassociative_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fassume-nothrow-exception-dtor", fassume_nothrow_exception_dtor, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Assume that exception objects' destructors are non-throwing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fassume-sane-operator-new", fassume_sane_operator_new, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fassume-unique-vtables", fassume_unique_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fassumptions", fassumptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fastcp", fastcp, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fastf", fastf, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fast", fast, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fasync-exceptions", fasync_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable EH Asynchronous exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fasynchronous-unwind-tables", fasynchronous_unwind_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fauto-import", fauto_import, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "MinGW specific. Enable code generation support for automatic dllimport, and enable support for it in the linker. Enabled by default.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fauto-profile-accurate", fauto_profile_accurate, Flag, f_Group, fprofile_sample_accurate, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fauto-profile=", fauto_profile_EQ, Joined, INVALID, fprofile_sample_use_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fauto-profile", fauto_profile, Flag, f_Group, fprofile_sample_use, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fautolink", fautolink, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fautomatic", fautomatic, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/favor", _SLASH_favor, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/FA", _SLASH_FA, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Output assembly code file during compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fa", _SLASH_Fa, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set assembly output file name (with /FA)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file or dir/>", nullptr)
OPTION(prefix_1, "-fbackslash", fbackslash, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Specify that backslash in string introduces an escape character", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbacktrace", fbacktrace, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbasic-block-address-map", fbasic_block_address_map, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Emit the basic block address map section.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbasic-block-sections=", fbasic_block_sections_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Place each function's basic blocks in unique sections (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "all,labels,none,list=")
OPTION(prefix_1, "-fbfloat16-excess-precision=", fbfloat16_excess_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Allows control over excess precision on targets where native support for BFloat16 precision types is not available. By default, excess precision is used to calculate intermediate results following the rules specified in ISO C99.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "standard,fast,none")
OPTION(prefix_1, "-fbinutils-version=", fbinutils_version_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Produced object files can use all ELF features supported by this binutils version and newer. If -fno-integrated-as is specified, the generated assembly will consider GNU as support. 'none' means that all ELF features can be used, regardless of binutils support. Defaults to 2.26.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<major.minor>", nullptr)
OPTION(prefix_1, "-fblas-matmul-limit=", fblas_matmul_limit_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fblocks-runtime-optional", fblocks_runtime_optional, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Weakly link in the blocks runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fblocks", fblocks, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Enable the 'blocks' language feature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbootclasspath=", fbootclasspath_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fborland-extensions", fborland_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Accept non-standard constructs supported by the Borland compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbounds-check", fbounds_check, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbracket-depth=", fbracket_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbracket-depth", fbracket_depth, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Maximum nesting level for parentheses, brackets, and braces", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbranch-count-reg", fbranch_count_reg, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbuild-session-file=", fbuild_session_file, Joined, i_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Use the last modification time of <file> as the build session timestamp", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fbuild-session-timestamp=", fbuild_session_timestamp, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Time when the current build session started", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<time since Epoch in seconds>", nullptr)
OPTION(prefix_1, "-fbuiltin-headers-in-system-modules", fbuiltin_headers_in_system_modules, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "builtin headers belong to system modules, and _Builtin_ modules are ignored for cstdlib headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbuiltin-module-map", fbuiltin_module_map, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Load the clang builtins module map file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fbuiltin", fbuiltin, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fc++-abi=", fcxx_abi_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "C++ ABI to use. This will override the target C++ ABI.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fc++-static-destructors", fcxx_static_destructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x10", fcall_saved_x10, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x10 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x11", fcall_saved_x11, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x11 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x12", fcall_saved_x12, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x12 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x13", fcall_saved_x13, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x13 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x14", fcall_saved_x14, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x14 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x15", fcall_saved_x15, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x15 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x18", fcall_saved_x18, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x18 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x8", fcall_saved_x8, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x8 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcall-saved-x9", fcall_saved_x9, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Make the x9 register call-saved (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcaller-saves", fcaller_saves, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcaret-diagnostics-max-lines=", fcaret_diagnostics_max_lines_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Set the maximum number of source lines to show in a caret diagnostic (0 = no limit).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcaret-diagnostics", fcaret_diagnostics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcf-protection=", fcf_protection_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Instrument control-flow architecture protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "return,branch,full,none")
OPTION(prefix_1, "-fcf-protection", fcf_protection, Flag, f_Group, fcf_protection_EQ, "full\0", 0, DefaultVis | CLOption | CC1Option, 0,
       "Enable cf-protection in 'full' mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcf-runtime-abi=", fcf_runtime_abi_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "unspecified,standalone,objc,swift,swift-5.0,swift-4.2,swift-4.1")
OPTION(prefix_2, "/fcgl", fcgl, Flag, dxc_Group, emit_pristine_llvm, nullptr, 0, DXCOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fchar8_t", fchar8__t, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable C++ builtin type char8_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcheck-array-temporaries", fcheck_array_temporaries, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcheck-new", fcheck_new, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Do not assume C++ operator new may not return NULL", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcheck=", fcheck_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fclang-abi-compat=", fclang_abi_compat_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Attempt to match the ABI of Clang <version>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<version>", "<major>.<minor>,latest")
OPTION(prefix_1, "-fclangir", fclangir, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Use the ClangIR pipeline to compile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fclasspath=", fclasspath_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoarray=", fcoarray_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcolor-diagnostics", fcolor_diagnostics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option | FlangOption | FC1Option, 0,
       "Enable colors in diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcomment-block-commands=", fcomment_block_commands, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Treat each comma separated argument in <arg> as a documentation comment block command", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-fcommon", fcommon, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Place uninitialized global variables in a common block", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcompatibility-qualified-id-block-type-checking", fcompatibility_qualified_id_block_param_type_checking, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Allow using blocks with parameters of more specific type than the type system guarantees when a parameter is qualified id", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcompile-resource=", fcompile_resource_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcomplete-member-pointers", fcomplete_member_pointers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Require member pointer base types to be complete if they would be significant under the Microsoft ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcomplex-arithmetic=", fcomplex_arithmetic_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "full,improved,promoted,basic")
OPTION(prefix_1, "-fconst-strings", fconst_strings, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use a const qualified type for string literals in C and ObjC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconstant-cfstrings", fconstant_cfstrings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconstant-string-class=", fconstant_string_class_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconstant-string-class", fconstant_string_class, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Specify the class to use for constant Objective-C string objects.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<class name>", nullptr)
OPTION(prefix_1, "-fconstexpr-backtrace-limit=", fconstexpr_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of entries to print in a constexpr evaluation backtrace (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconstexpr-depth=", fconstexpr_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum depth of recursive constexpr function calls", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconstexpr-steps=", fconstexpr_steps_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of steps in constexpr function evaluation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconvergent-functions", fconvergent_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fconvert=", fconvert_EQ, Joined, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Set endian conversion of data for unformatted files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoro-aligned-allocation", fcoro_aligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Prefer aligned allocation for C++ Coroutines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoroutines", fcoroutines, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable support for the C++ Coroutines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoverage-compilation-dir=", fcoverage_compilation_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption, 0,
       "The compilation directory to embed in the coverage mapping.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoverage-mapping", fcoverage_mapping, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Generate coverage mapping to enable code coverage analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoverage-mcdc", fmcdc_coverage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable MC/DC criteria when generating code coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcoverage-prefix-map=", fcoverage_prefix_map_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "remap file source paths <old> to <new> in coverage mapping. If there are multiple options, prefix replacement is applied in reverse order starting from the last one", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<old>=<new>", nullptr)
OPTION(prefix_1, "-fcrash-diagnostics-dir=", fcrash_diagnostics_dir, Joined, f_clang_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CLOption | DXCOption, 0,
       "Put crash-report files in <dir>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-fcrash-diagnostics=", fcrash_diagnostics_EQ, Joined, f_clang_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CLOption | DXCOption, 0,
       "Set level of crash diagnostic reporting, (option: off, compiler, all)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcrash-diagnostics", fcrash_diagnostics, Flag, f_clang_Group, fcrash_diagnostics_EQ, "compiler\0", NoArgumentUnused, DefaultVis | CLOption | DXCOption, 0,
       "Enable crash diagnostic reporting (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcray-pointer", fcray_pointer, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcreate-profile", fcreate_profile, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcs-profile-generate=", fcs_profile_generate_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Generate instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-fcs-profile-generate", fcs_profile_generate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Generate instrumented code to collect context sensitive execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fctor-dtor-return-this", fctor_dtor_return_this, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Change the C++ ABI to returning `this` pointer from constructors and non-deleting destructors. (No effect on Microsoft ABI)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-allow-variadic-functions", fcuda_allow_variadic_functions, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Allow variadic functions in CUDA device code.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-approx-transcendentals", anonymous_2140, Flag, INVALID, fgpu_approx_transcendentals, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-flush-denormals-to-zero", fcuda_flush_denormals_to_zero, Flag, cuda_Group, fgpu_flush_denormals_to_zero, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-include-gpubinary", fcuda_include_gpubinary, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Incorporate CUDA device-side binary into host object file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-is-device", fcuda_is_device, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate code for CUDA device", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-rdc", anonymous_142, Flag, cuda_Group, fgpu_rdc, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcuda-short-ptr", fcuda_short_ptr, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Use 32-bit pointers for accessing const/local/shared address spaces", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcx-fortran-rules", fcx_fortran_rules, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Range reduction is enabled for complex arithmetic operations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcx-limited-range", fcx_limited_range, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Basic algebraic expansions of complex arithmetic operations involving are enabled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcxx-exceptions", fcxx_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable C++ exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fcxx-modules", fcxx_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable modules for C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/FC", _SLASH_FC, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fc", dxc_Fc, JoinedOrSeparate, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Output assembly listing file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fd-lines-as-code", fd_lines_as_code, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fd-lines-as-comments", fd_lines_as_comments, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdata-sections", fdata_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Place each data in its own section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-compilation-dir=", fdebug_compilation_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0,
       "The compilation directory to embed in the debug info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-compilation-dir", fdebug_compilation_dir, Separate, f_Group, fdebug_compilation_dir_EQ, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-default-version=", fdebug_default_version, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Default DWARF version to use, if a -g option caused DWARF debug info to be produced", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-all", fdebug_dump_all, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump symbols and the parse tree after the semantic checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-parse-tree-no-sema", fdebug_dump_parse_tree_no_sema, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump the parse tree (skips the semantic checks)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-parse-tree", fdebug_dump_parse_tree, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump the parse tree", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-parsing-log", fdebug_dump_parsing_log, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Run instrumented parse and dump the parsing log", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-pft", fdebug_dump_pft, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump the pre-fir parse tree", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-provenance", fdebug_dump_provenance, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump provenance", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-dump-symbols", fdebug_dump_symbols, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump symbols after the semantic analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-info-for-profiling", fdebug_info_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Emit extra debug info to make sample profile more accurate", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-macro", fdebug_macro, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Emit macro debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-measure-parse-tree", fdebug_measure_parse_tree, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Measure the parse tree", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-module-writer", fdebug_module_writer, Flag, INVALID, INVALID, nullptr, 0, FC1Option, 0,
       "Enable debug messages while writing module files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-pass-arguments", fdebug_pass_arguments, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-pass-manager", fdebug_pass_manager, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Prints debug information for the new pass manager", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-pass-structure", fdebug_pass_structure, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-pre-fir-tree", fdebug_pre_fir_tree, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump the pre-FIR tree", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-prefix-map=", fdebug_prefix_map_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "For paths in debug info, remap directory <old> to <new>. If multiple options match a path, the last option wins", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<old>=<new>", nullptr)
OPTION(prefix_1, "-fdebug-ranges-base-address", fdebug_ranges_base_address, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use DWARF base address selection entries in .debug_ranges", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-types-section", fdebug_types_section, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Place debug types in their own section (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-unparse-no-sema", fdebug_unparse_no_sema, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Unparse and stop (skips the semantic checks)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-unparse-with-modules", fdebug_unparse_with_modules, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Unparse with dependent modules and stop.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-unparse-with-symbols", fdebug_unparse_with_symbols, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Unparse with symbols and stop.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebug-unparse", fdebug_unparse, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Unparse and stop.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebugger-cast-result-to-id", fdebugger_cast_result_to_id, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable casting unknown expression results to id", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebugger-objc-literal", fdebugger_objc_literal, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable special debugger support for Objective-C subscripting and literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdebugger-support", fdebugger_support, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable special debugger support behavior", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdeclare-opencl-builtins", fdeclare_opencl_builtins, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add OpenCL builtin function declarations (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdeclspec", fdeclspec, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Allow __declspec as a keyword", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdefault-calling-conv=", fdefault_calling_conv_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "cdecl,fastcall,stdcall,vectorcall,regcall,rtdcall")
OPTION(prefix_1, "-fdefault-double-8", fdefault_double_8, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Set the default double precision kind to an 8 byte wide type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdefault-inline", fdefault_inline, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdefault-integer-8", fdefault_integer_8, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Set the default integer and logical kind to an 8 byte wide type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdefault-real-8", fdefault_real_8, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Set the default real kind to an 8 byte wide type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdefer-pop", anonymous_534, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdefine-target-os-macros", fdefine_target_os_macros, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CC1Option, 0,
       "Enable predefined target OS macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdelayed-template-parsing", fdelayed_template_parsing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Parse templated function definitions at the end of the translation unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdelete-null-pointer-checks", fdelete_null_pointer_checks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Treat usage of null pointers as undefined behavior (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdenormal-fp-math-f32=", fdenormal_fp_math_f32_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdenormal-fp-math=", fdenormal_fp_math_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdepfile-entry=", fdepfile_entry, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdeprecated-macro", fdeprecated_macro, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Defines the __DEPRECATED macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdevirtualize-speculatively", fdevirtualize_speculatively, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdevirtualize", fdevirtualize, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-absolute-paths", fdiagnostics_absolute_paths, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Print absolute paths in diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-color=", fdiagnostics_color_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-color", anonymous_400, Flag, f_Group, fcolor_diagnostics, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-fixit-info", fdiagnostics_fixit_info, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-format=", fdiagnostics_format_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-format", fdiagnostics_format, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Change diagnostic formatting to match IDE and command line tools", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "clang,msvc,vi,sarif,SARIF")
OPTION(prefix_1, "-fdiagnostics-hotness-threshold=", fdiagnostics_hotness_threshold_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Prevent optimization remarks from being output if they do not have at least this profile count. Use 'auto' to apply the threshold from profile summary", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<value>", nullptr)
OPTION(prefix_1, "-fdiagnostics-misexpect-tolerance=", fdiagnostics_misexpect_tolerance_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Prevent misexpect diagnostics from being output if the profile counts are within N% of the expected. ", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<value>", nullptr)
OPTION(prefix_1, "-fdiagnostics-parseable-fixits", fdiagnostics_parseable_fixits, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Print fix-its in machine parseable form", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-print-source-range-info", fdiagnostics_print_source_range_info, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print source range spans in numeric form", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-category=", fdiagnostics_show_category_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-category", fdiagnostics_show_category, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print diagnostic category", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,id,name")
OPTION(prefix_1, "-fdiagnostics-show-hotness", fdiagnostics_show_hotness, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable profile hotness information in diagnostic line", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-line-numbers", fdiagnostics_show_line_numbers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-location=", fdiagnostics_show_location_EQ, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-note-include-stack", fdiagnostics_show_note_include_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Display include stacks for diagnostic notes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-option", fdiagnostics_show_option, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Print option name with mappable diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiagnostics-show-template-tree", fdiagnostics_show_template_tree, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print a template comparison tree for differing templates", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdigraphs", fdigraphs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdirect-access-external-data", fdirect_access_external_data, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't use GOT indirection to reference external data symbols", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdirectives-only", fdirectives_only, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdisable-block-signature-string", fdisable_block_signature_string, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable block signature string)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdisable-module-hash", fdisable_module_hash, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable the module hash", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdiscard-value-names", fdiscard_value_names, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DXCOption, 0,
       "Discard value names in LLVM IR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdollar-ok", fdollar_ok, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdollars-in-identifiers", fdollars_in_identifiers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Allow '$' in identifiers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdouble-square-bracket-attributes", fdouble_square_bracket_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdriver-only", fdriver_only, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption, 0,
       "Only run the driver.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-fortran-optimized", fdump_fortran_optimized, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-fortran-original", fdump_fortran_original, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-parse-tree", fdump_parse_tree, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-record-layouts-canonical", fdump_record_layouts_canonical, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information with canonical field types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-record-layouts-complete", fdump_record_layouts_complete, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information for all complete types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-record-layouts-simple", fdump_record_layouts_simple, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information in a simple form used for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-record-layouts", fdump_record_layouts, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdump-vtable-layouts", fdump_vtable_layouts, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump the layouts of all vtables that will be emitted in a translation unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdwarf-directory-asm", fdwarf_directory_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdwarf-exceptions", fdwarf_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Use DWARF style exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fdwarf2-cfi-asm", fdwarf2_cfi_asm, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fd", _SLASH_Fd, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fe:", _SLASH_Fe_COLON, JoinedOrSeparate, cl_Group, _SLASH_Fe, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-felide-constructors", felide_constructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-feliminate-unused-debug-symbols", feliminate_unused_debug_symbols, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-feliminate-unused-debug-types", feliminate_unused_debug_types, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Do not emit  debug info for defined but unused types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fembed-bitcode-marker", fembed_bitcode_marker, Flag, INVALID, fembed_bitcode_EQ, "marker\0", 0, DefaultVis, 0,
       "Embed placeholder LLVM IR data as a marker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fembed-bitcode=", fembed_bitcode_EQ, Joined, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | CC1AsOption, 0,
       "Embed LLVM bitcode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<option>", "off,all,bitcode,marker")
OPTION(prefix_1, "-fembed-bitcode", fembed_bitcode, Flag, f_Group, fembed_bitcode_EQ, "all\0", 0, DefaultVis, 0,
       "Embed LLVM IR bitcode as data", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fembed-offload-object=", fembed_offload_object_EQ, Joined, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FC1Option, 0,
       "Embed Offloading device-side binary into host object file as a section.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-femit-all-decls", femit_all_decls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit all declarations, even if unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-femit-compact-unwind-non-canonical", femit_compact_unwind_non_canonical, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | DefaultVis, 0,
       "Try emitting Compact-Unwind for non-canonical entries. Maybe overriden by other constraints", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-femit-dwarf-unwind=", femit_dwarf_unwind_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "When to emit DWARF unwind (EH frame) info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "always,no-compact-unwind,default")
OPTION(prefix_1, "-femulated-tls", femulated_tls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use emutls functions to access thread_local variables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fenable-matrix", fenable_matrix, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable matrix data type and related builtin functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fencode-extended-block-signature", fencode_extended_block_signature, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "enable extended encoding of block type signature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fencoding=", fencoding_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ferror-limit=", ferror_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ferror-limit", ferror_limit, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set the maximum number of errors to emit before stopping (0 = no limit).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr)
OPTION(prefix_1, "-fescaping-block-tail-calls", fescaping_block_tail_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexceptions", fexceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable support for exception handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexcess-precision=", fexcess_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Allows control over excess precision on targets where native support for the precision types is not available. By default, excess precision is used to calculate intermediate results following the rules specified in ISO C99.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "standard,fast,none")
OPTION(prefix_1, "-fexec-charset=", fexec_charset_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexpensive-optimizations", anonymous_532, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-assignment-tracking=", fexperimental_assignment_tracking_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "disabled,enabled,forced")
OPTION(prefix_1, "-fexperimental-bounds-safety", fbounds_safety, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Enable experimental bounds safety extension for C", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-isel", fexperimental_isel, Flag, f_clang_Group, fglobal_isel, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-late-parse-attributes", fexperimental_late_parse_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable experimental late parsing of attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-library", fexperimental_library, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DefaultVis, 0,
       "Control whether unstable and experimental library features are enabled. This option enables various library features that are either experimental (also known as TSes), or have been but are not stable yet in the selected Standard Library implementation. It is not recommended to use this option in production code, since neither ABI nor API stability are guaranteed. This is intended to provide a preview of features that will ship in the future for experimentation purposes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-max-bitint-width=", fexperimental_max_bitint_width_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Set the maximum bitwidth for _BitInt (this option is expected to be removed in the future)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr)
OPTION(prefix_1, "-fexperimental-modules-reduced-bmi", modules_reduced_bmi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate the reduced BMI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-new-constant-interpreter", fexperimental_new_constant_interpreter, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable the experimental new constant interpreter", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-omit-vtable-rtti", fexperimental_omit_vtable_rtti, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Omit the RTTI component from virtual tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-openacc-macro-override=", openacc_macro_override_EQ, Joined, INVALID, openacc_macro_override, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-openacc-macro-override", openacc_macro_override, Separate, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Overrides the _OPENACC macro value for experimental testing during OpenACC support development", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-relative-c++-abi-vtables", fexperimental_relative_cxx_abi_vtables, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use the experimental C++ class ABI for classes with virtual tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-sanitize-metadata-ignorelist=", fexperimental_sanitize_metadata_ignorelist_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable sanitizer metadata for modules and functions that match the provided special case list", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-sanitize-metadata=atomics", fexperimental_sanitize_metadata_EQ_atomics, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit PCs for atomic operations used by binary analysis sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-sanitize-metadata=covered", fexperimental_sanitize_metadata_EQ_covered, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit PCs for code covered with binary analysis sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-sanitize-metadata=uar", fexperimental_sanitize_metadata_EQ_uar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit PCs for start of functions that are subject for use-after-return checking.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-sanitize-metadata=", fexperimental_sanitize_metadata_EQ, CommaJoined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Specify the type of metadata to emit for binary analysis sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexperimental-strict-floating-point", fexperimental_strict_floating_point, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enables the use of non-default rounding modes and non-default exception handling on targets that are not currently ready.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fextdirs=", fextdirs_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fextend-arguments=", fextend_args_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option, 0,
       "Controls how scalar integer arguments are extended in calls to unprototyped and varargs functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "32,64")
OPTION(prefix_1, "-fextended-identifiers", anonymous_536, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexternal-blas", fexternal_blas, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fexternc-nounwind", fexternc_nounwind, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Assume all functions with C linkage do not unwind", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fe", _SLASH_Fe, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set output executable file name", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file or dir/>", nullptr)
OPTION(prefix_1, "-ff2c", ff2c, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffake-address-space-map", ffake_address_space_map, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use a fake address space map; OpenCL testing purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffast-math", ffast_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow aggressive, lossy floating-point optimizations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffat-lto-objects", ffat_lto_objects, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Enable fat LTO object support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffile-compilation-dir=", ffile_compilation_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "The compilation directory to embed in the debug info and coverage mapping.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffile-prefix-map=", ffile_prefix_map_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "remap file source paths in debug info, predefined preprocessor macros and __builtin_FILE(). Implies -ffile-reproducible.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffile-reproducible", ffile_reproducible, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Use the target's platform-specific path separator character when expanding the __FILE__ macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffine-grained-bitfield-accesses", ffine_grained_bitfield_accesses, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use separate accesses for consecutive bitfield runs with legal widths and alignments.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffinite-loops", ffinite_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Assume all non-trivial loops are finite.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffinite-math-only", ffinite_math_only, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Allow floating-point optimizations that assume arguments and results are not NaNs or +-inf. This defines the \\_\\_FINITE\\_MATH\\_ONLY\\_\\_ preprocessor macro.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a0", ffixed_a0, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a0 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a1", ffixed_a1, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a1 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a2", ffixed_a2, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a2 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a3", ffixed_a3, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a3 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a4", ffixed_a4, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a4 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a5", ffixed_a5, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a5 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-a6", ffixed_a6, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the a6 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d0", ffixed_d0, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d0 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d1", ffixed_d1, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d1 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d2", ffixed_d2, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d2 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d3", ffixed_d3, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d3 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d4", ffixed_d4, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d4 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d5", ffixed_d5, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d5 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d6", ffixed_d6, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d6 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-d7", ffixed_d7, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the d7 register (M68k only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-form", ffixed_form, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Process source files in fixed form", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g1", ffixed_g1, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G1 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g2", ffixed_g2, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G2 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g3", ffixed_g3, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G3 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g4", ffixed_g4, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G4 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g5", ffixed_g5, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G5 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g6", ffixed_g6, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G6 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-g7", ffixed_g7, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the G7 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-i0", ffixed_i0, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the I0 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-i1", ffixed_i1, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the I1 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-i2", ffixed_i2, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the I2 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-i3", ffixed_i3, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the I3 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-i4", ffixed_i4, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the I4 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-i5", ffixed_i5, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the I5 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l0", ffixed_l0, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L0 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l1", ffixed_l1, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L1 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l2", ffixed_l2, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L2 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l3", ffixed_l3, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L3 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l4", ffixed_l4, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L4 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l5", ffixed_l5, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L5 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l6", ffixed_l6, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L6 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-l7", ffixed_l7, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the L7 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-line-length-", ffixed_line_length_VALUE, Joined, f_Group, ffixed_line_length_EQ, nullptr, 0, FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-line-length=", ffixed_line_length_EQ, Joined, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Use <value> as character line width in fixed mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-o0", ffixed_o0, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the O0 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-o1", ffixed_o1, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the O1 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-o2", ffixed_o2, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the O2 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-o3", ffixed_o3, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the O3 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-o4", ffixed_o4, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the O4 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-o5", ffixed_o5, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the O5 register (SPARC only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-point", ffixed_point, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable fixed point types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-r19", ffixed_r19, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve register r19 (Hexagon only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-r9", ffixed_r9, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Reserve the r9 register (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x10", ffixed_x10, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x10 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x11", ffixed_x11, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x11 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x12", ffixed_x12, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x12 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x13", ffixed_x13, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x13 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x14", ffixed_x14, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x14 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x15", ffixed_x15, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x15 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x16", ffixed_x16, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x16 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x17", ffixed_x17, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x17 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x18", ffixed_x18, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x18 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x19", ffixed_x19, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x19 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x1", ffixed_x1, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x1 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x20", ffixed_x20, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x20 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x21", ffixed_x21, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x21 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x22", ffixed_x22, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x22 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x23", ffixed_x23, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x23 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x24", ffixed_x24, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x24 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x25", ffixed_x25, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x25 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x26", ffixed_x26, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x26 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x27", ffixed_x27, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x27 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x28", ffixed_x28, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x28 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x29", ffixed_x29, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x29 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x2", ffixed_x2, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x2 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x30", ffixed_x30, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x30 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x31", ffixed_x31, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x31 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x3", ffixed_x3, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x3 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x4", ffixed_x4, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x4 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x5", ffixed_x5, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x5 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x6", ffixed_x6, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x6 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x7", ffixed_x7, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x7 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x8", ffixed_x8, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x8 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffixed-x9", ffixed_x9, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Reserve the x9 register (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffloat-store", ffloat_store, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffloat16-excess-precision=", ffloat16_excess_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Allows control over excess precision on targets where native support for Float16 precision types is not available. By default, excess precision is used to calculate intermediate results following the rules specified in ISO C99.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "standard,fast,none")
OPTION(prefix_1, "-ffor-scope", ffor_scope, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fforbid-guard-variables", fforbid_guard_variables, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit an error if a C++ static local initializer would need a guard variable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fforce-addr", force_addr, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fforce-check-cxx20-modules-input-files", fforce_check_cxx20_modules_input_files, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Check the input source files from C++20 modules explicitly", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fforce-dwarf-frame", fforce_dwarf_frame, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Always emit a debug frame section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fforce-emit-vtables", fforce_emit_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Emits more virtual tables to improve devirtualization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fforce-enable-int128", fforce_enable_int128, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable support for int128_t type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffp-contract=", ffp_contract, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Form fused FP ops (e.g. FMAs)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "fast,on,off,fast-honor-pragmas")
OPTION(prefix_1, "-ffp-eval-method=", ffp_eval_method_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies the evaluation method to use for floating-point arithmetic.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "source,double,extended")
OPTION(prefix_1, "-ffp-exception-behavior=", ffp_exception_behavior_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies the exception behavior of floating-point operations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "ignore,maytrap,strict")
OPTION(prefix_1, "-ffp-model=", ffp_model_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Controls the semantics of floating-point calculations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffpe-trap=", ffpe_trap_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffree-form", ffree_form, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Process source files in free form", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffree-line-length-", ffree_line_length_VALUE, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffreestanding", ffreestanding, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Assert that the compilation takes place in a freestanding environment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffriend-injection", ffriend_injection, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffrontend-optimize", ffrontend_optimize, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffuchsia-api-level=", ffuchsia_api_level_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set Fuchsia API level", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffunction-attribute-list", ffunction_attribute_list, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ffunction-sections", ffunction_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Place each function in its own section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgcse-after-reload", fgcse_after_reload, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgcse-las", fgcse_las, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgcse-sm", fgcse_sm, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgcse", fgcse, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fget-definition", fget_definition, MultiArg, Action_Group, INVALID, nullptr, 0, FC1Option, 3,
       "Get the symbol definition from <line> <start-column> <end-column>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fget-symbols-sources", fget_symbols_sources, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump symbols and their source code locations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fglobal-isel", fglobal_isel, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enables the global instruction selector", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgnu-inline-asm", fgnu_inline_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgnu-keywords", fgnu_keywords, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Allow GNU-extension keywords regardless of language standard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgnu-runtime", fgnu_runtime, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate output compatible with the standard GNU Objective-C runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgnu89-inline", fgnu89_inline, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use the gnu89 inline semantics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgnuc-version=", fgnuc_version_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgnu", fgnu, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-allow-device-init", fgpu_allow_device_init, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Allow device side init function in HIP (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-approx-transcendentals", fgpu_approx_transcendentals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use approximate transcendental functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-default-stream=", fgpu_default_stream_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specify default stream. The default value is 'legacy'. (CUDA/HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "legacy,per-thread")
OPTION(prefix_1, "-fgpu-defer-diag", fgpu_defer_diag, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Defer host/device related diagnostic messages for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-exclude-wrong-side-overloads", fgpu_exclude_wrong_side_overloads, Flag, offload_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Always exclude wrong side overloads in overloading resolution for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-flush-denormals-to-zero", fgpu_flush_denormals_to_zero, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Flush denormal floating point values to zero in CUDA/HIP device mode.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-inline-threshold=", fgpu_inline_threshold_EQ, Joined, offload_Group, INVALID, nullptr, HelpHidden, DefaultVis | DefaultVis | CLOption, 0,
       "Inline threshold for device compilation for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-rdc", fgpu_rdc, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Generate relocatable device code, also known as separate compilation mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fgpu-sanitize", fgpu_sanitize, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable sanitizer for supported offloading devices", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhalf-no-semantic-interposition", fhalf_no_semantic_interposition, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Like -fno-semantic-interposition but don't use local aliases", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fheinous-gnu-extensions", fheinous_gnu_extensions, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhermetic-module-files", fhermetic_module_files, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Emit hermetic module files (no nested USE association)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhip-dump-offload-linker-script", fhip_dump_offload_linker_script, Flag, hip_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhip-emit-relocatable", fhip_emit_relocatable, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Compile HIP source to relocatable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhip-fp32-correctly-rounded-divide-sqrt", fhip_fp32_correctly_rounded_divide_sqrt, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhip-kernel-arg-name", fhip_kernel_arg_name, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Specify that kernel argument names are preserved (HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhip-new-launch-api", fhip_new_launch_api, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Use new kernel launching API for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhlsl-strict-availability", fhlsl_strict_availability, Flag, hlsl_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Enables strict availability diagnostic mode for HLSL built-in functions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhonor-infinites", anonymous_728, Flag, INVALID, fhonor_infinities, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhonor-infinities", fhonor_infinities, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Specify that floating-point optimizations are not allowed that assume arguments and results are not +-inf.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhonor-nans", fhonor_nans, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Specify that floating-point optimizations are not allowed that assume arguments and results are not NANs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fhosted", fhosted, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fi:", _SLASH_Fi_COLON, JoinedOrSeparate, cl_Group, _SLASH_Fi, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fident", anonymous_39, Flag, f_Group, Qy, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fignore-exceptions", fignore_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable support for ignoring exception handling constructs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-filelist", filelist, Separate, Link_Group, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-filetype", filetype, Separate, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "Specify the output file type ('asm', 'null', or 'obj')", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fimplement-inlines", fimplement_inlines, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fimplicit-module-maps", fimplicit_module_maps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Implicitly search the file system for module map files.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fimplicit-modules-use-lock", ffimplicit_modules_use_lock, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use filesystem locks for implicit modules builds to avoid duplicating work in competing clang invocations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fimplicit-modules", fimplicit_modules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fimplicit-none", fimplicit_none, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "No implicit typing allowed unless overridden by IMPLICIT statements", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fimplicit-templates", fimplicit_templates, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finclude-default-header", finclude_default_header, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include default header file for OpenCL and HLSL", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fincremental-extensions", fincremental_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable incremental processing extensions such as processingstatements on the global scope.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-findirect-virtual-calls", anonymous_795, Flag, INVALID, fapple_kext, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finit-character=", finit_character_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finit-integer=", finit_integer_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finit-local-zero", finit_local_zero, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finit-logical=", finit_logical_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finit-real=", finit_real_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-functions-called-once", finline_functions_called_once, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-functions", finline_functions, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Inline suitable functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-hint-functions", finline_hint_functions, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Inline functions which are (explicitly or implicitly) marked inline", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-limit=", finline_limit_EQ, Joined, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-limit", ffinline_limit, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-max-stacksize=", finline_max_stacksize_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Suppress inlining of functions whose stack size exceeds the given value", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline-small-functions", finline_small_functions, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finline", finline, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finput-charset=", finput_charset_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | FC1Option, 0,
       "Specify the default character set for source files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finstrument-function-entry-bare", finstrument_function_entry_bare, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Instrument function entry only, after inlining, without arguments to the instrumentation call", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finstrument-functions-after-inlining", finstrument_functions_after_inlining, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Like -finstrument-functions, but insert the calls after inlining", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finstrument-functions", finstrument_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate calls to instrument function entry and exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-finteger-4-integer-8", finteger_4_integer_8, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fintegrated-as", fintegrated_as, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | DefaultVis, 0,
       "Enable the integrated assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fintegrated-cc1", fintegrated_cc1, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Run cc1 in-process", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fintegrated-objemitter", fintegrated_objemitter, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Use internal machine object code emitter.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fintrinsic-modules-path", fintrinsic_modules_path, Separate, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Specify where to find the compiled intrinsic modules", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-fipa-cp", fipa_cp, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fivopts", fivopts, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fix-only-warnings", fix_only_warnings, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it advice only for warnings, not errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fix-what-you-can", fix_what_you_can, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it advice even in the presence of unfixable errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fixit-recompile", fixit_recompile, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it changes and recompile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fixit-to-temporary", fixit_to_temp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it changes to temporary files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fixit=", fixit_EQ, Joined, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it advice creating a file with the given suffix", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fixit", fixit, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it advice to the input source", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/FI", _SLASH_FI, JoinedOrSeparate, cl_Group, include, nullptr, NoXarchOption, CLOption, 0,
       "Include file before parsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fi", _SLASH_Fi, Joined, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set preprocess output file name (with /P)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fjmc", fjmc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable just-my-code debugging", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fjump-tables", fjump_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Use jump tables for lowering switches", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fkeep-inline-functions", fanonymous_1729, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fkeep-persistent-storage-variables", fkeep_persistent_storage_variables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable keeping all variables that have a persistent storage duration, including global, static and thread-local variables, to guarantee that they can be directly addressed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fkeep-static-consts", fkeep_static_consts, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Keep static const variables even if unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fkeep-system-includes", fkeep_system_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Instead of expanding system headers when emitting preprocessor output, preserve the #include directive. Useful when producing preprocessed output for test case reduction. May produce incorrect output if preprocessor symbols that control the included content (e.g. _XOPEN_SOURCE) are defined in the including source file. The portability of the resulting source to other compilation environments is not guaranteed.\n\nOnly valid with -E.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flang-deprecated-no-hlfir", flang_deprecated_no_hlfir, Flag, INVALID, INVALID, nullptr, HelpHidden, FlangOption | FC1Option, 0,
       "Do not use HLFIR lowering (deprecated)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flang-experimental-hlfir", flang_experimental_hlfir, Flag, INVALID, INVALID, nullptr, HelpHidden, FlangOption | FC1Option, 0,
       "Use HLFIR lowering (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flang-experimental-integer-overflow", flang_experimental_integer_overflow, Flag, INVALID, INVALID, nullptr, HelpHidden, FlangOption | FC1Option, 0,
       "Add nsw flag to internal operations such as do-variable increment (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flarge-sizes", flarge_sizes, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Use INTEGER(KIND=8) for the result type in size-related intrinsics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flat_namespace", flat__namespace, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flax-vector-conversions=", flax_vector_conversions_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable implicit vector bit-casts", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,integer,all")
OPTION(prefix_1, "-flax-vector-conversions", flax_vector_conversions, Flag, f_Group, flax_vector_conversions_EQ, "integer\0", 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flimit-debug-info", flimit_debug_info, Flag, INVALID, fno_standalone_debug, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flimited-precision=", flimited_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flogical-abbreviations", flogical_abbreviations, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Enable logical abbreviations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flto-jobs=", flto_jobs_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flto-unit", flto_unit, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit IR to support LTO unit features (CFI, whole program vtable opt)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flto-visibility-public-std", flto_visibility_public_std, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use public LTO visibility for classes in std and stdext namespaces", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flto=auto", flto_EQ_auto, Flag, f_Group, flto_EQ, "full\0", 0, DefaultVis | FlangOption, 0,
       "Enable LTO in 'full' mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flto=jobserver", flto_EQ_jobserver, Flag, f_Group, flto_EQ, "full\0", 0, DefaultVis | FlangOption, 0,
       "Enable LTO in 'full' mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-flto=", flto_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | FC1Option | FlangOption, 0,
       "Set LTO mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "thin,full")
OPTION(prefix_1, "-flto", flto, Flag, f_Group, flto_EQ, "full\0", 0, DefaultVis | CLOption | CC1Option | FC1Option | FlangOption, 0,
       "Enable LTO in 'full' mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmacro-backtrace-limit=", fmacro_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set the maximum number of entries to print in a macro expansion backtrace (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmacro-prefix-map=", fmacro_prefix_map_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "remap file source paths in predefined preprocessor macros and __builtin_FILE(). Implies -ffile-reproducible.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmath-errno", fmath_errno, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Require math functions to indicate errors by setting errno", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-array-constructor=", fmax_array_constructor_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-errors=", fmax_errors_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-identifier-length", fmax_identifier_length, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-stack-var-size=", fmax_stack_var_size_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-subrecord-length=", fmax_subrecord_length_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-tokens=", fmax_tokens_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Max total number of preprocessed tokens for -Wmax-tokens.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmax-type-align=", fmax_type_align_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the maximum alignment to enforce on pointers lacking an explicit alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmcdc-max-conditions=", fmcdc_max_conditions_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Maximum number of conditions in MC/DC coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmcdc-max-test-vectors=", fmcdc_max_test_vectors_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Maximum number of test vectors in MC/DC coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmemory-profile-use=", fmemory_profile_use_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Use memory profile for profile-guided memory optimization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<pathname>", nullptr)
OPTION(prefix_1, "-fmemory-profile=", fmemory_profile_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable heap memory profiling and dump results into <directory>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-fmemory-profile", fmemory_profile, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Enable heap memory profiling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmerge-all-constants", fmerge_all_constants, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DefaultVis, 0,
       "Allow merging of constants", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmerge-constants", fmerge_constants, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmerge-functions", fmerge_functions, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Permit merging of identical functions when optimizing.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmessage-length=", fmessage_length_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Format message diagnostics so that they fit within N columns", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fminimize-whitespace", fminimize_whitespace, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Ignore the whitespace from the input file when emitting preprocessor output. It will only contain whitespace when necessary, e.g. to keep two minus signs from merging into to an increment operator. Useful with the -P option to normalize whitespace such that two files with only formatting changes are equal.\n\nOnly valid with -E on C-like inputs and incompatible with -traditional-cpp.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-feature", fmodule_feature, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable <feature> in module map requires declarations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<feature>", nullptr)
OPTION(prefix_1, "-fmodule-file-deps", fmodule_file_deps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-file-home-is-cwd", fmodule_file_home_is_cwd, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the current working directory as the base directory of compiled module files.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-file=", fmodule_file, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "[<name>=]<file>", nullptr)
OPTION(prefix_1, "-fmodule-format=", fmodule_format_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Select the container format for clang modules and PCH. Supported options are 'raw' and 'obj'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-header=", fmodule_header_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Build a C++20 Header Unit from a header that should be found in the user (fmodule-header=user) or system (fmodule-header=system) search path.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<kind>", nullptr)
OPTION(prefix_1, "-fmodule-header", fmodule_header, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Build a C++20 Header Unit from a header", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-implementation-of", fmodule_implementation_of, Separate, INVALID, fmodule_name_EQ, nullptr, 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-map-file-home-is-cwd", fmodule_map_file_home_is_cwd, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the current working directory as the home directory of module maps specified by -fmodule-map-file=<FILE>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-map-file=", fmodule_map_file, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Load this module map file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fmodule-maps", fmodule_maps, Flag, INVALID, fimplicit_module_maps, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-name=", fmodule_name_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Specify the name of the module to build", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>", nullptr)
OPTION(prefix_1, "-fmodule-output=", fmodule_output_EQ, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | CC1Option, 0,
       "Save intermediate module file results when compiling a standard C++ module unit.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-output", fmodule_output, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | CC1Option, 0,
       "Save intermediate module file results when compiling a standard C++ module unit.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodule-private", fmodule_private, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-cache-path=", fmodules_cache_path, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the module cache path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-fmodules-codegen", fmodules_codegen, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate code for uses of this module that assumes an explicit object file will be built for the module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-debuginfo", fmodules_debuginfo, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate debug info for types in an object file built from this module and do not generate them elsewhere", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-decluse", fmodules_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Require declaration of modules used within a module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-disable-diagnostic-validation", fmodules_disable_diagnostic_validation, Flag, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable validation of the diagnostic options when loading the module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-embed-all-files", fmodules_embed_all_files, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Embed the contents of all files read by this compilation into the produced module file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-embed-file=", fmodules_embed_file_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Embed the contents of the specified file into the module file being compiled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fmodules-hash-content", fmodules_hash_content, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable hashing the content of a module file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-ignore-macro=", fmodules_ignore_macro, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Ignore the definition of the given macro when building and loading modules", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-local-submodule-visibility", fmodules_local_submodule_visibility, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enforce name visibility rules across submodules of the same top-level module.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-prune-after=", fmodules_prune_after, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the interval (in seconds) after which a module file will be considered unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<seconds>", nullptr)
OPTION(prefix_1, "-fmodules-prune-interval=", fmodules_prune_interval, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the interval (in seconds) between attempts to prune the module cache", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<seconds>", nullptr)
OPTION(prefix_1, "-fmodules-search-all", fmodules_search_all, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | CLOption, 0,
       "Search even non-imported modules to resolve references", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-skip-diagnostic-options", fmodules_skip_diagnostic_options, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Disable writing diagnostic options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-skip-header-search-paths", fmodules_skip_header_search_paths, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Disable writing header search paths", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-strict-context-hash", fmodules_strict_context_hash, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable hashing of all compiler options that could impact the semantics of a module in an implicit build", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-strict-decluse", fmodules_strict_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Like -fmodules-decluse but requires all headers to be in modules", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-user-build-path", fmodules_user_build_path, Separate, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the module user build path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-fmodules-validate-input-files-content", fmodules_validate_input_files_content, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Validate PCM input files based on content if mtime differs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-validate-once-per-build-session", fmodules_validate_once_per_build_session, Flag, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't verify input files for the modules if the module has been successfully validated or loaded during this build session", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules-validate-system-headers", fmodules_validate_system_headers, Flag, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Validate the system headers that a module depends on when loading the module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodules", fmodules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable the 'modules' language feature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodulo-sched-allow-regmoves", fmodulo_sched_allow_regmoves, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmodulo-sched", fmodulo_sched, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-compatibility-version=", fms_compatibility_version, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-compatibility", fms_compatibility, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable full Microsoft Visual C++ compatibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-define-stdc", fms_define_stdc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Define '__STDC__' to '1' in MSVC Compatibility mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-extensions", fms_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Accept some non-standard constructs supported by the Microsoft compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-hotpatch", fms_hotpatch, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Ensure that all functions can be hotpatched at runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-kernel", fms_kernel, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-memptr-rep=", fms_memptr_rep_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "single,multiple,virtual")
OPTION(prefix_1, "-fms-omit-default-lib", fms_omit_default_lib, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fms-runtime-lib=", fms_runtime_lib_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | FlangOption, 0,
       "Select Windows run-time library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "static,static_dbg,dll,dll_dbg")
OPTION(prefix_1, "-fms-volatile", fms_volatile, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Volatile loads and stores have acquire and release semantics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmsc-version=", fmsc_version, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmudflapth", fmudflapth, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fmudflap", fmudflap, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fm", _SLASH_Fm, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnative-half-arguments-and-returns", fnative_half_arguments_and_returns, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnative-half-type", fnative_half_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the native half type for __fp16 instead of promoting to float", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnested-functions", fnested_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnew-alignment=", fnew_alignment_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies the largest alignment guaranteed by '::operator new(size_t)'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<align>", nullptr)
OPTION(prefix_1, "-fnew-alignment", anonymous_1127, Separate, INVALID, fnew_alignment_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnew-infallible", fnew_infallible, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnext-runtime", fnext_runtime, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-aapcs-bitfield-width", fno_aapcs_bitfield_width, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Do not follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-access-control", fno_access_control, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable C++ access control", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-addrsig", fno_addrsig, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Don't emit an address-significance table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-aggressive-function-elimination", fno_aggressive_function_elimination, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-align-commons", fno_align_commons, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-align-functions", fno_align_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-align-jumps", fno_align_jumps, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-align-labels", fno_align_labels, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-align-loops", fno_align_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-aligned-allocation", fno_aligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-aligned-new", anonymous_1129, Flag, INVALID, fno_aligned_allocation, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-all-intrinsics", fno_all_intrinsics, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-allow-editor-placeholders", fno_allow_editor_placeholders, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-altivec", fno_altivec, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-analyzed-objects-for-unparse", fno_analyzed_objects_for_unparse, Flag, f_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Do not use the analyzed objects when unparsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-android-pad-segment", fno_android_pad_segment, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-apinotes-modules", fno_apinotes_modules, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable module-based external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-apinotes", fno_apinotes, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-apple-pragma-pack", fno_apple_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-application-extension", fno_application_extension, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-approx-func", fno_approx_func, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-asm-blocks", fno_asm_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-asm", fno_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-associative-math", fno_associative_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-assume-nothrow-exception-dtor", fno_assume_nothrow_exception_dtor, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-assume-sane-operator-new", fno_assume_sane_operator_new, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't assume that C++'s global operator new can't alias any pointer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-assume-unique-vtables", fno_assume_unique_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable optimizations based on vtable pointer identity", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-assumptions", fno_assumptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable codegen and compile-time checks for C++23's [[assume]] attribute", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-async-exceptions", fno_async_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-asynchronous-unwind-tables", fno_asynchronous_unwind_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-auto-import", fno_auto_import, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis, 0,
       "MinGW specific. Disable support for automatic dllimport in code generation and linking", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-auto-profile-accurate", fno_auto_profile_accurate, Flag, f_Group, fno_profile_sample_accurate, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-auto-profile", fno_auto_profile, Flag, f_Group, fno_profile_sample_use, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-autolink", fno_autolink, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable generation of linker directives for automatic library linking", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-automatic", fno_automatic, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Implies the SAVE attribute for non-automatic local objects in subprograms unless RECURSIVE", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-backslash", fno_backslash, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-backtrace", fno_backtrace, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-basic-block-address-map", fno_basic_block_address_map, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-bitfield-type-align", fno_bitfield_type_align, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Ignore bit-field types when aligning structures", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-blocks", fno_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-borland-extensions", fno_borland_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-bounds-check", fno_bounds_check, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-branch-count-reg", fno_branch_count_reg, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-builtin-", fno_builtin_, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Disable implicit builtin knowledge of a specific function", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-builtin", fno_builtin, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Disable implicit builtin knowledge of functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-c++-static-destructors", fno_cxx_static_destructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable C++ static destructor registration", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-caller-saves", fno_caller_saves, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-caret-diagnostics", fno_caret_diagnostics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-char8_t", fno_char8__t, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable C++ builtin type char8_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-check-array-temporaries", fno_check_array_temporaries, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-check-new", fno_check_new, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-clangir", fno_clangir, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Use the AST -> LLVM pipeline to compile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-color-diagnostics", fno_color_diagnostics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Disable colors in diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-common", fno_common, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Compile common globals like normal definitions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-complete-member-pointers", fno_complete_member_pointers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-const-strings", fno_const_strings, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't use a const qualified type for string literals in C and ObjC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-constant-cfstrings", fno_constant_cfstrings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable creation of CodeFoundation-type constant strings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-convergent-functions", fno_convergent_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Assume all functions may be convergent.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-coro-aligned-allocation", fno_coro_aligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-coroutines", fno_coroutines, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-coverage-mapping", fno_coverage_mapping, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable code coverage analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-coverage-mcdc", fno_mcdc_coverage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable MC/DC coverage criteria", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-crash-diagnostics", fno_crash_diagnostics, Flag, f_clang_Group, gen_reproducer_eq, "off\0", NoArgumentUnused, DefaultVis | CLOption | DXCOption, 0,
       "Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cray-pointer", fno_cray_pointer, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cuda-approx-transcendentals", anonymous_2141, Flag, INVALID, fno_gpu_approx_transcendentals, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cuda-flush-denormals-to-zero", fno_cuda_flush_denormals_to_zero, Flag, cuda_Group, fno_gpu_flush_denormals_to_zero, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cuda-host-device-constexpr", fno_cuda_host_device_constexpr, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't treat unattributed constexpr functions as __host__ __device__.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cuda-rdc", anonymous_143, Flag, cuda_Group, fno_gpu_rdc, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cuda-short-ptr", fno_cuda_short_ptr, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cx-fortran-rules", fno_cx_fortran_rules, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Range reduction is disabled for complex arithmetic operations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cx-limited-range", fno_cx_limited_range, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Basic algebraic expansions of complex arithmetic operations involving are disabled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cxx-exceptions", fno_cxx_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-cxx-modules", fno_cxx_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable modules for C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-d-lines-as-code", fno_d_lines_as_code, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-d-lines-as-comments", fno_d_lines_as_comments, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-data-sections", fno_data_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-debug-info-for-profiling", fno_debug_info_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-debug-macro", fno_debug_macro, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Do not emit macro debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-debug-pass-manager", fno_debug_pass_manager, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Disables debug printing for the new pass manager", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-debug-ranges-base-address", fno_debug_ranges_base_address, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-debug-types-section", fno_debug_types_section, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-declspec", fno_declspec, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disallow __declspec as a keyword", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-default-inline", fno_default_inline, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-defer-pop", anonymous_535, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-define-target-os-macros", fno_define_target_os_macros, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable predefined target OS macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-delayed-template-parsing", fno_delayed_template_parsing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disable delayed template parsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-delete-null-pointer-checks", fno_delete_null_pointer_checks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Do not treat usage of null pointers as undefined behavior", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-deprecated-macro", fno_deprecated_macro, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Undefines the __DEPRECATED macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-devirtualize-speculatively", fno_devirtualize_speculatively, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-devirtualize", fno_devirtualize, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-color", anonymous_401, Flag, f_Group, fno_color_diagnostics, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-fixit-info", fno_diagnostics_fixit_info, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not include fixit information in diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-show-hotness", fno_diagnostics_show_hotness, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-show-line-numbers", fno_diagnostics_show_line_numbers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Show line numbers in diagnostic code snippets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-show-note-include-stack", fno_diagnostics_show_note_include_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-show-option", fno_diagnostics_show_option, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-diagnostics-use-presumed-location", fno_diagnostics_use_presumed_location, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Ignore #line directives when displaying diagnostic locations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-digraphs", fno_digraphs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-direct-access-external-data", fno_direct_access_external_data, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use GOT indirection to reference external data symbols", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-directives-only", fno_directives_only, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-disable-block-signature-string", fno_disable_block_signature_string, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't disable block signature string)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-discard-value-names", fno_discard_value_names, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DXCOption, 0,
       "Do not discard value names in LLVM IR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dllexport-inlines", fno_dllexport_inlines, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dollar-ok", fno_dollar_ok, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dollars-in-identifiers", fno_dollars_in_identifiers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disallow '$' in identifiers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-double-square-bracket-attributes", fno_double_square_bracket_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dump-fortran-optimized", fno_dump_fortran_optimized, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dump-fortran-original", fno_dump_fortran_original, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dump-parse-tree", fno_dump_parse_tree, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dwarf-directory-asm", fno_dwarf_directory_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-dwarf2-cfi-asm", fno_dwarf2_cfi_asm, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-elide-constructors", fno_elide_constructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable C++ copy constructor elision", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-elide-type", fno_elide_type, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not elide types when printing diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-eliminate-unused-debug-symbols", fno_eliminate_unused_debug_symbols, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-eliminate-unused-debug-types", fno_eliminate_unused_debug_types, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Emit  debug info for defined but unused types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-emit-compact-unwind-non-canonical", fno_emit_compact_unwind_non_canonical, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-emulated-tls", fno_emulated_tls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-escaping-block-tail-calls", fno_escaping_block_tail_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-exceptions", fno_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable support for exception handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-expensive-optimizations", anonymous_533, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-bounds-safety", fno_bounds_safety, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Disable experimental bounds safety extension for C", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-isel", fno_experimental_isel, Flag, f_clang_Group, fno_global_isel, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-late-parse-attributes", fno_experimental_late_parse_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable experimental late parsing of attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-library", fno_experimental_library, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-omit-vtable-rtti", fno_experimental_omit_vtable_rtti, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Do not omit the RTTI component from virtual tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-relative-c++-abi-vtables", fno_experimental_relative_cxx_abi_vtables, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not use the experimental C++ class ABI for classes with virtual tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-experimental-sanitize-metadata=", fno_experimental_sanitize_metadata_EQ, CommaJoined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable emitting metadata for binary analysis sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-extended-identifiers", anonymous_537, Flag, f_Group, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-external-blas", fno_external_blas, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-f2c", fno_f2c, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-fast-math", fno_fast_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-fat-lto-objects", fno_fat_lto_objects, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Disable fat LTO object support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-file-reproducible", fno_file_reproducible, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Use the host's platform-specific path separator character when expanding the __FILE__ macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-fine-grained-bitfield-accesses", fno_fine_grained_bitfield_accesses, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use large-integer access for consecutive bitfield runs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-finite-loops", fno_finite_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not assume that any loop is finite.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-finite-math-only", fno_finite_math_only, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-fixed-point", fno_fixed_point, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable fixed point types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-float-store", fno_float_store, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-for-scope", fno_for_scope, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-force-dwarf-frame", fno_force_dwarf_frame, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-force-emit-vtables", fno_force_emit_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-force-enable-int128", fno_force_enable_int128, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable support for int128_t type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-friend-injection", fno_friend_injection, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-frontend-optimize", fno_frontend_optimize, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-function-attribute-list", fno_function_attribute_list, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-function-sections", fno_function_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gcse-after-reload", fno_gcse_after_reload, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gcse-las", fno_gcse_las, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gcse-sm", fno_gcse_sm, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gcse", fno_gcse, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-global-isel", fno_global_isel, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disables the global instruction selector", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gnu-inline-asm", fno_gnu_inline_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable GNU style inline asm", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gnu-keywords", fno_gnu_keywords, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gnu89-inline", fno_gnu89_inline, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gnu", fno_gnu, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-allow-device-init", fno_gpu_allow_device_init, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't allow device side init function in HIP (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-approx-transcendentals", fno_gpu_approx_transcendentals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Don't use approximate transcendental functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-defer-diag", fno_gpu_defer_diag, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't defer host/device related diagnostic messages for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-exclude-wrong-side-overloads", fno_gpu_exclude_wrong_side_overloads, Flag, offload_Group, INVALID, nullptr, HelpHidden, DefaultVis | DefaultVis | CLOption, 0,
       "Exclude wrong side overloads only if there are same side overloads in overloading resolution for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-flush-denormals-to-zero", fno_gpu_flush_denormals_to_zero, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-rdc", fno_gpu_rdc, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-gpu-sanitize", fno_gpu_sanitize, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-hip-emit-relocatable", fno_hip_emit_relocatable, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not override toolchain to compile HIP source to relocatable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-hip-fp32-correctly-rounded-divide-sqrt", fno_hip_fp32_correctly_rounded_divide_sqrt, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Don't specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-hip-kernel-arg-name", fno_hip_kernel_arg_name, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't specify that kernel argument names are preserved (HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-hip-new-launch-api", fno_hip_new_launch_api, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't use new kernel launching API for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-honor-infinites", anonymous_729, Flag, INVALID, fno_honor_infinities, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-honor-infinities", fno_honor_infinities, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-honor-nans", fno_honor_nans, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ident", anonymous_40, Flag, f_Group, Qn, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-implement-inlines", fno_implement_inlines, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-implicit-module-maps", fno_implicit_module_maps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-implicit-modules-use-lock", fno_fimplicit_modules_use_lock, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-implicit-modules", fno_implicit_modules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-implicit-none", fno_implicit_none, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-implicit-templates", fno_implicit_templates, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-init-local-zero", fno_init_local_zero, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-inline-functions-called-once", fno_inline_functions_called_once, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-inline-functions", fno_inline_functions, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-inline-limit", fno_finline_limit, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-inline-small-functions", fno_inline_small_functions, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-inline", fno_inline, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-integer-4-integer-8", fno_integer_4_integer_8, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-integrated-as", fno_integrated_as, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | DefaultVis, 0,
       "Disable the integrated assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-integrated-cc1", fno_integrated_cc1, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Spawn a separate process for each cc1", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-integrated-objemitter", fno_integrated_objemitter, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Use external machine object code emitter.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ipa-cp", fno_ipa_cp, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ivopts", fno_ivopts, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-jmc", fno_jmc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-jump-tables", fno_jump_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not use jump tables for lowering switches", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-keep-inline-functions", fno_anonymous_1729, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-keep-persistent-storage-variables", fno_keep_persistent_storage_variables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable keeping all variables that have a persistent storage duration, including global, static and thread-local variables, to guarantee that they can be directly addressed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-keep-static-consts", fno_keep_static_consts, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Don't keep static const variables even if unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-keep-system-includes", fno_keep_system_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-knr-functions", fno_knr_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable support for K&R C function declarations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-lax-vector-conversions", fno_lax_vector_conversions, Flag, f_Group, flax_vector_conversions_EQ, "none\0", 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-limit-debug-info", fno_limit_debug_info, Flag, INVALID, fstandalone_debug, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-logical-abbreviations", fno_logical_abbreviations, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-lto-unit", fno_lto_unit, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-lto", fno_lto, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option | FlangOption, 0,
       "Disable LTO mode (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-math-builtin", fno_math_builtin, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Disable implicit builtin knowledge of math functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-math-errno", fno_math_errno, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-max-identifier-length", fno_max_identifier_length, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-max-type-align", fno_max_type_align, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-memory-profile", fno_memory_profile, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable heap memory profiling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-merge-all-constants", fno_merge_all_constants, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disallow merging of constants", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-merge-constants", fno_merge_constants, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-minimize-whitespace", fno_minimize_whitespace, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-module-file-deps", fno_module_file_deps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-module-maps", fno_module_maps, Flag, INVALID, fno_implicit_module_maps, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-module-private", fno_module_private, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-check-relocated", fno_modules_check_relocated, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Skip checks for relocated modules when loading PCM files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-decluse", fno_modules_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-error-recovery", fno_modules_error_recovery, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not automatically import modules for error recovery", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-global-index", fno_modules_global_index, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not automatically generate or update the global module index", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-prune-non-affecting-module-map-files", fno_modules_prune_non_affecting_module_map_files, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Do not prune non-affecting module map files when writing module files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-search-all", fno_modules_search_all, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-share-filemanager", fno_modules_share_filemanager, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable sharing the FileManager when building a module implicitly", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-skip-diagnostic-options", fno_modules_skip_diagnostic_options, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-skip-header-search-paths", fno_modules_skip_header_search_paths, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-validate-system-headers", fno_modules_validate_system_headers, Flag, i_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules-validate-textual-header-includes", fno_modules_validate_textual_header_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not enforce -fmodules-decluse and private header restrictions for textual headers. This flag will be removed in a future Clang release.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modules", fno_modules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modulo-sched-allow-regmoves", fno_modulo_sched_allow_regmoves, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-modulo-sched", fno_modulo_sched, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ms-compatibility", fno_ms_compatibility, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ms-extensions", fno_ms_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ms-volatile", fno_ms_volatile, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-new-infallible", fno_new_infallible, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-non-call-exceptions", fno_non_call_exceptions, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-arc-exceptions", fno_objc_arc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-arc", fno_objc_arc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-avoid-heapify-local-blocks", fno_objc_avoid_heapify_local_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't try to avoid heapifying local blocks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-convert-messages-to-runtime-calls", fno_objc_convert_messages_to_runtime_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-encode-cxx-class-template-spec", fno_objc_encode_cxx_class_template_spec, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-exceptions", fno_objc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-infer-related-result-type", fno_objc_infer_related_result_type, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "do not infer Objective-C related result type based on method family", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-legacy-dispatch", fno_objc_legacy_dispatch, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-nonfragile-abi", fno_objc_nonfragile_abi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-objc-weak", fno_objc_weak, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-offload-implicit-host-device-templates", fno_offload_implicit_host_device_templates, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-offload-lto", fno_offload_lto, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disable LTO mode (default) for offload compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-offload-uniform-block", fno_offload_uniform_block, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't assume that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-omit-frame-pointer", fno_omit_frame_pointer, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-assume-teams-oversubscription", fno_openmp_assume_teams_oversubscription, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-assume-threads-oversubscription", fno_openmp_assume_threads_oversubscription, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-cuda-mode", fno_openmp_cuda_mode, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-extensions", fno_openmp_extensions, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable all Clang extensions for OpenMP directives and clauses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-new-driver", fno_openmp_new_driver, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Don't use the new driver for OpenMP offloading.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-optimistic-collapse", fno_openmp_optimistic_collapse, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-simd", fno_openmp_simd, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-target-debug", fno_openmp_target_debug, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-target-jit", fno_openmp_target_jit, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp-target-new-runtime", fno_openmp_target_new_runtime, Flag, f_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-openmp", fno_openmp, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-operator-names", fno_operator_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not treat C++ operator name keywords as synonyms for operators", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-optimize-sibling-calls", fno_optimize_sibling_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable tail call optimization, keeping the call stack accurate", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pack-derived", fno_pack_derived, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pack-struct", fno_pack_struct, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-padding-on-unsigned-fixed-point", fno_padding_on_unsigned_fixed_point, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pascal-strings", fno_pascal_strings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pch-codegen", fno_pch_codegen, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Do not generate code for uses of this PCH that assumes an explicit object file will be built for the PCH", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pch-debuginfo", fno_pch_debuginfo, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Do not generate debug info for types in an object file built from this PCH and do not generate them elsewhere", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pch-instantiate-templates", fno_pch_instantiate_templates, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pch-timestamp", fno_pch_timestamp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable inclusion of timestamp in precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-peel-loops", fno_peel_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-permissive", fno_permissive, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-PIC", fno_PIC, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pic", fno_pic, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-PIE", fno_PIE, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pie", fno_pie, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-plt", fno_plt, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use GOT indirection instead of PLT to make external function calls (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pointer-tbaa", fno_pointer_tbaa, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ppc-native-vector-element-order", fno_ppc_native_vec_elem_order, Flag, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Specifies PowerPC non-native vector element order", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-prebuilt-implicit-modules", fno_prebuilt_implicit_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-prefetch-loop-arrays", fno_prefetch_loop_arrays, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-preserve-as-comments", fno_preserve_as_comments, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not preserve comments in inline assembly", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-printf", fno_printf, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-arcs", fno_profile_arcs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-correction", fno_profile_correction, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-generate-sampling", fno_profile_generate_sampling, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-generate", fno_profile_generate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disable generation of profile instrumentation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-instr-generate", fno_profile_instr_generate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disable generation of profile instrumentation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-instr-use", fno_profile_instr_use, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disable using instrumentation data for profile-guided optimization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-reusedist", fno_profile_reusedist, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-sample-accurate", fno_profile_sample_accurate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-sample-use", fno_profile_sample_use, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-use", fno_profile_use, Flag, INVALID, fno_profile_instr_use, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile-values", fno_profile_values, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-profile", fno_profile, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-protect-parens", fno_protect_parens, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-pseudo-probe-for-profiling", fno_pseudo_probe_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Do not emit pseudo probes for sample profiling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-auth-traps", fno_ptrauth_auth_traps, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-calls", fno_ptrauth_calls, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-function-pointer-type-discrimination", fno_ptrauth_function_pointer_type_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-indirect-gotos", fno_ptrauth_indirect_gotos, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-init-fini", fno_ptrauth_init_fini, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-intrinsics", fno_ptrauth_intrinsics, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-returns", fno_ptrauth_returns, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-type-info-vtable-pointer-discrimination", fno_ptrauth_type_info_vtable_pointer_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-vtable-pointer-address-discrimination", fno_ptrauth_vtable_pointer_address_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ptrauth-vtable-pointer-type-discrimination", fno_ptrauth_vtable_pointer_type_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-range-check", fno_range_check, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-raw-string-literals", fno_raw_string_literals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable raw string literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-real-4-real-10", fno_real_4_real_10, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-real-4-real-16", fno_real_4_real_16, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-real-4-real-8", fno_real_4_real_8, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-real-8-real-10", fno_real_8_real_10, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-real-8-real-16", fno_real_8_real_16, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-real-8-real-4", fno_real_8_real_4, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-realloc-lhs", fno_realloc_lhs, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-reciprocal-math", fno_reciprocal_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-record-command-line", fno_record_command_line, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-record-gcc-switches", anonymous_406, Flag, INVALID, fno_record_command_line, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-recovery-ast-type", fno_recovery_ast_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-recovery-ast", fno_recovery_ast, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-recursive", fno_recursive, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-reformat", fno_reformat, Flag, Preprocessor_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Dump the cooked character stream in -E mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-register-global-dtors-with-atexit", fno_register_global_dtors_with_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Don't use atexit or __cxa_atexit to register global destructors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-regs-graph", fno_regs_graph, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-relaxed-template-template-args", fno_relaxed_template_template_args, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Disable C++17 relaxed template template argument matching", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rename-registers", fno_rename_registers, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-reorder-blocks", fno_reorder_blocks, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-repack-arrays", fno_repack_arrays, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rewrite-imports", fno_rewrite_imports, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rewrite-includes", fno_rewrite_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ripa", fno_ripa, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-ropi", fno_ropi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rounding-math", fno_rounding_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rtlib-add-rpath", fno_rtlib_add_rpath, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, DefaultVis | FlangOption, 0,
       "Do not add -rpath with architecture-specific resource directory to the linker flags. When --hip-link is specified, do not add -rpath with HIP runtime library directory to the linker flags", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rtlib-defaultlib", fno_rtlib_defaultlib, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "On Windows, do not emit /defaultlib: directives to link compiler-rt libraries", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rtti-data", fno_rtti_data, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable generation of RTTI data", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rtti", fno_rtti, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable generation of rtti information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-rwpi", fno_rwpi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-safe-buffer-usage-suggestions", fno_safe_buffer_usage_suggestions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-address-globals-dead-stripping", fno_sanitize_address_globals_dead_stripping, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable linker dead stripping of globals in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-address-outline-instrumentation", fno_sanitize_address_outline_instrumentation, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Use default code inlining logic for the address sanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-address-poison-custom-array-cookie", fno_sanitize_address_poison_custom_array_cookie, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable poisoning array cookies when using custom operator new[] in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-address-use-after-scope", fno_sanitize_address_use_after_scope, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable use-after-scope detection in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-address-use-odr-indicator", fno_sanitize_address_use_odr_indicator, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable ODR indicator globals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fno-sanitize-address-vcasan-lib", _SLASH_fno_sanitize_address_vcasan_lib, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-blacklist", anonymous_609, Flag, f_clang_Group, fno_sanitize_ignorelist, nullptr, HelpHidden, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-cfi-canonical-jump-tables", fno_sanitize_cfi_canonical_jump_tables, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Do not make the jump table addresses canonical in the symbol table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-cfi-cross-dso", fno_sanitize_cfi_cross_dso, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable control flow integrity (CFI) checks for cross-DSO calls.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-coverage=", fno_sanitize_coverage, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable features of coverage instrumentation for Sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "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")
OPTION(prefix_1, "-fno-sanitize-hwaddress-experimental-aliasing", fno_sanitize_hwaddress_experimental_aliasing, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable aliasing mode in HWAddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-ignorelist", fno_sanitize_ignorelist, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Don't use ignorelist file for sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-link-c++-runtime", fno_sanitize_link_cxx_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-link-runtime", fno_sanitize_link_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-memory-param-retval", fno_sanitize_memory_param_retval, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable detection of uninitialized parameters and return values", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-memory-track-origins", fno_sanitize_memory_track_origins, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable origins tracking in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-memory-use-after-dtor", fno_sanitize_memory_use_after_dtor, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable use-after-destroy detection in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-minimal-runtime", fno_sanitize_minimal_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-recover=", fno_sanitize_recover_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable recovery for specified sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-recover", fno_sanitize_recover, Flag, f_clang_Group, fno_sanitize_recover_EQ, "all\0", 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-stable-abi", fno_sanitize_stable_abi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Conventional ABI instrumentation for sanitizer runtime. Default: Conventional", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-stats", fno_sanitize_stats, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable sanitizer statistics gathering.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-thread-atomics", fno_sanitize_thread_atomics, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable atomic operations instrumentation in ThreadSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-thread-func-entry-exit", fno_sanitize_thread_func_entry_exit, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable function entry/exit instrumentation in ThreadSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-thread-memory-access", fno_sanitize_thread_memory_access, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable memory access instrumentation in ThreadSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-trap=", fno_sanitize_trap_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable trapping for specified sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-trap", fno_sanitize_trap, Flag, f_clang_Group, fno_sanitize_trap_EQ, "all\0", 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable trapping for all sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize-undefined-trap-on-error", fno_sanitize_undefined_trap_on_error, Flag, f_clang_Group, fno_sanitize_trap_EQ, "undefined\0", 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sanitize=", fno_sanitize_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-save-optimization-record", fno_save_optimization_record, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-schedule-insns2", fno_schedule_insns2, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-schedule-insns", fno_schedule_insns, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-second-underscore", fno_second_underscore, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-see", fno_see, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-semantic-interposition", fno_semantic_interposition, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-separate-named-sections", fno_separate_named_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-short-enums", fno_short_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-short-wchar", fno_short_wchar, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Force wchar_t to be an unsigned int", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-show-column", fno_show_column, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not include column number on diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-show-source-location", fno_show_source_location, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not include source location information with diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sign-zero", fno_sign_zero, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-signaling-math", fno_signaling_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-signaling-nans", fno_signaling_nans, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-signed-char", fno_signed_char, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "char is unsigned", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-signed-wchar", fno_signed_wchar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use an unsigned type for wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-signed-zeros", fno_signed_zeros, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow optimizations that ignore the sign of floating point zeros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-single-precision-constant", fno_single_precision_constant, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sized-deallocation", fno_sized_deallocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-skip-odr-check-in-gmf", fno_skip_odr_check_in_gmf, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Perform ODR checks for decls in the global module fragment.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-slp-vectorize-aggressive", anonymous_4, Flag, clang_ignored_legacy_options_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-slp-vectorize", fno_slp_vectorize, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-spec-constr-count", fno_spec_constr_count, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-spell-checking", fno_spell_checking, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable spell-checking", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-split-dwarf-inlining", fno_split_dwarf_inlining, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-split-lto-unit", fno_split_lto_unit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-split-machine-functions", fno_split_machine_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable late function splitting using profile information (x86 ELF)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-split-stack", fno_split_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Wouldn't use segmented stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-stack-arrays", fno_stack_arrays, Flag, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Allocate array temporaries on the heap (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-stack-check", fno_stack_check, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-stack-clash-protection", fno_stack_clash_protection, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable stack clash protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-stack-protector", fno_stack_protector, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable the use of stack protectors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-stack-size-section", fno_stack_size_section, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-standalone-debug", fno_standalone_debug, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Limit debug information produced to reduce size of debug binary", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strength-reduce", fno_strength_reduce, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-aliasing", fno_strict_aliasing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Disable optimizations based on strict aliasing rules", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-enums", fno_strict_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-float-cast-overflow", fno_strict_float_cast_overflow, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-modules-decluse", fno_modules_strict_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-overflow", fno_strict_overflow, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-return", fno_strict_return, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't treat control flow paths that fall off the end of a non-void function as unreachable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-strict-vtable-pointers", fno_strict_vtable_pointers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-struct-path-tbaa", fno_struct_path_tbaa, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-sycl", fno_sycl, Flag, sycl_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disables SYCL kernels compilation for device", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-temp-file", fno_temp_file, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-test-coverage", fno_test_coverage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-threadsafe-statics", fno_threadsafe_statics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not emit code to make initialization of local statics thread safe", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tls-model", fno_tls_model, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tracer", fno_tracer, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-trapping-math", fno_trapping_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-dce", fno_tree_dce, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-salias", fno_tree_salias, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-slp-vectorize", anonymous_1332, Flag, INVALID, fno_slp_vectorize, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-ter", fno_tree_ter, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-vectorizer-verbose", fno_tree_vectorizer_verbose, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-vectorize", anonymous_1330, Flag, INVALID, fno_vectorize, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-tree-vrp", fno_tree_vrp, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-trigraphs", fno_trigraphs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not process trigraph sequences", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-underscoring", fno_underscoring, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unified-lto", fno_unified_lto, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use distinct LTO pipelines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unique-basic-block-section-names", fno_unique_basic_block_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unique-internal-linkage-names", fno_unique_internal_linkage_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unique-section-names", fno_unique_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't use unique names for text and data sections", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unit-at-a-time", fno_anonymous_1739, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unroll-all-loops", fno_unroll_all_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unroll-loops", fno_unroll_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Turn off loop unroller", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unsafe-loop-optimizations", fno_unsafe_loop_optimizations, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unsafe-math-optimizations", fno_unsafe_math_optimizations, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unsigned-char", fno_unsigned_char, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unswitch-loops", fno_unswitch_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-unwind-tables", fno_unwind_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-use-ctor-homing", fno_use_ctor_homing, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Don't use constructor homing for debug info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-use-cxa-atexit", fno_use_cxa_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't use __cxa_atexit for calling destructors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-use-init-array", fno_use_init_array, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use .ctors/.dtors instead of .init_array/.fini_array", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-use-line-directives", fno_use_line_directives, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-use-linker-plugin", fno_use_linker_plugin, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-validate-pch", fno_validate_pch, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable validation of precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-var-tracking", fno_var_tracking, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-variable-expansion-in-unroller", fno_variable_expansion_in_unroller, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-vect-cost-model", fno_vect_cost_model, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-vectorize", fno_vectorize, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-verbose-asm", fno_verbose_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-verify-intermediate-code", fno_verify_intermediate_code, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Disable verification of LLVM IR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-version-loops-for-stride", fno_loop_versioning, Flag, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Do not create unit-strided loops (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-virtual-function-elimination", fno_virtual_function_elimination, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-visibility-from-dllstorageclass", fno_visibility_from_dllstorageclass, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-visibility-inlines-hidden-static-local-var", fno_visibility_inlines_hidden_static_local_var, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disables -fvisibility-inlines-hidden-static-local-var (this is the default on non-darwin targets)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-visibility-inlines-hidden", fno_visibility_inlines_hidden, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-wchar", fno_wchar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable C++ builtin type wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-web", fno_web, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-whole-file", fno_whole_file, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-whole-program-vtables", fno_whole_program_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-whole-program", fno_whole_program, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-working-directory", fno_working_directory, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-wrapv", fno_wrapv, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xl-pragma-pack", fno_xl_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xor-operator", fno_xor_operator, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xray-always-emit-customevents", fno_xray_always_emit_customevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xray-always-emit-typedevents", fno_xray_always_emit_typedevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xray-function-index", fno_xray_function_index, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Omit function index section at the expense of single-function patching performance", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xray-ignore-loops", fno_xray_ignore_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xray-instrument", fno_xray_instrument, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-xray-link-deps", fno_xray_link_deps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-zero-initialized-in-bss", fno_zero_initialized_in_bss, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't place zero initialized data in BSS", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno-zvector", fno_zvector, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno_modules-validate-input-files-content", fno_modules_validate_input_files_content, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fno_pch-validate-input-files-content", fno_pch_validate_input_files_content, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnon-call-exceptions", fnon_call_exceptions, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnoopenmp-relocatable-target", fnoopenmp_relocatable_target, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fnoopenmp-use-tls", fnoopenmp_use_tls, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fo:", _SLASH_Fo_COLON, JoinedOrSeparate, cl_compile_Group, _SLASH_Fo, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-abi-version=", fobjc_abi_version_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-arc-cxxlib=", fobjc_arc_cxxlib_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Objective-C++ Automatic Reference Counting standard library kind", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "libc++,libstdc++,none")
OPTION(prefix_1, "-fobjc-arc-exceptions", fobjc_arc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use EH-safe code when synthesizing retains and releases in -fobjc-arc", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-arc", fobjc_arc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Synthesize retain and release calls for Objective-C pointers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-atdefs", fobjc_atdefs, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-avoid-heapify-local-blocks", fobjc_avoid_heapify_local_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Try to avoid heapifying local blocks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-call-cxx-cdtors", fobjc_call_cxx_cdtors, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-convert-messages-to-runtime-calls", fobjc_convert_messages_to_runtime_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-disable-direct-methods-for-testing", fobjc_disable_direct_methods_for_testing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Ignore attribute objc_direct so that direct methods can be tested", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-dispatch-method=", fobjc_dispatch_method_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Objective-C dispatch method to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "legacy,non-legacy,mixed")
OPTION(prefix_1, "-fobjc-encode-cxx-class-template-spec", fobjc_encode_cxx_class_template_spec, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Fully encode c++ class template specialization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-exceptions", fobjc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable Objective-C exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-gc-only", fobjc_gc_only, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Use GC exclusively for Objective-C related memory management", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-gc", fobjc_gc, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Enable Objective-C garbage collection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-infer-related-result-type", fobjc_infer_related_result_type, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-legacy-dispatch", fobjc_legacy_dispatch, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-link-runtime", fobjc_link_runtime, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-new-property", fobjc_new_property, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-nonfragile-abi-version=", fobjc_nonfragile_abi_version_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-nonfragile-abi", fobjc_nonfragile_abi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-runtime-has-weak", fobjc_runtime_has_weak, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The target Objective-C runtime supports ARC weak operations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-runtime=", fobjc_runtime_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Specify the target Objective-C runtime kind and version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-sender-dependent-dispatch", fobjc_sender_dependent_dispatch, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-subscripting-legacy-runtime", fobjc_subscripting_legacy_runtime, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Allow Objective-C array and dictionary subscripting in legacy runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fobjc-weak", fobjc_weak, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable ARC-style weak references in Objective-C", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foffload-implicit-host-device-templates", foffload_implicit_host_device_templates, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Template functions or specializations without host, device and global attributes have implicit host device attributes (CUDA/HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foffload-lto=", foffload_lto_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Set LTO mode for offload compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "thin,full")
OPTION(prefix_1, "-foffload-lto", foffload_lto, Flag, f_Group, foffload_lto_EQ, "full\0", 0, DefaultVis | CLOption, 0,
       "Enable LTO in 'full' mode for offload compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foffload-uniform-block", foffload_uniform_block, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Assume that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fomit-frame-pointer", fomit_frame_pointer, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Omit the frame pointer from functions that don't need it. Some stack unwinding cases, such as profilers and sanitizers, may prefer specifying -fno-omit-frame-pointer. On many targets, -O1 and higher omit the frame pointer by default. -m[no-]omit-leaf-frame-pointer takes precedence for leaf functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenacc", fopenacc, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption | CC1Option | DefaultVis, 0,
       "Enable OpenACC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-assume-no-nested-parallelism", fopenmp_assume_no_nested_parallelism, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Assert no nested parallel regions in the GPU", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-assume-no-thread-state", fopenmp_assume_no_thread_state, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Assert no thread in a parallel region modifies an ICV", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-assume-teams-oversubscription", fopenmp_assume_teams_oversubscription, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-assume-threads-oversubscription", fopenmp_assume_threads_oversubscription, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-cuda-blocks-per-sm=", fopenmp_cuda_blocks_per_sm_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-cuda-mode", fopenmp_cuda_mode, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-cuda-number-of-sm=", fopenmp_cuda_number_of_sm_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-cuda-teams-reduction-recs-num=", fopenmp_cuda_teams_reduction_recs_num_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-enable-irbuilder", fopenmp_enable_irbuilder, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0,
       "Use the experimental OpenMP-IR-Builder codegen path.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-extensions", fopenmp_extensions, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable all Clang extensions for OpenMP directives and clauses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-force-usm", fopenmp_force_usm, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Force behvaior as if the user specified pragma omp requires unified_shared_memory.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-host-ir-file-path", fopenmp_host_ir_file_path, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Path to the IR file produced by the frontend for the host.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-is-device", anonymous_2128, Flag, INVALID, fopenmp_is_target_device, nullptr, 0, CC1Option | FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-is-target-device", fopenmp_is_target_device, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Generate code only for an OpenMP target device.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-new-driver", fopenmp_new_driver, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Use the new driver for OpenMP offloading.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-offload-mandatory", fopenmp_offload_mandatory, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option, 0,
       "Do not create a host fallback if offloading to the device fails.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-optimistic-collapse", fopenmp_optimistic_collapse, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-relocatable-target", fopenmp_relocatable_target, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-simd", fopenmp_simd, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option, 0,
       "Emit OpenMP code only for SIMD-based constructs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-target-debug=", fopenmp_target_debug_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-target-debug", fopenmp_target_debug, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Enable debugging in the OpenMP offloading device RTL", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-target-jit", fopenmp_target_jit, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CLOption, 0,
       "Emit code that can be JIT compiled for OpenMP offloading. Implies -foffload-lto=full", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-target-new-runtime", fopenmp_target_new_runtime, Flag, f_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-targets=", fopenmp_targets_EQ, CommaJoined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FlangOption, 0,
       "Specify comma-separated list of triples OpenMP offloading targets to be supported", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-use-tls", fopenmp_use_tls, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp-version=", fopenmp_version_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Set OpenMP version (e.g. 45 for OpenMP 4.5, 51 for OpenMP 5.1). Default value is 51 for Clang", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{FlangOption, FC1Option}}, "Set OpenMP version (e.g. 45 for OpenMP 4.5, 51 for OpenMP 5.1). Default value is 11 for Flang") }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp=", fopenmp_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fopenmp", fopenmp, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Parse OpenMP pragmas and generate parallel code.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foperator-arrow-depth=", foperator_arrow_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Maximum number of 'operator->'s to call for a member access", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foperator-names", foperator_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foptimization-record-file=", foptimization_record_file_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "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.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-foptimization-record-passes=", foptimization_record_passes_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<regex>", nullptr)
OPTION(prefix_1, "-foptimize-sibling-calls", foptimize_sibling_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--for-linker=", _for_linker_EQ, Joined, INVALID, Xlinker, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--for-linker", _for_linker, Separate, INVALID, Xlinker, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--force-link=", _force_link_EQ, Joined, INVALID, u, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--force-link", _force_link, Separate, INVALID, u, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-force_cpusubtype_ALL", force__cpusubtype__ALL, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-force_flat_namespace", force__flat__namespace, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-force_load", force__load, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-forder-file-instrumentation", forder_file_instrumentation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foutput-class-dir=", foutput_class_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-foverride-record-layout=", foverride_record_layout_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Override record layouts with those in the given file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fo", dxc_Fo, JoinedOrSeparate, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Output object file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fo", _SLASH_Fo, Joined, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set output object file (with /c)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file or dir/>", nullptr)
OPTION(prefix_2, "/fp:contract", _SLASH_fp_contract, Flag, cl_Group, ffp_contract, "on\0", NoXarchOption, CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fp:except-", _SLASH_fp_except_, Flag, cl_Group, ffp_exception_behavior_EQ, "ignore\0", NoXarchOption, CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fp:except", _SLASH_fp_except, Flag, cl_Group, ffp_exception_behavior_EQ, "strict\0", NoXarchOption, CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fp:fast", _SLASH_fp_fast, Flag, cl_Group, ffast_math, nullptr, NoXarchOption, CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fp:precise", _SLASH_fp_precise, Flag, cl_Group, ffp_model_EQ, "precise\0", NoXarchOption, CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fp:strict", _SLASH_fp_strict, Flag, cl_Group, ffp_model_EQ, "strict\0", NoXarchOption, CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fp:", _SLASH_Fp_COLON, JoinedOrSeparate, cl_Group, _SLASH_Fp, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpack-derived", fpack_derived, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpack-struct=", fpack_struct_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the default maximum struct packing alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpack-struct", fpack_struct, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpadding-on-unsigned-fixed-point", fpadding_on_unsigned_fixed_point, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Force each unsigned fixed point type to have an extra bit of padding to align their scales with those of signed fixed point types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fparse-all-comments", fparse_all_comments, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpascal-strings", fpascal_strings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Recognize and construct Pascal-style string literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpass-by-value-is-noalias", fpass_by_value_is_noalias, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Allows assuming by-value parameters do not alias any other value. Has no effect on non-trivially-copyable classes in C++.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpass-plugin=", fpass_plugin_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Load pass plugin from a dynamic shared object file (only with new pass manager).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dsopath>", nullptr)
OPTION(prefix_1, "-fpatchable-function-entry-offset=", fpatchable_function_entry_offset_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate M NOPs before function entry", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<M>", nullptr)
OPTION(prefix_1, "-fpatchable-function-entry=", fpatchable_function_entry_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate M NOPs before function entry and N-M NOPs after function entry", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N,M>", nullptr)
OPTION(prefix_1, "-fpcc-struct-return", fpcc_struct_return, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Override the default ABI to return all structs on the stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpch-codegen", fpch_codegen, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Generate code for uses of this PCH that assumes an explicit object file will be built for the PCH", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpch-debuginfo", fpch_debuginfo, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Generate debug info for types in an object file built from this PCH and do not generate them elsewhere", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpch-instantiate-templates", fpch_instantiate_templates, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | CLOption, 0,
       "Instantiate templates already while building a PCH", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpch-preprocess", fpch_preprocess, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpch-validate-input-files-content", fpch_validate_input_files_content, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Validate PCH input files based on content if mtime differs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpeel-loops", fpeel_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpermissive", fpermissive, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fPIC", fPIC, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpic", fpic, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fPIE", fPIE, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpie", fpie, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fplt", fplt, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fplugin-arg-", fplugin_arg, Joined, INVALID, INVALID, nullptr, NoArgumentUnused, DefaultVis, 0,
       "Pass <arg> to plugin <name>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>-<arg>", nullptr)
OPTION(prefix_1, "-fplugin=", fplugin_EQ, Joined, f_Group, INVALID, nullptr, NoXarchOption | NoArgumentUnused, DefaultVis, 0,
       "Load the named plugin (dynamic shared object)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dsopath>", nullptr)
OPTION(prefix_1, "-fpointer-tbaa", fpointer_tbaa, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fppc-native-vector-element-order", fppc_native_vec_elem_order, Flag, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Specifies PowerPC native vector element order (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprebuilt-implicit-modules", fprebuilt_implicit_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Look up implicit modules in the prebuilt module path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprebuilt-module-path=", fprebuilt_module_path, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Specify the prebuilt module path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-fprefetch-loop-arrays", fprefetch_loop_arrays, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpreserve-as-comments", fpreserve_as_comments, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpreserve-vec3-type", fpreserve_vec3_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve 3-component vector type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprintf", fprintf, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fproc-stat-report=", fproc_stat_report_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Save subprocess statistics to the given file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fproc-stat-report", fproc_stat_report, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Print subprocess statistics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-arcs", fprofile_arcs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Instrument code to produce gcov data files (*.gcda)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-correction", fprofile_correction, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-dir=", fprofile_dir, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-exclude-files=", fprofile_exclude_files_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Instrument only functions from files where names don't match all the regexes separated by a semi-colon", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-filter-files=", fprofile_filter_files_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Instrument only functions from files where names match any regex separated by a semi-colon", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-function-groups=", fprofile_function_groups, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Partition functions into N groups and select only functions in group i to be instrumented using -fprofile-selected-function-group", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr)
OPTION(prefix_1, "-fprofile-generate-sampling", fprofile_generate_sampling, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-generate=", fprofile_generate_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-fprofile-generate", fprofile_generate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-instr-generate=", fprofile_instr_generate_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fprofile-instr-generate", fprofile_instr_generate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-instr-use=", fprofile_instr_use_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Use instrumentation data for profile-guided optimization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-instr-use", fprofile_instr_use, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-instrument-path=", fprofile_instrument_path_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-instrument-use-path=", fprofile_instrument_use_path_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Specify the profile path in PGO use compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-instrument=", fprofile_instrument_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable PGO instrumentation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,clang,llvm,csllvm")
OPTION(prefix_1, "-fprofile-list=", fprofile_list_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Filename defining the list of functions/files to instrument. The file uses the sanitizer special case list format.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-remapping-file=", fprofile_remapping_file_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Use the remappings described in <file> to match the profile data against names in the program", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fprofile-reusedist", fprofile_reusedist, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-sample-accurate", fprofile_sample_accurate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies that the sample profile is accurate", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-sample-use=", fprofile_sample_use_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable sample-based profile guided optimizations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-sample-use", fprofile_sample_use, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-selected-function-group=", fprofile_selected_function_group, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Partition functions into N groups using -fprofile-function-groups and select only functions in group i to be instrumented. The valid range is 0 to N-1 inclusive", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<i>", nullptr)
OPTION(prefix_1, "-fprofile-update=", fprofile_update_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set update method of profile counters", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<method>", "atomic,prefer-atomic,single")
OPTION(prefix_1, "-fprofile-use=", fprofile_use_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<pathname>", nullptr)
OPTION(prefix_1, "-fprofile-use", fprofile_use, Flag, f_Group, fprofile_instr_use, nullptr, 0, DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile-values", fprofile_values, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprofile", fprofile, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fprotect-parens", fprotect_parens, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | DefaultVis, 0,
       "Determines whether the optimizer honors parentheses when floating-point expressions are evaluated", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fpseudo-probe-for-profiling", fpseudo_probe_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Emit pseudo probes for sample profiling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-auth-traps", fptrauth_auth_traps, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable traps on authentication failures", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-calls", fptrauth_calls, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable signing and authentication of all indirect calls", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-function-pointer-type-discrimination", fptrauth_function_pointer_type_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable type discrimination on C function pointers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-indirect-gotos", fptrauth_indirect_gotos, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable signing and authentication of indirect goto targets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-init-fini", fptrauth_init_fini, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable signing of function pointers in init/fini arrays", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-intrinsics", fptrauth_intrinsics, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable pointer authentication intrinsics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-returns", fptrauth_returns, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable signing and authentication of return addresses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-type-info-vtable-pointer-discrimination", fptrauth_type_info_vtable_pointer_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable type and address discrimination of vtable pointer of std::type_info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-vtable-pointer-address-discrimination", fptrauth_vtable_pointer_address_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable address discrimination of vtable pointers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fptrauth-vtable-pointer-type-discrimination", fptrauth_vtable_pointer_type_discrimination, Flag, f_Group, INVALID, nullptr, TargetSpecific, CC1Option | DefaultVis, 0,
       "Enable type discrimination of vtable pointers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fp", _SLASH_Fp, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set pch file name (with /Yc and /Yu)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-framework", framework, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frandom-seed=", frandom_seed_EQ, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frandomize-layout-seed-file=", frandomize_layout_seed_file_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "File holding the seed used by the randomize structure layout feature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-frandomize-layout-seed=", frandomize_layout_seed_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The seed used by the randomize structure layout feature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<seed>", nullptr)
OPTION(prefix_1, "-frange-check", frange_check, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fraw-string-literals", fraw_string_literals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable raw string literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freal-4-real-10", freal_4_real_10, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freal-4-real-16", freal_4_real_16, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freal-4-real-8", freal_4_real_8, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freal-8-real-10", freal_8_real_10, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freal-8-real-16", freal_8_real_16, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freal-8-real-4", freal_8_real_4, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frealloc-lhs", frealloc_lhs, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freciprocal-math", freciprocal_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow division operations to be reassociated", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frecord-command-line", frecord_command_line, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frecord-gcc-switches", anonymous_405, Flag, INVALID, frecord_command_line, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frecord-marker=", frecord_marker_EQ, Joined, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frecovery-ast-type", frecovery_ast_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve the type for recovery expressions when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frecovery-ast", frecovery_ast, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve expressions in AST rather than dropping them when encountering semantic errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frecursive", frecursive, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freg-struct-return", freg_struct_return, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Override the default ABI to return small structs in registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fregister-global-dtors-with-atexit", fregister_global_dtors_with_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use atexit or __cxa_atexit to register global destructors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fregs-graph", fregs_graph, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frelaxed-template-template-args", frelaxed_template_template_args, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable C++17 relaxed template template argument matching", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frename-registers", frename_registers, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-freorder-blocks", freorder_blocks, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frepack-arrays", frepack_arrays, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fretain-comments-from-system-headers", fretain_comments_from_system_headers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frewrite-imports", frewrite_imports, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frewrite-includes", frewrite_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fripa", fripa, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fropi", fropi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "Generate read-only position independent code (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frounding-math", frounding_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frtlib-add-rpath", frtlib_add_rpath, Flag, INVALID, INVALID, nullptr, NoArgumentUnused, DefaultVis | FlangOption, 0,
       "Add -rpath with architecture-specific resource directory to the linker flags. When --hip-link is specified, also add -rpath with HIP runtime library directory to the linker flags", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frtlib-defaultlib", frtlib_defaultlib, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "On Windows, emit /defaultlib: directives to link compiler-rt libraries (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frtti-data", frtti_data, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frtti", frtti, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-frwpi", frwpi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "Generate read-write position independent code (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/FR", _SLASH_FR, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fr", _SLASH_Fr, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsafe-buffer-usage-suggestions", fsafe_buffer_usage_suggestions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Display suggestions to update code associated with -Wunsafe-buffer-usage warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsample-profile-use-profi", fsample_profile_use_profi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use profi to infer block and edge counts", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-destructor=", sanitize_address_destructor_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set the kind of module destructors emitted by AddressSanitizer instrumentation. These destructors are emitted to unregister instrumented global variables when code is unloaded (e.g. via `dlclose()`).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,global")
OPTION(prefix_1, "-fsanitize-address-field-padding=", fsanitize_address_field_padding, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Level of field padding for AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-globals-dead-stripping", fsanitize_address_globals_dead_stripping, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable linker dead stripping of globals in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-outline-instrumentation", fsanitize_address_outline_instrumentation, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Always generate function calls for address sanitizer instrumentation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-poison-custom-array-cookie", fsanitize_address_poison_custom_array_cookie, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable poisoning array cookies when using custom operator new[] in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-use-after-return=", sanitize_address_use_after_return_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Select the mode of detecting stack use-after-return in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<mode>", "never,runtime,always")
OPTION(prefix_2, "/fsanitize-address-use-after-return", _SLASH_fsanitize_address_use_after_return, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-use-after-scope", fsanitize_address_use_after_scope, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable use-after-scope detection in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-address-use-odr-indicator", fsanitize_address_use_odr_indicator, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-blacklist=", anonymous_608, Joined, f_clang_Group, fsanitize_ignorelist_EQ, nullptr, HelpHidden, DefaultVis | CC1Option | CLOption, 0,
       "Alias for -fsanitize-ignorelist=", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-cfi-canonical-jump-tables", fsanitize_cfi_canonical_jump_tables, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Make the jump table addresses canonical in the symbol table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-cfi-cross-dso", fsanitize_cfi_cross_dso, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable control flow integrity (CFI) checks for cross-DSO calls.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-cfi-icall-experimental-normalize-integers", fsanitize_cfi_icall_normalize_integers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Normalize integers in CFI indirect call type signature checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-cfi-icall-generalize-pointers", fsanitize_cfi_icall_generalize_pointers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Generalize pointers in CFI indirect call type signature checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-8bit-counters", fsanitize_coverage_8bit_counters, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable frequency counters in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-allowlist=", fsanitize_coverage_allowlist, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-control-flow", fsanitize_coverage_control_flow, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Collect control flow of function", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-ignorelist=", fsanitize_coverage_ignorelist, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-indirect-calls", fsanitize_coverage_indirect_calls, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable sanitizer coverage for indirect calls", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-inline-8bit-counters", fsanitize_coverage_inline_8bit_counters, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable inline 8-bit counters in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-inline-bool-flag", fsanitize_coverage_inline_bool_flag, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable inline bool flag in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-no-prune", fsanitize_coverage_no_prune, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable coverage pruning (i.e. instrument all blocks/edges)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-pc-table", fsanitize_coverage_pc_table, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Create a table of coverage-instrumented PCs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-stack-depth", fsanitize_coverage_stack_depth, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable max stack depth tracing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-bb", fsanitize_coverage_trace_bb, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable basic block tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-cmp", fsanitize_coverage_trace_cmp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable cmp instruction tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-div", fsanitize_coverage_trace_div, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable div instruction tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-gep", fsanitize_coverage_trace_gep, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable gep instruction tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-loads", fsanitize_coverage_trace_loads, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable tracing of loads", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-pc-guard", fsanitize_coverage_trace_pc_guard, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable PC tracing with guard in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-pc", fsanitize_coverage_trace_pc, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable PC tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-trace-stores", fsanitize_coverage_trace_stores, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable tracing of stores", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage-type=", fsanitize_coverage_type, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Sanitizer coverage type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-coverage=", fsanitize_coverage, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Specify the type of coverage instrumentation for Sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-hwaddress-abi=", fsanitize_hwaddress_abi_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Select the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor). This option is currently unused.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-hwaddress-experimental-aliasing", fsanitize_hwaddress_experimental_aliasing, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable aliasing mode in HWAddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-ignorelist=", fsanitize_ignorelist_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Path to ignorelist file for sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-link-c++-runtime", fsanitize_link_cxx_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-link-runtime", fsanitize_link_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-memory-param-retval", fsanitize_memory_param_retval, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable detection of uninitialized parameters and return values", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-memory-track-origins=", fsanitize_memory_track_origins_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable origins tracking in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-memory-track-origins", fsanitize_memory_track_origins, Flag, f_clang_Group, fsanitize_memory_track_origins_EQ, "2\0", 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable origins tracking in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-memory-use-after-dtor", fsanitize_memory_use_after_dtor, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable use-after-destroy detection in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-memtag-mode=", fsanitize_memtag_mode_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set default MTE mode to 'sync' (default) or 'async'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-minimal-runtime", fsanitize_minimal_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-recover=", fsanitize_recover_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable recovery for specified sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-recover", fsanitize_recover, Flag, f_clang_Group, fsanitize_recover_EQ, "all\0", 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-stable-abi", fsanitize_stable_abi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Stable  ABI instrumentation for sanitizer runtime. Default: Conventional", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-stats", fsanitize_stats, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable sanitizer statistics gathering.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-system-ignorelist=", fsanitize_system_ignorelist_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Path to system ignorelist file for sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-thread-atomics", fsanitize_thread_atomics, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable atomic operations instrumentation in ThreadSanitizer (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-thread-func-entry-exit", fsanitize_thread_func_entry_exit, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable function entry/exit instrumentation in ThreadSanitizer (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-thread-memory-access", fsanitize_thread_memory_access, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable memory access instrumentation in ThreadSanitizer (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-trap=", fsanitize_trap_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable trapping for specified sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-trap", fsanitize_trap, Flag, f_clang_Group, fsanitize_trap_EQ, "all\0", 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable trapping for all sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize-undefined-strip-path-components=", fsanitize_undefined_strip_path_components_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Strip (or keep only, if negative) a given number of path components when emitting check metadata.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<number>", nullptr)
OPTION(prefix_1, "-fsanitize-undefined-trap-on-error", fsanitize_undefined_trap_on_error, Flag, f_clang_Group, fsanitize_trap_EQ, "undefined\0", 0, DefaultVis | CC1Option | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/fsanitize=address", _SLASH_fsanitize_EQ_address, Flag, cl_Group, fsanitize_EQ, "address\0", NoXarchOption, CLOption, 0,
       "Enable AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsanitize=", fsanitize_EQ, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<check>", nullptr)
OPTION(prefix_1, "-fsave-optimization-record=", fsave_optimization_record_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Generate an optimization record file in a specific format", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<format>", nullptr)
OPTION(prefix_1, "-fsave-optimization-record", fsave_optimization_record, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Generate a YAML optimization record file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsched-interblock", anonymous_1248, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fschedule-insns2", fschedule_insns2, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fschedule-insns", fschedule_insns, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsecond-underscore", fsecond_underscore, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsee", fsee, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fseh-exceptions", fseh_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Use SEH style exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsemantic-interposition", fsemantic_interposition, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fseparate-named-sections", fseparate_named_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use separate unique sections for named sections (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fshort-enums", fshort_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Allocate to an enum type only as many bytes as it needs for the declared range of possible values", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fshort-wchar", fshort_wchar, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Force wchar_t to be a short unsigned int", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fshow-column", fshow_column, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fshow-overloads=", fshow_overloads_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Which overload candidates to show when overload resolution fails. Defaults to 'all'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "best,all")
OPTION(prefix_1, "-fshow-skipped-includes", fshow_skipped_includes, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Show skipped includes in -H output.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fshow-source-location", fshow_source_location, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsign-zero", fsign_zero, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsignaling-math", fsignaling_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsignaling-nans", fsignaling_nans, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsigned-bitfields", fsigned_bitfields, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsigned-char", fsigned_char, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "char is signed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsigned-wchar", fsigned_wchar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use a signed type for wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsigned-zeros", fsigned_zeros, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsingle-precision-constant", fsingle_precision_constant, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsized-deallocation", fsized_deallocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable C++14 sized global deallocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsjlj-exceptions", fsjlj_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Use SjLj style exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fskip-odr-check-in-gmf", fskip_odr_check_in_gmf, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Skip ODR checks for decls in the global module fragment.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fslp-vectorize-aggressive", anonymous_3, Flag, clang_ignored_legacy_options_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fslp-vectorize", fslp_vectorize, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable the superword-level parallelism vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fspec-constr-count", fspec_constr_count, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fspell-checking-limit=", fspell_checking_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of times to perform spell checking on unrecognized identifiers (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fspell-checking", fspell_checking, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsplit-dwarf-inlining", fsplit_dwarf_inlining, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsplit-lto-unit", fsplit_lto_unit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enables splitting of the LTO unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsplit-machine-functions", fsplit_machine_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable late function splitting using profile information (x86 ELF)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsplit-stack", fsplit_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use segmented stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fspv-target-env=", fspv_target_env_EQ, Joined, dxc_Group, INVALID, nullptr, 0, DefaultVis | DXCOption, 0,
       "Specify the target environment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "vulkan1.2, vulkan1.3")
OPTION(prefix_1, "-fstack-arrays", fstack_arrays, Flag, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Attempt to allocate array temporaries on the stack, no matter their size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-check", fstack_check, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-clash-protection", fstack_clash_protection, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable stack clash protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-protector-all", fstack_protector_all, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable stack protectors for all functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-protector-strong", fstack_protector_strong, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable stack protectors for some functions vulnerable to stack smashing. Compared to -fstack-protector, this uses a stronger heuristic that includes functions containing arrays of any size (and any type), as well as any calls to alloca or the taking of an address from a local variable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-protector", fstack_protector, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable stack protectors for some functions vulnerable to stack smashing. This uses a loose heuristic which considers functions vulnerable if they contain a char (or 8bit integer) array or constant sized calls to alloca , which are of greater size than ssp-buffer-size (default: 8 bytes). All variable sized calls to alloca are considered vulnerable. A function with a stack protector has a guard value added to the stack frame that is checked on function exit. The guard value must be positioned in the stack frame such that a buffer overflow from a vulnerable variable will overwrite the guard value before overwriting the function's return address. The reference stack guard value is stored in a global variable.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-size-section", fstack_size_section, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Emit section containing metadata on function stack sizes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstack-usage", fstack_usage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Emit .su file containing information on function stack sizes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstandalone-debug", fstandalone_debug, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Emit full debug info for all types used by the program", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrength-reduce", fstrength_reduce, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrict-aliasing", fstrict_aliasing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Enable optimizations based on strict aliasing rules", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrict-enums", fstrict_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable optimizations based on the strict definition of an enum's value range", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrict-flex-arrays=", fstrict_flex_arrays_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable optimizations based on the strict definition of flexible arrays", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<n>", "0,1,2,3")
OPTION(prefix_1, "-fstrict-float-cast-overflow", fstrict_float_cast_overflow, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Assume that overflowing float-to-int casts are undefined (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrict-overflow", fstrict_overflow, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrict-return", fstrict_return, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstrict-vtable-pointers", fstrict_vtable_pointers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable optimizations based on the strict rules for overwriting polymorphic C++ objects", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fstruct-path-tbaa", fstruct_path_tbaa, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fswift-async-fp=", fswift_async_fp_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption, 0,
       "Control emission of Swift async extended frame info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<option>", "auto,always,never")
OPTION(prefix_1, "-fsycl-is-device", fsycl_is_device, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate code for SYCL device.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsycl-is-host", fsycl_is_host, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "SYCL host compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsycl", fsycl, Flag, sycl_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Enables SYCL kernels compilation for device", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsymbol-partition=", fsymbol_partition_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsyntax-only", fsyntax_only, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | CC1Option | FC1Option | FlangOption, 0,
       "Run the preprocessor, parser and semantic analysis stages", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fsystem-module", fsystem_module, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Build this module as a system module. Only used with -emit-module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/FS", _SLASH_FS, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftabstop=", ftabstop_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftabstop", ftabstop, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set the tab stop distance.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr)
OPTION(prefix_1, "-ftemplate-backtrace-limit=", ftemplate_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of entries to print in a template instantiation backtrace (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftemplate-depth-", anonymous_1320, Joined, f_Group, ftemplate_depth_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftemplate-depth=", ftemplate_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum depth of recursive template instantiation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fterminated-vtables", anonymous_1334, Flag, INVALID, fapple_kext, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftest-coverage", ftest_coverage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Produce gcov notes files (*.gcno)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftest-module-file-extension=", ftest_module_file_extension_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "introduce a module file extension for testing purposes. The argument is parsed as blockname:major:minor:hashed:user info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fthin-link-bitcode=", fthin_link_bitcode_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Write minimized bitcode to <file> for the ThinLTO thin link only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fthinlto-index=", fthinlto_index_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Perform ThinLTO importing using provided function summary index", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fthreadsafe-statics", fthreadsafe_statics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftime-report=", ftime_report_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "(For new pass manager) 'per-pass': one report for each pass; 'per-pass-run': one report for each pass invocation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "per-pass,per-pass-run")
OPTION(prefix_1, "-ftime-report", ftime_report, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftime-trace-granularity=", ftime_trace_granularity_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Minimum time granularity (in microseconds) traced by time profiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftime-trace-verbose", ftime_trace_verbose, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Make time trace capture verbose event details (e.g. source filenames). This can increase the size of the output by 2-3 times", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftime-trace=", ftime_trace_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Similar to -ftime-trace. Specify the JSON file or a directory which will contain the JSON file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftime-trace", ftime_trace, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Turn on time profiler. Generates JSON file based on output filename.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftls-model=", ftlsmodel_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "global-dynamic,local-dynamic,initial-exec,local-exec")
OPTION(prefix_1, "-ftls-model", ftls_model, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftracer", ftracer, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrap-function=", ftrap_function_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Issue call to specified function rather than a trap instruction", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrapping-math", ftrapping_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrapv-handler=", ftrapv_handler_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Specify the function to be called on overflow", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<function name>", nullptr)
OPTION(prefix_1, "-ftrapv-handler", ftrapv_handler, Separate, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrapv", ftrapv, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Trap on integer overflow", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-dce", ftree_dce, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-salias", ftree_salias, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-slp-vectorize", anonymous_1331, Flag, INVALID, fslp_vectorize, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-ter", ftree_ter, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-vectorizer-verbose", ftree_vectorizer_verbose, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-vectorize", anonymous_1329, Flag, INVALID, fvectorize, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftree-vrp", ftree_vrp, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrigraphs", ftrigraphs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Process trigraph sequences", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrivial-auto-var-init-max-size=", ftrivial_auto_var_init_max_size, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Stop initializing trivial automatic stack variables if var size exceeds the specified number of instances (in bytes)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrivial-auto-var-init-stop-after=", ftrivial_auto_var_init_stop_after, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Stop initializing trivial automatic stack variables after the specified number of instances", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ftrivial-auto-var-init=", ftrivial_auto_var_init, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Initialize trivial automatic stack variables. Defaults to 'uninitialized'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "uninitialized,zero,pattern")
OPTION(prefix_1, "-ftype-visibility=", ftype_visibility, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Default type visibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "default,hidden,internal,protected")
OPTION(prefix_1, "-function-alignment", function_alignment, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "default alignment for functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funderscoring", funderscoring, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Appends one trailing underscore to external names", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funified-lto", funified_lto, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use the unified LTO pipeline", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funique-basic-block-section-names", funique_basic_block_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use unique names for basic block sections (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funique-internal-linkage-names", funique_internal_linkage_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funique-section-names", funique_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funit-at-a-time", fanonymous_1739, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funknown-anytype", funknown_anytype, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable parser support for the __unknown_anytype type; for testing purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funroll-all-loops", funroll_all_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funroll-loops", funroll_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Turn on loop unroller", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funsafe-loop-optimizations", funsafe_loop_optimizations, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funsafe-math-optimizations", funsafe_math_optimizations, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Allow unsafe floating-point math optimizations which may decrease precision", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funsigned-bitfields", funsigned_bitfields, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funsigned-char", funsigned_char, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funswitch-loops", funswitch_loops, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funwind-tables=", funwind_tables_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate unwinding tables for all functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-funwind-tables", funwind_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-ctor-homing", fuse_ctor_homing, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Use constructor homing if we are using limited debug info already", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-cuid=", fuse_cuid_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Method to generate ID's for compilation units for single source offloading languages CUDA and HIP: 'hash' (ID's generated by hashing file path and command line options) | 'random' (ID's generated as random numbers) | 'none' (disabled). Default is 'hash'. This option will be overridden by option '-cuid=[ID]' if it is specified.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-cxa-atexit", fuse_cxa_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-init-array", fuse_init_array, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-ld=", fuse_ld_EQ, Joined, f_Group, INVALID, nullptr, LinkOption, DefaultVis | FlangOption | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-line-directives", fuse_line_directives, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use #line in preprocessed output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-linker-plugin", fuse_linker_plugin, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fuse-register-sized-bitfield-access", fuse_register_sized_bitfield_access, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use register sized accesses to bit-fields, when possible.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/FU", _SLASH_FU, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvalidate-ast-input-files-content", fvalidate_ast_input_files_content, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Compute and store the hash of input files used to build an AST. Files with mismatching mtime's are considered valid if both contents is identical", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvariable-expansion-in-unroller", fvariable_expansion_in_unroller, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fveclib=", fveclib, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Use the given vector functions library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "Accelerate,libmvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,none")
OPTION(prefix_1, "-fvect-cost-model", fvect_cost_model, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvectorize", fvectorize, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable the loop vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fverbose-asm", fverbose_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate verbose assembly output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fverify-debuginfo-preserve-export=", fverify_debuginfo_preserve_export, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Export debug info (by testing original Debug Info) failures into specified (JSON) file (should be abs path as we use append mode to insert new JSON objects).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-fverify-debuginfo-preserve", fverify_debuginfo_preserve, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable Debug Info Metadata preservation testing in optimizations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fverify-intermediate-code", fverify_intermediate_code, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Enable verification of LLVM IR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fversion-loops-for-stride", floop_versioning, Flag, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Create unit-strided versions of loops", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvirtual-function-elimination", fvirtual_function_elimination, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enables dead virtual function elimination optimization. Requires -flto=full", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvisibility-dllexport=", fvisibility_dllexport_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for dllexport definitions. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default")
OPTION(prefix_1, "-fvisibility-externs-dllimport=", fvisibility_externs_dllimport_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for dllimport external declarations. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default")
OPTION(prefix_1, "-fvisibility-externs-nodllstorageclass=", fvisibility_externs_nodllstorageclass_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for external declarations without an explicit DLL storage class. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default")
OPTION(prefix_1, "-fvisibility-from-dllstorageclass", fvisibility_from_dllstorageclass, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Override the visibility of globals based on their final DLL storage class.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvisibility-global-new-delete-hidden", fvisibility_global_new_delete_hidden, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Give global C++ operator new and delete declarations hidden visibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvisibility-global-new-delete=", fvisibility_global_new_delete_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for global C++ operator new and delete declarations. If 'source' is specified the visibility is not adjusted", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "force-default,force-protected,force-hidden,source")
OPTION(prefix_1, "-fvisibility-inlines-hidden-static-local-var", fvisibility_inlines_hidden_static_local_var, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "When -fvisibility-inlines-hidden is enabled, static variables in inline C++ member functions will also be given hidden visibility by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvisibility-inlines-hidden", fvisibility_inlines_hidden, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Give inline C++ member functions hidden visibility by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvisibility-ms-compat", fvisibility_ms_compat, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Give global types 'default' visibility and global functions and variables 'hidden' visibility by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fvisibility-nodllstorageclass=", fvisibility_nodllstorageclass_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for definitions without an explicit DLL storage class. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default")
OPTION(prefix_1, "-fvisibility=", fvisibility_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the default symbol visibility for all global definitions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "default,hidden,internal,protected")
OPTION(prefix_1, "-fwarn-stack-size=", fwarn_stack_size_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwasm-exceptions", fwasm_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Use WebAssembly style exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwchar-type=", fwchar_type_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Select underlying type for wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "char,short,int")
OPTION(prefix_1, "-fweb", fweb, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwhole-file", fwhole_file, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwhole-program-vtables", fwhole_program_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enables whole-program vtable optimization. Requires -flto", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwhole-program", fwhole_program, Flag, clang_ignored_gcc_optimization_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwrapv", fwrapv, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Treat signed integer overflow as two's complement", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fwritable-strings", fwritable_strings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Store string literals as writable data", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxl-pragma-pack", fxl_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable IBM XL #pragma pack handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxor-operator", fxor_operator, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Enable .XOR. as a synonym of .NEQV.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-always-emit-customevents", fxray_always_emit_customevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Always emit __xray_customevent(...) calls even if the containing function is not always instrumented", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-always-emit-typedevents", fxray_always_emit_typedevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-always-instrument=", fxray_always_instrument, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-attr-list=", fxray_attr_list, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Filename defining the list of functions/types for imbuing XRay attributes.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-function-groups=", fxray_function_groups, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Only instrument 1 of N groups", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-function-index", fxray_function_index, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-ignore-loops", fxray_ignore_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't instrument functions with loops unless they also meet the minimum function size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-instruction-threshold=", fxray_instruction_threshold_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Sets the minimum function size to instrument with XRay", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-instrumentation-bundle=", fxray_instrumentation_bundle, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "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'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-instrument", fxray_instrument, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Generate XRay instrumentation sleds on function entry and exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-link-deps", fxray_link_deps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Link XRay runtime library when -fxray-instrument is specified (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-modes=", fxray_modes, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "List of modes to link in by default into XRay instrumented binaries.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-never-instrument=", fxray_never_instrument, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fxray-selected-function-group=", fxray_selected_function_group, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "When using -fxray-function-groups, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Fx", _SLASH_Fx, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fzero-call-used-regs=", fzero_call_used_regs_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Clear call-used registers upon function return (AArch64/x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "skip,used-gpr-arg,used-gpr,used-arg,used,all-gpr-arg,all-gpr,all-arg,all")
OPTION(prefix_1, "-fzero-initialized-in-bss", fzero_initialized_in_bss, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-fzvector", fzvector, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable System z vector language extension", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-F", F, JoinedOrSeparate, INVALID, INVALID, nullptr, RenderJoined, DefaultVis | CC1Option, 0,
       "Add directory to framework include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/F", _SLASH_F, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-g0", g0, Flag, gN_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/G1", _SLASH_G1, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-g1", g1, Flag, gN_Group, gline_tables_only, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/G2", _SLASH_G2, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-g2", g2, Flag, gN_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-g3", g3, Flag, gN_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-G=", G_EQ, Joined, m_Group, G, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GA", _SLASH_GA, Flag, cl_Group, ftlsmodel_EQ, "local-exec\0", NoXarchOption, CLOption, 0,
       "Assume thread-local variables are defined in the executable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--gcc-install-dir=", gcc_install_dir_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Use GCC installation in the specified directory. The directory ends with path components like 'lib{,32,64}/gcc{,-cross}/$triple/$version'. Note: executables (e.g. ld) used by the compiler are not overridden by the selected GCC installation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--gcc-toolchain=", gcc_toolchain, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | FlangOption, 0,
       "Specify a directory where Clang can find 'include' and 'lib{,32,64}/gcc{,-cross}/$triple/$version'. Clang will use the GCC installation with the largest version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{FlangOption}}, "Specify a directory where Flang can find 'lib{,32,64}/gcc{,-cross}/$triple/$version'. Flang will use the GCC installation with the largest version") }}), nullptr, nullptr)
OPTION(prefix_3, "--gcc-triple=", gcc_triple_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Search for the GCC installation with the specified triple.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gcodeview-command-line", gcodeview_command_line, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Emit compiler path and command line into CodeView debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gcodeview-ghash", gcodeview_ghash, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "Emit type record hashes in a .debug$H section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gcodeview", gcodeview, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0,
       "Generate CodeView debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gcoff", gcoff, Joined, g_Group, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gcolumn-info", gcolumn_info, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdbx", gdbx, Flag, gTune_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf-2", gdwarf_2, Flag, g_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate source-level debug information with dwarf version 2", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf-3", gdwarf_3, Flag, g_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate source-level debug information with dwarf version 3", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf-4", gdwarf_4, Flag, g_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate source-level debug information with dwarf version 4", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf-5", gdwarf_5, Flag, g_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate source-level debug information with dwarf version 5", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf-aranges", gdwarf_aranges, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf32", gdwarf32, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Enables DWARF32 format for ELF binaries, if debug information emission is enabled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf64", gdwarf64, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Enables DWARF64 format for ELF binaries, if debug information emission is enabled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gdwarf", gdwarf, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Generate source-level debug information with the default dwarf version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gd", _SLASH_Gd, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set __cdecl as a default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gembed-source", gembed_source, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Embed source text in DWARF debug sections", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gen-cdb-fragment-path", gen_cdb_fragment_path, Separate, internal_debug_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Emit a compilation database fragment to the specified directory", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gen-reproducer=", gen_reproducer_eq, Joined, INVALID, INVALID, nullptr, NoArgumentUnused, DefaultVis | CLOption | DXCOption, 0,
       "Emit reproducer on (option: off, crash (default), error, always)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gen-reproducer", gen_reproducer, Flag, internal_debug_Group, gen_reproducer_eq, "always\0", NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Auto-generates preprocessed source files and a reproduction script", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ge", _SLASH_Ge, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GF-", _SLASH_GF_, Flag, cl_Group, fwritable_strings, nullptr, NoXarchOption, CLOption, 0,
       "Disable string pooling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gfull", gfull, Flag, g_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GF", _SLASH_GF, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Enable string pooling (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ggdb0", ggdb0, Flag, ggdbN_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ggdb1", ggdb1, Flag, ggdbN_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ggdb2", ggdb2, Flag, ggdbN_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ggdb3", ggdb3, Flag, ggdbN_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ggdb", ggdb, Flag, gTune_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ggnu-pubnames", ggnu_pubnames, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GH", _SLASH_GH, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gh", _SLASH_Gh, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ginline-line-tables", ginline_line_tables, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GL-", _SLASH_GL_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gline-directives-only", gline_directives_only, Flag, gN_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Emit debug line info directives only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gline-tables-only", gline_tables_only, Flag, gN_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Emit debug line number tables only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-glldb", glldb, Flag, gTune_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GL", _SLASH_GL, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gm-", _SLASH_Gm_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gmlt", gmlt, Flag, INVALID, gline_tables_only, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gmodules", gmodules, Flag, gN_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Generate debug info with external references to clang modules or precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gm", _SLASH_Gm, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-codeview-command-line", gno_codeview_command_line, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Don't emit compiler path and command line into CodeView debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-codeview-ghash", gno_codeview_ghash, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-column-info", gno_column_info, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-embed-source", gno_embed_source, Flag, g_flags_Group, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Restore the default behavior of not embedding source text in DWARF debug sections", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-gnu-pubnames", gno_gnu_pubnames, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-inline-line-tables", gno_inline_line_tables, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "Don't emit inline line tables.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-modules", gno_modules, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-omit-unreferenced-methods", gno_omit_unreferenced_methods, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-pubnames", gno_pubnames, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-record-command-line", gno_record_command_line, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-record-gcc-switches", anonymous_1563, Flag, INVALID, gno_record_command_line, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-simple-template-names", gno_simple_template_names, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-split-dwarf", gno_split_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-strict-dwarf", gno_strict_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gno-template-alias", gno_template_alias, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gomit-unreferenced-methods", gomit_unreferenced_methods, Flag, g_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--gpu-bundle-output", gpu_bundle_output, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Bundle output files of HIP device compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--gpu-instrument-lib=", gpu_instrument_lib_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Instrument device library for HIP, which is a LLVM bitcode containing __cyg_profile_func_enter and __cyg_profile_func_exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--gpu-max-threads-per-block=", gpu_max_threads_per_block_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Default max threads per block for kernel launch bounds for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--gpu-use-aux-triple-only", gpu_use_aux_triple_only, Flag, offload_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | DefaultVis | CLOption, 0,
       "Prepare '-aux-triple' only without populating '-aux-target-cpu' and '-aux-target-feature'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gpubnames", gpubnames, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gpulibc", gpulibc, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Link the LLVM C Library for GPUs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GR-", _SLASH_GR_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Do not emit RTTI data", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-grecord-command-line", grecord_command_line, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-grecord-gcc-switches", anonymous_1562, Flag, INVALID, grecord_command_line, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gregcall4", _SLASH_Gregcall4, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set __regcall4 as a default calling convention to respect __regcall ABI v.4", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gregcall", _SLASH_Gregcall, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set __regcall as a default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GR", _SLASH_GR, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Emit RTTI data (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gr", _SLASH_Gr, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set __fastcall as a default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GS-", _SLASH_GS_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable buffer security check", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gsce", gsce, Flag, gTune_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gsimple-template-names=", gsimple_template_names_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use simple template names in DWARF, or include the full template name with a modified prefix for validation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "simple,mangled")
OPTION(prefix_1, "-gsimple-template-names", gsimple_template_names, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gsplit-dwarf=", gsplit_dwarf_EQ, Joined, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Set DWARF fission mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "split,single")
OPTION(prefix_1, "-gsplit-dwarf", gsplit_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gsrc-hash=", gsrc_hash_EQ, Joined, g_flags_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "md5,sha1,sha256")
OPTION(prefix_1, "-gstabs", gstabs, Joined, g_Group, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gstrict-dwarf", gstrict_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "Restrict DWARF features to those defined in the specified version, avoiding features from later versions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GS", _SLASH_GS, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Enable buffer security check (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gs", anonymous_2152, Flag, cl_Group, mstack_probe_size, "4096\0", NoXarchOption, CLOption, 0,
       "Use stack probes (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gs", _SLASH_Gs, Joined, cl_Group, mstack_probe_size, nullptr, NoXarchOption, CLOption, 0,
       "Set stack probe size (default 4096)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gtemplate-alias", gtemplate_alias, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gtoggle", gtoggle, Flag, g_flags_Group, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GT", _SLASH_GT, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/guard:", _SLASH_guard, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Enable Control Flow Guard with /guard:cf, or only the table with /guard:cf,nochecks. Enable EH Continuation Guard with /guard:ehcont", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gused", gused, Flag, g_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gvms", gvms, Joined, g_Group, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gv", _SLASH_Gv, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set __vectorcall as a default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gw-", _SLASH_Gw_, Flag, cl_Group, fno_data_sections, nullptr, NoXarchOption, CLOption, 0,
       "Do not put each data item in its own section (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gw", _SLASH_Gw, Flag, cl_Group, fdata_sections, nullptr, NoXarchOption, CLOption, 0,
       "Put each data item in its own section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GX-", _SLASH_GX_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Deprecated (like not passing /EH)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gxcoff", gxcoff, Joined, g_Group, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GX", _SLASH_GX, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Deprecated; use /EHsc", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gy-", _SLASH_Gy_, Flag, cl_Group, fno_function_sections, nullptr, NoXarchOption, CLOption, 0,
       "Do not put each function in its own section (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gy", _SLASH_Gy, Flag, cl_Group, ffunction_sections, nullptr, NoXarchOption, CLOption, 0,
       "Put each function in its own section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gz=", gz_EQ, Joined, g_flags_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "DWARF debug sections compression type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/GZ", _SLASH_GZ, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Gz", _SLASH_Gz, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set __stdcall as a default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-gz", gz, Flag, g_flags_Group, gz_EQ, "zlib\0", 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-G", G, JoinedOrSeparate, m_Group, INVALID, nullptr, NoXarchOption | TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Put objects of at most <size> bytes into small data section (MIPS / Hexagon)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<size>", nullptr)
OPTION(prefix_1, "-g", g_Flag, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Generate source-level debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-header-include-file", header_include_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename (or -) to write header include output to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-header-include-filtering=", header_include_filtering_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "set the flag that enables filtering header information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,only-direct-system")
OPTION(prefix_1, "-header-include-format=", header_include_format_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "set format in which header info is emitted", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "textual,json")
OPTION(prefix_2, "/headerName:", _SLASH_headername, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-headerpad_max_install_names", headerpad__max__install__names, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/headerUnit:angle", _SLASH_headerUnitAngle, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/headerUnit:quote", _SLASH_headerUnitQuote, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/headerUnit", _SLASH_headerUnit, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--help-hidden", _help_hidden, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption, 0,
       "Display help for hidden options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/HELP", _SLASH_HELP, Flag, cl_Group, help, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-help", help, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | FC1Option | FlangOption | DXCOption, 0,
       "Display available options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/help", _SLASH_help, Flag, cl_Group, help, nullptr, NoXarchOption, CLOption | DXCOption, 0,
       "Display available options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hip-device-lib-path=", anonymous_153, Joined, hip_Group, rocm_device_lib_path_EQ, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hip-device-lib=", hip_device_lib_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "HIP device library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hip-link", hip_link, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Link clang-offload-bundler bundles for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hip-path=", hip_path_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "HIP runtime installation path, used for finding HIP version and adding HIP include path.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hip-version=", hip_version_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "HIP version in the format of major.minor.patch", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hipspv-pass-plugin=", hipspv_pass_plugin_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "path to a pass plugin for HIP to SPIR-V passes.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dsopath>", nullptr)
OPTION(prefix_3, "--hipstdpar-interpose-alloc", hipstdpar_interpose_alloc, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Replace all memory allocation / deallocation calls with hipManagedMalloc / hipFree equivalents", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hipstdpar-path=", hipstdpar_path_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "HIP Standard Parallel Algorithm Acceleration library path, used for finding and implicitly including the library header", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hipstdpar-prim-path=", hipstdpar_prim_path_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "rocPrim path, required by the HIP Standard Parallel Algorithm Acceleration library, used to implicitly include the rocPrim library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hipstdpar-thrust-path=", hipstdpar_thrust_path_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "rocThrust path, required by the HIP Standard Parallel Algorithm Acceleration library, used to implicitly include the rocThrust library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--hipstdpar", hipstdpar, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable HIP acceleration for standard parallel algorithms", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-hlsl-entry", hlsl_entrypoint, Separate, dxc_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DXCOption, 0,
       "Entry point name for hlsl", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/hlsl-no-stdinc", dxc_no_stdinc, Flag, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "HLSL only. Disables all standard includes containing non-native compiler types and functions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/homeparams", _SLASH_homeparams, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/hotpatch", _SLASH_hotpatch, Flag, cl_Group, fms_hotpatch, nullptr, NoXarchOption, CLOption, 0,
       "Create hotpatchable image", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/HV", dxc_hlsl_version, JoinedOrSeparate, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "HLSL Version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "2016, 2017, 2018, 2021, 202x")
OPTION(prefix_1, "-H", H, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Show header includes and nesting depth", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/H", _SLASH_H, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-I-", I_, Flag, I_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-iapinotes-modules", iapinotes_modules, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to the API notes search path referenced by module name", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-ibuiltininc", ibuiltininc, Flag, clang_i_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable builtin #include directories even when -nostdinc is used before or after -ibuiltininc. Using -nobuiltininc after the option disables it", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-idirafter", idirafter, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to AFTER include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-iframeworkwithsysroot", iframeworkwithsysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-iframework", iframework, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to SYSTEM framework search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--imacros=", _imacros_EQ, Joined, INVALID, imacros, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-imacros", imacros, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include macros from file before parsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-image_base", image__base, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/imsvc", _SLASH_imsvc, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Add <dir> to system include search path, as if in %INCLUDE%", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-imultilib", imultilib, Separate, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-barrier", _include_barrier, Flag, INVALID, I_, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-directory-after=", _include_directory_after_EQ, Joined, INVALID, idirafter, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-directory-after", _include_directory_after, Separate, INVALID, idirafter, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-directory=", _include_directory_EQ, Joined, INVALID, I, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-directory", _include_directory, Separate, INVALID, I, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-include-pch", include_pch, Separate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include precompiled header file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_3, "--include-prefix=", _include_prefix_EQ, Joined, INVALID, iprefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-prefix", _include_prefix, Separate, INVALID, iprefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-with-prefix-after=", _include_with_prefix_after_EQ, Joined, INVALID, iwithprefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-with-prefix-after", _include_with_prefix_after, Separate, INVALID, iwithprefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-with-prefix-before=", _include_with_prefix_before_EQ, Joined, INVALID, iwithprefixbefore, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-with-prefix-before", _include_with_prefix_before, Separate, INVALID, iwithprefixbefore, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-with-prefix=", _include_with_prefix_EQ, Joined, INVALID, iwithprefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include-with-prefix", _include_with_prefix, Separate, INVALID, iwithprefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--include=", _include_EQ, Joined, INVALID, include, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-include", include, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include file before parsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-index-header-map", index_header_map, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Make the next included directory (-I or -F) an indexer header map", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-init-only", init_only, Flag, Action_Group, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Only execute frontend initialization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-init", init, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-inline-asm=", inline_asm_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "att,intel")
OPTION(prefix_1, "-install_name", install__name, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-integrated-as", anonymous_1726, Flag, INVALID, fintegrated_as, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-interface-stub-version=", interface_stub_version_EQ, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-internal-externc-isystem", internal_externc_isystem, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add directory to the internal system include search path with implicit extern \"C\" semantics; these are assumed to not be user-provided and are used to model system and standard headers' paths.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-internal-isystem", internal_isystem, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add directory to the internal system include search path; these are assumed to not be user-provided and are used to model system and standard headers' paths.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-iprefix", iprefix, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the -iwithprefix/-iwithprefixbefore prefix", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-iquote", iquote, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to QUOTE include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-isysroot", isysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption, 0,
       "Set the system root directory (usually /)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-isystem-after", isystem_after, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Add directory to end of the SYSTEM include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-isystem", isystem, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to SYSTEM include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-ivfsoverlay", ivfsoverlay, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Overlay the virtual filesystem described by file over the real file system", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-iwithprefixbefore", iwithprefixbefore, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set directory to include search path with prefix", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-iwithprefix", iwithprefix, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set directory to SYSTEM include search path with prefix", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-iwithsysroot", iwithsysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add directory to SYSTEM include search path, absolute paths are relative to -isysroot", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-I", I, JoinedOrSeparate, I_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | FlangOption | FC1Option, 0,
       "Add directory to the end of the list of include search paths", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_2, "/I", _SLASH_I, JoinedOrSeparate, cl_Group, I, nullptr, NoXarchOption, CLOption | DXCOption, 0,
       "Add directory to include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_2, "/JMC-", _SLASH_JMC_, Flag, cl_Group, fno_jmc, nullptr, NoXarchOption, CLOption, 0,
       "Disable just-my-code debugging (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/JMC", _SLASH_JMC, Flag, cl_Group, fjmc, nullptr, NoXarchOption, CLOption, 0,
       "Enable just-my-code debugging", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-J", J, JoinedOrSeparate, gfortran_Group, module_dir, nullptr, RenderJoined, FlangOption | FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/J", _SLASH_J, Flag, cl_Group, funsigned_char, nullptr, NoXarchOption, CLOption, 0,
       "Make char type unsigned", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-keep_private_externs", keep__private__externs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/kernel-", _SLASH_kernel_, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/kernel", _SLASH_kernel, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-K", K, Flag, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--language=", _language_EQ, Joined, INVALID, x, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--language", _language, Separate, INVALID, x, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-lazy_framework", lazy__framework, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-lazy_library", lazy__library, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--ld-path=", ld_path_EQ, Joined, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/LDd", _SLASH_LDd, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Create debug DLL", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/LD", _SLASH_LD, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Create DLL", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--libomptarget-amdgcn-bc-path=", libomptarget_amdgcn_bc_path_EQ, Joined, i_Group, libomptarget_amdgpu_bc_path_EQ, nullptr, 0, DefaultVis, 0,
       "Path to libomptarget-amdgcn bitcode library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--libomptarget-amdgpu-bc-path=", libomptarget_amdgpu_bc_path_EQ, Joined, i_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Path to libomptarget-amdgcn bitcode library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--libomptarget-nvptx-bc-path=", libomptarget_nvptx_bc_path_EQ, Joined, i_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Path to libomptarget-nvptx bitcode library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--library-directory=", _library_directory_EQ, Joined, INVALID, L, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--library-directory", _library_directory, Separate, INVALID, L, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--linker-option=", linker_option, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add linker option", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/link", _SLASH_link, RemainingArgsJoined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Forward options to the linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<options>", nullptr)
OPTION(prefix_1, "-llvm-verify-each", llvm_verify_each, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run the LLVM verifier after every LLVM pass", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/LN", _SLASH_LN, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-load", load, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Load the named plugin (dynamic shared object)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dsopath>", nullptr)
OPTION(prefix_1, "-L", L, JoinedOrSeparate, Link_Group, INVALID, nullptr, RenderJoined, DefaultVis | FlangOption, 0,
       "Add directory to library search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-l", l, JoinedOrSeparate, Link_Group, INVALID, nullptr, LinkerInput | RenderJoined, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m16", m16, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m32", m32, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m3dnowa", m3dnowa, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m3dnow", m3dnow, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m64", m64, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68000", m68000, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68010", m68010, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68020", m68020, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68030", m68030, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68040", m68040, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68060", m68060, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m68881", m68881, Flag, m_m68k_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-m80387", m80387, Flag, INVALID, mx87, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mabi=ieeelongdouble", mabi_EQ_ieeelongdouble, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use IEEE 754 quadruple-precision for long double", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mabi=quadword-atomics", mabi_EQ_quadword_atomics, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable quadword atomics ABI on AIX (AIX PPC64 only). Uses lqarx/stqcx. instructions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mabi=vec-extabi", mabi_EQ_vec_extabi, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable the extended Altivec ABI on AIX. Use volatile and nonvolatile vector registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mabi=", mabi_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mabicalls", mabicalls, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable SVR4-style position-independent code (Mips only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mabs=", mabs_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Mach", Mach, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-madx", madx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maes", maes, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-main-file-name", main_file_name, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Main file name to use for debug info and source if missing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maix-shared-lib-tls-model-opt", maix_shared_lib_tls_model_opt, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "For shared library loaded with the main program, change local-dynamic access(es) to initial-exec access(es) at the function level (AIX 64-bit only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maix-small-local-dynamic-tls", maix_small_local_dynamic_tls, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Produce a faster access sequence for local-dynamic TLS variables where the offset from the TLS base is encoded as an immediate operand (AIX 64-bit only). This access sequence is not used for variables larger than 32KB.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maix-small-local-exec-tls", maix_small_local_exec_tls, Flag, m_ppc_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Produce a faster access sequence for local-exec TLS variables where the offset from the TLS base is encoded as an immediate operand (AIX 64-bit only). This access sequence is not used for variables larger than 32KB.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maix-struct-return", maix_struct_return, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Return all structs in memory (PPC32 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maix32", maix32, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maix64", maix64, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-malign-branch-boundary=", malign_branch_boundary_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Specify the boundary's size to align branches", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-malign-branch=", malign_branch_EQ, CommaJoined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Specify types of branches to align", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-malign-double", malign_double, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Align doubles to two words in structs (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-malign-functions=", malign_functions_EQ, Joined, clang_ignored_m_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-malign-jumps=", malign_jumps_EQ, Joined, clang_ignored_m_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-malign-loops=", malign_loops_EQ, Joined, clang_ignored_m_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-maltivec", maltivec, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable AltiVec vector initializer syntax", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamdgpu-ieee", mamdgpu_ieee, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Sets the IEEE bit in the expected default floating point  mode register. Floating point opcodes that support exception flag gathering quiet and propagate signaling NaN inputs per IEEE 754-2008. This option changes the ABI. (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamdgpu-precise-memory-op", mamdgpu_precise_memory_op, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable precise memory mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamx-bf16", mamx_bf16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamx-complex", mamx_complex, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamx-fp16", mamx_fp16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamx-int8", mamx_int8, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mamx-tile", mamx_tile, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mappletvos-version-min=", mappletvos_version_min_EQ, Joined, INVALID, mtvos_version_min_EQ, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mappletvsimulator-version-min=", mappletvsimulator_version_min_EQ, Joined, INVALID, mtvos_simulator_version_min_EQ, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mapx-features=", mapx_features_EQ, CommaJoined, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CLOption | FlangOption | DefaultVis | CLOption, 0,
       "Enable features of APX", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "egpr,push2pop2,ppx,ndd,ccmp,nf,cf,zu")
OPTION(prefix_1, "-mapx-inline-asm-use-gpr32", mapx_inline_asm_use_gpr32, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Enable use of GPR32 in inline assembly for APX", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mapxf", mapxf, Flag, INVALID, mapx_features_EQ, "egpr\0push2pop2\0ppx\0ndd\0ccmp\0nf\0cf\0zu\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-march=", march_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CLOption | DXCOption | FlangOption | DefaultVis | CLOption, 0,
       "For a list of available architectures for the target use '-mcpu=help'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-marm64x", marm64x, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Link as a hybrid ARM64X image", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-marm", marm, Flag, INVALID, mno_thumb, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-masm=", masm_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-massembler-fatal-warnings", massembler_fatal_warnings, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Make assembler warnings fatal", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-massembler-no-warn", massembler_no_warn, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Make assembler not emit warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-matomics", matomics, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx10.1-256", mavx10_1_256, Flag, m_x86_AVX10_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx10.1-512", mavx10_1_512, Flag, m_x86_AVX10_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx10.1", mavx10_1, Flag, INVALID, mavx10_1_256, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx2", mavx2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512bf16", mavx512bf16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512bitalg", mavx512bitalg, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512bw", mavx512bw, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512cd", mavx512cd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512dq", mavx512dq, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512fp16", mavx512fp16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512f", mavx512f, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512ifma", mavx512ifma, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512vbmi2", mavx512vbmi2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512vbmi", mavx512vbmi, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512vl", mavx512vl, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512vnni", mavx512vnni, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512vp2intersect", mavx512vp2intersect, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx512vpopcntdq", mavx512vpopcntdq, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavxifma", mavxifma, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavxneconvert", mavxneconvert, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavxvnniint16", mavxvnniint16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavxvnniint8", mavxvnniint8, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavxvnni", mavxvnni, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mavx", mavx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbackchain", mbackchain, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Link stack frames through backchain on System Z", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbig-endian", mbig_endian, Flag, m_Group, INVALID, nullptr, NoXarchOption | TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbmi2", mbmi2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbmi", mbmi, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbranch-likely", mbranch_likely, Flag, m_Group, INVALID, nullptr, HelpHidden, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbranch-protection-pauth-lr", mbranch_protection_pauth_lr, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbranch-protection=", mbranch_protection_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Enforce targets of indirect branches and function returns", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbranch-target-enforce", mbranch_target_enforce, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbranches-within-32B-boundaries", mbranches_within_32B_boundaries, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Align selected branches (fused, jcc, jmp) within 32-byte boundary", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mbulk-memory", mbulk_memory, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcabac", mcabac, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable CABAC instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcheck-zero-division", mcheck_zero_division, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcldemote", mcldemote, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mclflushopt", mclflushopt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mclwb", mclwb, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mclzero", mclzero, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcmodel=", mcmodel_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcmpb", mcmpb, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcmpccxadd", mcmpccxadd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcmse", mcmse, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Allow use of CMSE (Armv8-M Security Extensions)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcode-object-version=", mcode_object_version_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | FC1Option | DefaultVis | CLOption, 0,
       "Specify code object ABI version. Defaults to 5. (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,4,5,6")
OPTION(prefix_1, "-mcompact-branches=", mcompact_branches_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mconsole", mconsole, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mconstant-cfstrings", mconstant_cfstrings, Flag, clang_ignored_m_Group, INVALID, nullptr, TargetSpecific | Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mconstructor-aliases", mconstructor_aliases, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Enable emitting complete constructors and destructors as aliases when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcpu=help", anonymous_1709, Flag, INVALID, print_supported_cpus, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcpu=", mcpu_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "For a list of available CPUs for the target use '-mcpu=help'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcrbits", mcrbits, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Control the CR-bit tracking feature on PowerPC. ``-mcrbits`` (the enablement of CR-bit tracking support) is the default for POWER8 and above, as well as for all other CPUs when optimization is applied (-O2 and above).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcrc32", mcrc32, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcrc", mcrc, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Allow use of CRC instructions (ARM/Mips only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcrypto", mpower8_crypto, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcumode", mcumode, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Specify CU wavefront execution mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mcx16", mcx16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdaz-ftz", mdaz_ftz, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Globally set the denormals-are-zero (DAZ) and flush-to-zero (FTZ) bits in the floating-point control register on program startup", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/MDd", _SLASH_MDd, Flag, _SLASH_M_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Use DLL debug run-time", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdebug-pass", mdebug_pass, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable additional debug output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdefault-build-attributes", mdefault_build_attributes, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdefault-visibility-export-mapping=", mdefault_visibility_export_mapping_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Mapping between default visibility and export", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,explicit,all")
OPTION(prefix_1, "-mdirect-move", mdirect_move, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdll", mdll, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdouble-float", mdouble_float, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdouble=", mdouble_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Force double to be <n> bits", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<n", "32,64")
OPTION(prefix_1, "-mdspr2", mdspr2, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdsp", mdsp, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mdynamic-no-pic", mdynamic_no_pic, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | FlangOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MD", MD, Flag, M_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Write a depfile containing user and system headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/MD", _SLASH_MD, Flag, _SLASH_M_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Use DLL run-time", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-meabi", meabi, Separate, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set EABI type. Default depends on triple)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "default,4,5,gnu")
OPTION(prefix_1, "-mefpu2", mefpu2, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-membedded-data", membedded_data, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Place constants in the .rodata section instead of the .sdata section even if they meet the -G <size> threshold (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-menable-experimental-extensions", menable_experimental_extensions, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Enable use of experimental RISC-V extensions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-menable-no-infs", menable_no_infinities, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Allow optimization to assume there are no infinities.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-menable-no-nans", menable_no_nans, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Allow optimization to assume there are no NaNs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-menqcmd", menqcmd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mevex512", mevex512, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mexception-handling", mexception_handing, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mexec-model=", mexec_model_EQ, Joined, m_wasm_Features_Driver_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Execution model (WebAssembly only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "command,reactor")
OPTION(prefix_1, "-mexecute-only", mexecute_only, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disallow generation of data access to code sections (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mextended-const", mextended_const, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mextern-sdata", mextern_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mf16c", mf16c, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfancy-math-387", mfancy_math_387, Flag, clang_ignored_m_Group, INVALID, nullptr, TargetSpecific | Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfentry", mfentry, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Insert calls to fentry at function entry (x86/SystemZ only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfix-and-continue", mfix_and_continue, Flag, clang_ignored_m_Group, INVALID, nullptr, TargetSpecific | Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfix-cmse-cve-2021-35465", mfix_cmse_cve_2021_35465, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Work around VLLDM erratum CVE-2021-35465 (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfix-cortex-a53-835769", mfix_cortex_a53_835769, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Workaround Cortex-A53 erratum 835769 (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfix-cortex-a57-aes-1742098", mfix_cortex_a57_aes_1742098, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Work around Cortex-A57 Erratum 1742098 (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfix-cortex-a72-aes-1655431", mfix_cortex_a72_aes_1655431, Flag, m_arm_Features_Group, mfix_cortex_a57_aes_1742098, nullptr, TargetSpecific, DefaultVis, 0,
       "Work around Cortex-A72 Erratum 1655431 (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfix4300", mfix4300, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfloat-abi=", mfloat_abi_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "soft,softfp,hard")
OPTION(prefix_1, "-mfloat-abi", mfloat_abi, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The float ABI to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfloat128", mfloat128, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfma4", mfma4, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfma", mfma, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mforced-sw-shadow-stack", mforced_sw_shadow_stack, Flag, m_riscv_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Force using software shadow stack when shadow-stack enabled", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfp32", mfp32, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Use 32-bit floating point registers (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfp64", mfp64, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Use 64-bit floating point registers (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfpmath=", mfpmath_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfpmath", mfpmath, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Which unit to use for fp math", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfprnd", mfprnd, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfpu=", mfpu_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfpu", mfpu, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfpxx", mfpxx, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Avoid FPU mode dependent operations when used with the O32 ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mframe-chain=", mframe_chain, Joined, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Select the frame chain model used to emit frame records (Arm only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,aapcs,aapcs+leaf")
OPTION(prefix_1, "-mframe-pointer=", mframe_pointer_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Specify which frame pointers to retain.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "all,non-leaf,reserved,none")
OPTION(prefix_1, "-mfsgsbase", mfsgsbase, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfsmuld", mfsmuld, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mfunction-return=", mfunction_return_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | DefaultVis | CLOption, 0,
       "Replace returns with jumps to ``__x86_return_thunk`` (x86 only, error otherwise)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,thunk-extern")
OPTION(prefix_1, "-mfxsr", mfxsr, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MF", MF, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Write depfile output from -MMD, -MD, -MM, or -M to <file>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-mgeneral-regs-only", mgeneral_regs_only, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Generate code which only uses the general purpose registers (AArch64/x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mgfni", mgfni, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mginv", mginv, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mglibc", mglibc, Flag, m_libc_Group, INVALID, nullptr, HelpHidden | HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mglobal-merge", mglobal_merge, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable merging of globals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mgpopt", mgpopt, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Use GP relative accesses for symbols known to be in a small data section (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mguard=", mguard_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Enable or disable Control Flow Guard checks and guard tables emission", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,cf,cf-nochecks")
OPTION(prefix_1, "-mguarded-control-stack", mguarded_control_stack, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MG", MG, Flag, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add missing headers to depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhalf-precision", mhalf_precision, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhard-float", mhard_float, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhard-quad-float", mhard_quad_float, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mharden-sls=", mharden_sls_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Select straight-line speculation hardening scope (ARM/AArch64/X86 only). <arg> must be: all, none, retbr(ARM/AArch64), blr(ARM/AArch64), comdat(ARM/AArch64), nocomdat(ARM/AArch64), return(X86), indirect-jmp(X86)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhreset", mhreset, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhtm", mhtm, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhvx-ieee-fp", mhexagon_hvx_ieee_fp, Flag, m_hexagon_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable Hexagon HVX IEEE floating-point", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhvx-length=", mhexagon_hvx_length_EQ, Joined, m_hexagon_Features_HVX_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Set Hexagon Vector Length", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "64B,128B")
OPTION(prefix_1, "-mhvx-qfloat", mhexagon_hvx_qfloat, Flag, m_hexagon_Features_HVX_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable Hexagon HVX QFloat instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhvx=", mhexagon_hvx_EQ, Joined, m_hexagon_Features_HVX_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable Hexagon Vector eXtensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhvx", mhexagon_hvx, Flag, m_hexagon_Features_HVX_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable Hexagon Vector eXtensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--mhwdiv=", _mhwdiv_EQ, Joined, INVALID, mhwdiv_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhwdiv=", mhwdiv_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--mhwdiv", _mhwdiv, Separate, INVALID, mhwdiv_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mhwmult=", mhwmult_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-miamcu", miamcu, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Use Intel MCU ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mieee-fp", mieee_fp, Flag, clang_ignored_m_Group, INVALID, nullptr, TargetSpecific | Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mieee-rnd-near", mieee_rnd_near, Flag, m_hexagon_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mignore-xcoff-visibility", mignore_xcoff_visibility, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--migrate", _migrate, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Run the migrator", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-migrate", migrate, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Migrate source code", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mimplicit-float", mimplicit_float, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mimplicit-it=", mimplicit_it_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mincremental-linker-compatible", mincremental_linker_compatible, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | DefaultVis | CLOption, 0,
       "(integrated-as) Emit an object file which can be used with an incremental linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mindirect-branch-cs-prefix", mindirect_branch_cs_prefix, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | DefaultVis | CLOption, 0,
       "Add cs prefix to call and jmp to indirect thunk", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mindirect-jump=", mindirect_jump_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Change indirect jump instructions to inhibit speculation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-minline-all-stringops", minline_all_stringops, Flag, clang_ignored_m_Group, INVALID, nullptr, TargetSpecific | Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-minvariant-function-descriptors", minvariant_function_descriptors, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-minvpcid", minvpcid, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mios-simulator-version-min=", mios_simulator_version_min_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mios-version-min=", mios_version_min_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Set iOS deployment target", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-miphoneos-version-min=", anonymous_1597, Joined, m_Group, mios_version_min_EQ, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-miphonesimulator-version-min=", anonymous_1598, Joined, INVALID, mios_simulator_version_min_EQ, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips16", mips16, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips1", mips1, Flag, m_mips_Features_Group, march_EQ, "mips1\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips1", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips2", mips2, Flag, m_mips_Features_Group, march_EQ, "mips2\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips2", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips32r2", mips32r2, Flag, m_mips_Features_Group, march_EQ, "mips32r2\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips32r2", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips32r3", mips32r3, Flag, m_mips_Features_Group, march_EQ, "mips32r3\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips32r3", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips32r5", mips32r5, Flag, m_mips_Features_Group, march_EQ, "mips32r5\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips32r5", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips32r6", mips32r6, Flag, m_mips_Features_Group, march_EQ, "mips32r6\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips32r6", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips32", mips32, Flag, m_mips_Features_Group, march_EQ, "mips32\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips32", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips3", mips3, Flag, m_mips_Features_Group, march_EQ, "mips3\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips3", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips4", mips4, Flag, m_mips_Features_Group, march_EQ, "mips4\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips4", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips5", mips5, Flag, m_mips_Features_Group, march_EQ, "mips5\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips5", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips64r2", mips64r2, Flag, m_mips_Features_Group, march_EQ, "mips64r2\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips64r2", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips64r3", mips64r3, Flag, m_mips_Features_Group, march_EQ, "mips64r3\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips64r3", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips64r5", mips64r5, Flag, m_mips_Features_Group, march_EQ, "mips64r5\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips64r5", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips64r6", mips64r6, Flag, m_mips_Features_Group, march_EQ, "mips64r6\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips64r6", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mips64", mips64, Flag, m_mips_Features_Group, march_EQ, "mips64\0", HelpHidden, DefaultVis, 0,
       "Equivalent to -march=mips64", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-misel", misel, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MJ", MJ, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Write a compilation database entry per input", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mkernel", mkernel, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mkl", mkl, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlarge-data-threshold=", mlarge_data_threshold_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | FlangOption | FC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlasx", mlasx, Flag, m_loongarch_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable Loongson Advanced SIMD Extension (LASX).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mldc1-sdc1", mldc1_sdc1, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlimit-float-precision", mlimit_float_precision, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Limit float precision to the given value", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlink-bitcode-file", mlink_bitcode_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Link the given bitcode file before performing optimizations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlink-builtin-bitcode-postopt", mlink_builtin_bitcode_postopt, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Link builtin bitcodes after the optimization pipeline", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlink-builtin-bitcode", mlink_builtin_bitcode, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Link and internalize needed symbols from the given bitcode file before performing optimizations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlinker-version=", mlinker_version_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlittle-endian", mlittle_endian, Flag, m_Group, INVALID, nullptr, NoXarchOption | TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mllvm=", anonymous_1600, Joined, INVALID, mllvm, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Alias for -mllvm", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-mllvm", mllvm, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption | FC1Option | FlangOption, 0,
       "Additional arguments to forward to LLVM's option processing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlocal-sdata", mlocal_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Extend the -G behaviour to object local data (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlong-calls", mlong_calls, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Generate branches with extended addressability, usually via indirect jumps.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlong-double-128", mlong_double_128, Flag, LongDouble_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Force long double to be 128 bits", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlong-double-64", mlong_double_64, Flag, LongDouble_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Force long double to be 64 bits", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlong-double-80", mlong_double_80, Flag, LongDouble_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Force long double to be 80 bits, padded to 128 bits for storage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlongcall", mlongcall, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlr-for-calls-only", mlr_for_calls_only, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Do not allocate the LR register for general purpose usage, only for calls. (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlsx", mlsx, Flag, m_loongarch_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable Loongson SIMD Extension (LSX).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlvi-cfi", mlvi_cfi, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Enable only control-flow mitigations for Load Value Injection (LVI)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlvi-hardening", mlvi_hardening, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Enable all mitigations for Load Value Injection (LVI)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlwp", mlwp, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mlzcnt", mlzcnt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmacos-version-min=", mmacos_version_min_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Set macOS deployment target", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmacosx-version-min=", anonymous_1602, Joined, m_Group, mmacos_version_min_EQ, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmadd4", mmadd4, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable the generation of 4-operand madd.s, madd.d and related instructions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmark-bti-property", mmark_bti_property, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Add .note.gnu.property with BTI to assembly files (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmcu=", mmcu_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MMD", MMD, Flag, M_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Write a depfile containing user headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmemops", mmemops, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable generation of memop instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmfcrf", mmfcrf, Flag, INVALID, mmfocrf, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmfocrf", mmfocrf, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmicromips", mmicromips, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmlir", mmlir, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | FC1Option | FlangOption, 0,
       "Additional arguments to forward to MLIR's option processing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmma", mmma, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmmx", mmmx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmovbe", mmovbe, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmovdir64b", mmovdir64b, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmovdiri", mmovdiri, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmpx", mmpx, Flag, clang_ignored_legacy_options_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mms-bitfields", mms_bitfields, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set the default structure layout to be compatible with the Microsoft compiler standard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmsa", mmsa, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable MSA ASE (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmt", mmt, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable MT ASE (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmultimemory", mmultimemory, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmultivalue", mmultivalue, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmutable-globals", mmutable_globals, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mmwaitx", mmwaitx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MM", MM, Flag, M_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Like -MMD, but also implies -E and writes to stdout by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnan=", mnan_EQ, Joined, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-3dnowa", mno_3dnowa, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-3dnow", mno_3dnow, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-80387", mno_80387, Flag, INVALID, mno_x87, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-abicalls", mno_abicalls, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable SVR4-style position-independent code (Mips only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-adx", mno_adx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-aes", mno_aes, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-altivec", mno_altivec, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amdgpu-ieee", mno_amdgpu_ieee, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amdgpu-precise-memory-op", mno_amdgpu_precise_memory_op, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable precise memory mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amx-bf16", mno_amx_bf16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amx-complex", mno_amx_complex, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amx-fp16", mno_amx_fp16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amx-int8", mno_amx_int8, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-amx-tile", mno_amx_tile, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-apx-features=", mno_apx_features_EQ, CommaJoined, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CLOption | FlangOption | DefaultVis | CLOption, 0,
       "Disable features of APX", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "egpr,push2pop2,ppx,ndd,ccmp,nf,cf,zu")
OPTION(prefix_1, "-mno-apxf", mno_apxf, Flag, INVALID, mno_apx_features_EQ, "egpr\0push2pop2\0ppx\0ndd\0ccmp\0nf\0cf\0zu\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-atomics", mno_atomics, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx10.1-256", mno_avx10_1_256, Flag, m_x86_AVX10_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx10.1-512", mno_avx10_1_512, Flag, m_x86_AVX10_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx10.1", mno_avx10_1, Flag, INVALID, mno_avx10_1_256, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx2", mno_avx2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512bf16", mno_avx512bf16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512bitalg", mno_avx512bitalg, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512bw", mno_avx512bw, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512cd", mno_avx512cd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512dq", mno_avx512dq, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512fp16", mno_avx512fp16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512f", mno_avx512f, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512ifma", mno_avx512ifma, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512vbmi2", mno_avx512vbmi2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512vbmi", mno_avx512vbmi, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512vl", mno_avx512vl, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512vnni", mno_avx512vnni, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512vp2intersect", mno_avx512vp2intersect, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx512vpopcntdq", mno_avx512vpopcntdq, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avxifma", mno_avxifma, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avxneconvert", mno_avxneconvert, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avxvnniint16", mno_avxvnniint16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avxvnniint8", mno_avxvnniint8, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avxvnni", mno_avxvnni, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-avx", mno_avx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-backchain", mno_backchain, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-bmi2", mno_bmi2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-bmi", mno_bmi, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-branch-likely", mno_branch_likely, Flag, m_Group, INVALID, nullptr, HelpHidden, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-bti-at-return-twice", mno_bti_at_return_twice, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Do not add a BTI instruction after a setjmp or other return-twice construct (Arm/AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-bulk-memory", mno_bulk_memory, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-check-zero-division", mno_check_zero_division, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-cldemote", mno_cldemote, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-clflushopt", mno_clflushopt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-clwb", mno_clwb, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-clzero", mno_clzero, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-cmpb", mno_cmpb, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-cmpccxadd", mno_cmpccxadd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-constant-cfstrings", mno_constant_cfstrings, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-constructor-aliases", mno_constructor_aliases, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Disable emitting complete constructors and destructors as aliases when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-crbits", mno_crbits, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-crc32", mno_crc32, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-crc", mno_crc, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disallow use of CRC instructions (Mips only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-crypto", mnopower8_crypto, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-cumode", mno_cumode, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Specify WGP wavefront execution mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-cx16", mno_cx16, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-daz-ftz", mno_daz_ftz, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not globally set the denormals-are-zero (DAZ) and flush-to-zero (FTZ) bits in the floating-point control register on program startup", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-default-build-attributes", mno_default_build_attributes, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-direct-move", mnodirect_move, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-dspr2", mno_dspr2, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-dsp", mno_dsp, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-embedded-data", mno_embedded_data, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Do not place constants in the .rodata section instead of the .sdata if they meet the -G <size> threshold (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-enqcmd", mno_enqcmd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-evex512", mno_evex512, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-exception-handling", mno_exception_handing, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-execute-only", mno_execute_only, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Allow generation of data access to code sections (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-extended-const", mno_extended_const, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-extern-sdata", mno_extern_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Do not assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-f16c", mno_f16c, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fix-cmse-cve-2021-35465", mno_fix_cmse_cve_2021_35465, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Don't work around VLLDM erratum CVE-2021-35465 (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fix-cortex-a53-835769", mno_fix_cortex_a53_835769, Flag, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Don't workaround Cortex-A53 erratum 835769 (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fix-cortex-a57-aes-1742098", mno_fix_cortex_a57_aes_1742098, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Don't work around Cortex-A57 Erratum 1742098 (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fix-cortex-a72-aes-1655431", mno_fix_cortex_a72_aes_1655431, Flag, m_arm_Features_Group, mno_fix_cortex_a57_aes_1742098, nullptr, TargetSpecific, DefaultVis, 0,
       "Don't work around Cortex-A72 Erratum 1655431 (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-float128", mno_float128, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fma4", mno_fma4, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fma", mno_fma, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fmv", mno_fmv, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable function multiversioning", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-forced-sw-shadow-stack", mno_forced_sw_shadow_stack, Flag, m_riscv_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Not force using software shadow stack when shadow-stack enabled", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fp-ret-in-387", mno_fp_ret_in_387, Flag, INVALID, mno_x87, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fprnd", mno_fprnd, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fpu", mno_fpu, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fsgsbase", mno_fsgsbase, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fsmuld", mno_fsmuld, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-fxsr", mno_fxsr, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-gather", mno_gather, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Disable generation of gather instructions in auto-vectorization(x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-gfni", mno_gfni, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-ginv", mno_ginv, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-global-merge", mno_global_merge, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable merging of globals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-gpopt", mno_gpopt, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Do not use GP relative accesses for symbols known to be in a small data section (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-half-precision", mno_half_precision, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-hreset", mno_hreset, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-htm", mno_htm, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-hvx-ieee-fp", mno_hexagon_hvx_ieee_fp, Flag, m_hexagon_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable Hexagon HVX IEEE floating-point", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-hvx-qfloat", mno_hexagon_hvx_qfloat, Flag, m_hexagon_Features_HVX_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable Hexagon HVX QFloat instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-hvx", mno_hexagon_hvx, Flag, m_hexagon_Features_HVX_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable Hexagon Vector eXtensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-iamcu", mno_iamcu, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-implicit-float", mno_implicit_float, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Don't generate implicit floating point or vector instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-incremental-linker-compatible", mno_incremental_linker_compatible, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "(integrated-as) Emit an object file which cannot be used with an incremental linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-inline-all-stringops", mno_inline_all_stringops, Flag, clang_ignored_m_Group, INVALID, nullptr, TargetSpecific | Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-invariant-function-descriptors", mno_invariant_function_descriptors, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-invpcid", mno_invpcid, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-isel", mno_isel, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-kl", mno_kl, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-lasx", mno_lasx, Flag, m_loongarch_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable Loongson Advanced SIMD Extension (LASX).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-ldc1-sdc1", mno_ldc1_sdc1, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-link-builtin-bitcode-postopt", mno_link_builtin_bitcode_postopt, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-local-sdata", mno_local_sdata, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Do not extend the -G behaviour to object local data (MIPS)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-long-calls", mno_long_calls, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Restore the default behaviour of not generating long calls", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-longcall", mno_longcall, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-lsx", mno_lsx, Flag, m_loongarch_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable Loongson SIMD Extension (LSX).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-lvi-cfi", mno_lvi_cfi, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Disable control-flow mitigations for Load Value Injection (LVI)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-lvi-hardening", mno_lvi_hardening, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Disable mitigations for Load Value Injection (LVI)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-lwp", mno_lwp, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-lzcnt", mno_lzcnt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-madd4", mno_madd4, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable the generation of 4-operand madd.s, madd.d and related instructions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-memops", mno_memops, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable generation of memop instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mfcrf", mno_mfcrf, Flag, INVALID, mno_mfocrf, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mfocrf", mno_mfocrf, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-micromips", mno_micromips, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mips16", mno_mips16, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mma", mno_mma, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mmx", mno_mmx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-movbe", mno_movbe, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-movdir64b", mno_movdir64b, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-movdiri", mno_movdiri, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-movt", mno_movt, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disallow use of movt/movw pairs (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mpx", mno_mpx, Flag, clang_ignored_legacy_options_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-ms-bitfields", mno_ms_bitfields, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not set the default structure layout to be compatible with the Microsoft compiler standard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-msa", mno_msa, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable MSA ASE (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mt", mno_mt, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable MT ASE (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-multimemory", mno_multimemory, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-multivalue", mno_multivalue, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mutable-globals", mno_mutable_globals, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-mwaitx", mno_mwaitx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-neg-immediates", mno_neg_immediates, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disallow converting instructions with negative immediates to their negation or inversion.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-nontrapping-fptoint", mno_nontrapping_fptoint, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-nvj", mno_nvj, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable generation of new-value jumps", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-nvs", mno_nvs, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable generation of new-value stores", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-odd-spreg", mno_odd_spreg, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Disable odd single-precision floating point registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-omit-leaf-frame-pointer", mno_omit_leaf_frame_pointer, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-outline-atomics", mno_outline_atomics, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption, 0,
       "Don't generate local calls to out-of-line atomic operations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-outline", mno_outline, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable function outlining (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-packed-stack", mno_packed_stack, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-packets", mno_packets, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable generation of instruction packets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-paired-vector-memops", mnopaired_vector_memops, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pascal-strings", mno_pascal_strings, Flag, INVALID, fno_pascal_strings, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pclmul", mno_pclmul, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pconfig", mno_pconfig, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pcrel", mno_pcrel, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pic-data-is-text-relative", mno_pic_data_is_text_relative, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Don't assume data segments are relative to text segment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pku", mno_pku, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-popcntd", mno_popcntd, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-popcnt", mno_popcnt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-popc", mno_popc, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-power10-vector", mno_power10_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-power8-vector", mno_power8_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-power9-vector", mno_power9_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-prefetchi", mno_prefetchi, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-prefixed", mno_prefixed, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-prfchw", mno_prfchw, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-ptwrite", mno_ptwrite, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-pure-code", mno_pure_code, Flag, INVALID, mno_execute_only, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-raoint", mno_raoint, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-rdpid", mno_rdpid, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-rdpru", mno_rdpru, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-rdrnd", mno_rdrnd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-rdseed", mno_rdseed, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-red-zone", mno_red_zone, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-reference-types", mno_reference_types, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-regnames", mno_regnames, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Use only register numbers when writing assembly output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-relax-all", mno_relax_all, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-relax-pic-calls", mno_relax_pic_calls, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Do not produce relaxation hints for linkers to try optimizing PIC call sequences into direct calls (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-relaxed-simd", mno_relaxed_simd, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-relax", mno_relax, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable linker relaxation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-restrict-it", mno_restrict_it, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Allow generation of complex IT blocks.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-retpoline-external-thunk", mno_retpoline_external_thunk, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-retpoline", mno_retpoline, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-rtd", mno_rtd, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-rtm", mno_rtm, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sahf", mno_sahf, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-save-restore", mno_save_restore, Flag, m_riscv_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disable using library calls for save and restore", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-scalar-strict-align", mno_scalar_strict_align, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Allow scalar memory accesses to be unaligned (RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-scatter", mno_scatter, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Disable generation of scatter instructions in auto-vectorization(x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-serialize", mno_serialize, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-seses", mno_seses, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Disable speculative execution side effect suppression (SESES)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sgx", mno_sgx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sha512", mno_sha512, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sha", mno_sha, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-shstk", mno_shstk, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sign-ext", mno_sign_ext, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-simd128", mno_simd128, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-skip-rax-setup", mno_skip_rax_setup, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sm3", mno_sm3, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sm4", mno_sm4, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-soft-float", mno_soft_float, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-speculative-load-hardening", mno_speculative_load_hardening, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-spe", mno_spe, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse2", mno_sse2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse3", mno_sse3, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse4.1", mno_sse4_1, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse4.2", mno_sse4_2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse4a", mno_sse4a, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse4", mno_sse4, Flag, INVALID, mno_sse4_1, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-sse", mno_sse, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-ssse3", mno_ssse3, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-stack-arg-probe", mno_stack_arg_probe, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable stack probes which are enabled by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-stackrealign", mno_stackrealign, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-strict-align", mno_strict_align, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Allow memory accesses to be unaligned (AArch64/LoongArch/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tail-call", mno_tail_call, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tbm", mno_tbm, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tgsplit", mno_tgsplit, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable threadgroup split execution mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-thumb", mno_thumb, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tls-direct-seg-refs", mno_tls_direct_seg_refs, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable direct TLS access through segment registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tocdata=", mno_tocdata_EQ, CommaJoined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specifies a list of variables to be exempt from the TOC datatransformation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tocdata", mno_tocdata, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "This is the default. TOC data transformation is not applied to anyvariables. Only variables specified explicitly in -mtocdata= willhave the TOC data transformation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-tsxldtrk", mno_tsxldtrk, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-type-check", mno_type_check, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Don't perform type checking of the assembly code (wasm only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-uintr", mno_uintr, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-unaligned-access", mno_unaligned_access, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Force all memory accesses to be aligned (AArch32/MIPSr6 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-unaligned-symbols", mno_unaligned_symbols, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Expect external char-aligned symbols to be without ABI alignment (SystemZ only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-unsafe-fp-atomics", mno_unsafe_fp_atomics, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-usermsr", mno_usermsr, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vaes", mno_vaes, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vector-strict-align", mno_vector_strict_align, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Allow vector memory accesses to be unaligned (RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vevpu", mno_vevpu, Flag, m_ve_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-virt", mno_virt, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vis2", mno_vis2, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vis3", mno_vis3, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vis", mno_vis, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vpclmulqdq", mno_vpclmulqdq, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vsx", mno_vsx, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vx", mno_vx, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-vzeroupper", mno_vzeroupper, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-waitpkg", mno_waitpkg, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-warn-nonportable-cfstrings", mno_warn_nonportable_cfstrings, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-wavefrontsize64", mno_wavefrontsize64, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Specify wavefront size 32 mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-wbnoinvd", mno_wbnoinvd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-widekl", mno_widekl, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-x87", mno_x87, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xcoff-roptr", mno_xcoff_roptr, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xgot", mno_xgot, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xop", mno_xop, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xsavec", mno_xsavec, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xsaveopt", mno_xsaveopt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xsaves", mno_xsaves, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-xsave", mno_xsave, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mno-zvector", mno_zvector, Flag, INVALID, fno_zvector, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnocrc", mnocrc, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disallow use of CRC instructions (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnoexecstack", mno_exec_stack, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Mark the file as not needing an executable stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnontrapping-fptoint", mnontrapping_fptoint, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnop-mcount", mnop_mcount, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnvj", mnvj, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable generation of new-value jumps", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mnvs", mnvs, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable generation of new-value stores", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-modd-spreg", modd_spreg, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Enable odd single-precision floating point registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-module-dependency-dir", module_dependency_dir, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Directory to dump module dependencies to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-module-dir", module_dir, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Put MODULE files in <dir>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_1, "-module-file-deps", module_file_deps, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include module files in dependency output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-module-file-info", module_file_info, Flag, Action_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Provide information about a particular module file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-module-suffix", module_suffix, Separate, f_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Use <suffix> as the suffix for module files (the default value is `.mod`)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<suffix>", nullptr)
OPTION(prefix_1, "-momit-leaf-frame-pointer", momit_leaf_frame_pointer, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Omit frame pointer setup for leaf functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-moslib=", moslib_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-moutline-atomics", moutline_atomics, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption, 0,
       "Generate local calls to out-of-line atomic operations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-moutline", moutline, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable function outlining (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpacked-stack", mpacked_stack, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use packed stack layout (SystemZ only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpackets", mpackets, Flag, m_hexagon_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable generation of instruction packets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpad-max-prefix-size=", mpad_max_prefix_size_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Specify maximum number of prefixes to use for padding", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpaired-vector-memops", mpaired_vector_memops, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpascal-strings", mpascal_strings, Flag, INVALID, fpascal_strings, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpclmul", mpclmul, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpconfig", mpconfig, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpcrel", mpcrel, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpic-data-is-text-relative", mpic_data_is_text_relative, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Assume data segments are relative to text segment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpku", mpku, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpopcntd", mpopcntd, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpopcnt", mpopcnt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpopc", mpopc, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpower10-vector", mpower10_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpower8-vector", mpower8_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpower9-vector", mpower9_vector, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mprefer-vector-width=", mprefer_vector_width_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mprefetchi", mprefetchi, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mprefixed", mprefixed, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mprfchw", mprfchw, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mprintf-kind=", mprintf_kind_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specify the printf lowering scheme (AMDGPU only), allowed values are \"hostcall\"(printing happens during kernel execution, this scheme relies on hostcalls which require system to support pcie atomics) and \"buffered\"(printing happens after all kernel threads exit, this uses a printf buffer and does not rely on pcie atomic support)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "hostcall,buffered")
OPTION(prefix_1, "-mprivileged", mprivileged, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mptwrite", mptwrite, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mpure-code", mpure_code, Flag, INVALID, mexecute_only, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MP", MP, Flag, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Create phony target for each dependency (other than main file)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/MP", _SLASH_MP, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mqdsp6-compat", mqdsp6_compat, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable hexagon-qdsp6 backward compatibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MQ", MQ, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify name of main file output to quote in depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mraoint", mraoint, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrdpid", mrdpid, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrdpru", mrdpru, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrdrnd", mrdrnd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrdseed", mrdseed, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mreassociate", mreassociate, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Allow reassociation transformations for floating-point instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrecip=", mrecip_EQ, CommaJoined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Control use of approximate reciprocal and reciprocal square root instructions followed by <n> iterations of Newton-Raphson refinement. <value> = ( ['!'] ['vec-'] ('rcp'|'sqrt') [('h'|'s'|'d')] [':'<n>] ) | 'all' | 'default' | 'none'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrecip", mrecip, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Equivalent to '-mrecip=all'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrecord-mcount", mrecord_mcount, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Generate a __mcount_loc section entry for each __fentry__ call.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mred-zone", mred_zone, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mreference-types", mreference_types, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mregnames", mregnames, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Use full register names when writing assembly output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mregparm=", mregparm_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mregparm", mregparm, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Limit the number of registers available for integer arguments", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrelax-all", mrelax_all, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | DefaultVis | CLOption, 0,
       "(integrated-as) Relax all machine instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrelax-pic-calls", mrelax_pic_calls, Flag, m_mips_Features_Group, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Produce relaxation hints for linkers to try optimizing PIC call sequences into direct calls (MIPS only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrelax-relocations=no", mrelax_relocations_no, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Disable x86 relax relocations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrelaxed-simd", mrelaxed_simd, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrelax", mrelax, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable linker relaxation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrelocation-model", mrelocation_model, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "The relocation model to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic")
OPTION(prefix_1, "-mrestrict-it", mrestrict_it, Flag, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Disallow generation of complex IT blocks. It is off by default.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mretpoline-external-thunk", mretpoline_external_thunk, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mretpoline", mretpoline, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrop-protect", mrop_protect, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrtd", mrtd, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Make StdCall calling convention the default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrtm", mrtm, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mrvv-vector-bits=", mrvv_vector_bits_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Specify the size in bits of an RVV vector register", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msahf", msahf, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msave-restore", msave_restore, Flag, m_riscv_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Enable using library calls for save and restore", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msave-temp-labels", msave_temp_labels, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Save temporary labels in the symbol table. Note this may change .s semantics and shouldn't generally be used on compiler-generated code.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mscalar-strict-align", mscalar_strict_align, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Force all scalar memory accesses to be aligned (RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msecure-plt", msecure_plt, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mserialize", mserialize, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mseses", m_seses, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "Enable speculative execution side effect suppression (SESES). Includes LVI control flow integrity mitigations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msgx", msgx, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msha512", msha512, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msha", msha, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mshstk", mshstk, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msign-ext", msign_ext, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msign-return-address-key=", msign_return_address_key_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "a_key,b_key")
OPTION(prefix_1, "-msign-return-address=", msign_return_address_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Select return address signing scope", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,all,non-leaf")
OPTION(prefix_1, "-msimd128", msimd128, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msimd=", msimd_EQ, Joined, m_loongarch_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Select the SIMD extension(s) to be enabled in LoongArch either 'none', 'lsx', 'lasx'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msim", msim, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msingle-float", msingle_float, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mskip-rax-setup", mskip_rax_setup, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Skip setting up RAX register when passing variable arguments (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msm3", msm3, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msm4", msm4, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msmall-data-limit=", msmall_data_limit_EQ, Joined, m_Group, G, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Put global and static data smaller than the limit into a special section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msmall-data-limit", msmall_data_limit, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Put global and static data smaller than the limit into a special section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msmall-data-threshold=", msmall_data_threshold_EQ, Joined, m_Group, G, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msoft-float", msoft_float, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use software floating point", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msoft-quad-float", msoft_quad_float, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mspeculative-load-hardening", mspeculative_load_hardening, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mspe", mspe, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse2avx", msse2avx, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | CC1AsOption | DefaultVis | CLOption, 0,
       "Specify that the assembler should encode SSE instructions with VEX prefix", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse2", msse2, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse3", msse3, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse4.1", msse4_1, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse4.2", msse4_2, Flag, m_x86_Features_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse4a", msse4a, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse4", msse4, Flag, INVALID, msse4_2, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msse", msse, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mssse3", mssse3, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-alignment=", mstack_alignment, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set the stack alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-arg-probe", mstack_arg_probe, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable stack probes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-probe-size=", mstack_probe_size, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set the stack probe size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-protector-guard-offset=", mstack_protector_guard_offset_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given offset for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-protector-guard-reg=", mstack_protector_guard_reg_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given reg for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-protector-guard-symbol=", mstack_protector_guard_symbol_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given symbol for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstack-protector-guard=", mstack_protector_guard_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given guard (global, tls) for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstackrealign", mstackrealign, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Force realign the stack at entry to every function", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mstrict-align", mstrict_align, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Force all memory accesses to be aligned (AArch64/LoongArch/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msve-vector-bits=", msve_vector_bits_EQ, Joined, m_aarch64_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | FlangOption, 0,
       "Specify the size in bits of an SVE vector register. Defaults to the vector length agnostic value of \"scalable\". (AArch64 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-msvr4-struct-return", msvr4_struct_return, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Return small structs in registers (PPC32 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mt-migrate-directory", mt_migrate_directory, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Directory for temporary files produced during ARC or ObjC migration", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtail-call", mtail_call, Flag, m_wasm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtargetos=", mtargetos_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Set the deployment target to be the specified OS and OS version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtbm", mtbm, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/MTd", _SLASH_MTd, Flag, _SLASH_M_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Use static debug run-time", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtgsplit", mtgsplit, Flag, m_amdgpu_Features_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable threadgroup split execution mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mthread-model", mthread_model, Separate, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "The thread model to use. Defaults to 'posix')", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "posix,single")
OPTION(prefix_1, "-mthreads", mthreads, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mthumb", mthumb, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtls-dialect=", mtls_dialect_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Which thread-local storage dialect to use for dynamic accesses of TLS variables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtls-direct-seg-refs", mtls_direct_seg_refs, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable direct TLS access through segment registers (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtls-size=", mtls_size_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specify bit size of immediate TLS offsets (AArch64 ELF only): 12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtocdata=", mtocdata_EQ, CommaJoined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specifies a list of variables to which the TOC data transformationwill be applied.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtocdata", mtocdata, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "All suitable variables will have the TOC data transformation applied", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtp=", mtp_mode_EQ, Joined, m_arm_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Thread pointer access method. For AArch32: 'soft' uses a function call, or 'tpidrurw', 'tpidruro' or 'tpidrprw' use the three CP15 registers. 'cp15' is an alias for 'tpidruro'. For AArch64: 'tpidr_el0', 'tpidr_el1', 'tpidr_el2', 'tpidr_el3' or 'tpidrro_el0' use the five system registers. 'elN' is an alias for 'tpidr_elN'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "soft,cp15,tpidrurw,tpidruro,tpidrprw,el0,el1,el2,el3,tpidr_el0,tpidr_el1,tpidr_el2,tpidr_el3,tpidrro_el0")
OPTION(prefix_1, "-mtp", mtp, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Mode for reading thread pointer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtsxldtrk", mtsxldtrk, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtune=help", anonymous_1710, Flag, INVALID, print_supported_cpus, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtune=", mtune_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Only supported on AArch64, PowerPC, RISC-V, SPARC, SystemZ, and X86", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtvos-simulator-version-min=", mtvos_simulator_version_min_EQ, Joined, INVALID, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mtvos-version-min=", mtvos_version_min_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MT", MT, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify name of main file output in depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/MT", _SLASH_MT, Flag, _SLASH_M_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Use static run-time", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-muclibc", muclibc, Flag, m_libc_Group, INVALID, nullptr, HelpHidden | HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-muintr", muintr, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-multi_module", multi__module, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-multiply_defined_unused", multiply__defined__unused, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-multiply_defined", multiply__defined, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-munaligned-access", munaligned_access, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Allow memory accesses to be unaligned (AArch32/MIPSr6 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-munaligned-symbols", munaligned_symbols, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Expect external char-aligned symbols to be without ABI alignment (SystemZ only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-municode", municode, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-munsafe-fp-atomics", munsafe_fp_atomics, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Enable generation of unsafe floating point atomic instructions. May generate more efficient code, but may not respect rounding and denormal modes, and may give incorrect results for certain memory destinations. (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-musermsr", musermsr, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv55", mv55, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv55\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv5", mv5, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv5\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv60", mv60, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv60\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv62", mv62, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv62\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv65", mv65, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv65\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv66", mv66, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv66\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv67t", mv67t, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv67t\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv67", mv67, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv67\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv68", mv68, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv68\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv69", mv69, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv69\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv71t", mv71t, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv71t\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv71", mv71, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv71\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mv73", mv73, Flag, m_hexagon_Features_Group, mcpu_EQ, "hexagonv73\0", TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvaes", mvaes, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvector-strict-align", mvector_strict_align, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0,
       "Force all vector memory accesses to be aligned (RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvevpu", mvevpu, Flag, m_ve_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "Emit VPU instructions for VE", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvirt", mvirt, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvis2", mvis2, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvis3", mvis3, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvis", mvis, Flag, m_sparc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvpclmulqdq", mvpclmulqdq, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvscale-max=", mvscale_max_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Specify the vscale maximum. Defaults to the vector length agnostic value of \"0\". (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvscale-min=", mvscale_min_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Specify the vscale minimum. Defaults to \"1\". (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvsx", mvsx, Flag, m_ppc_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvx", mvx, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mvzeroupper", mvzeroupper, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-MV", MV, Flag, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use NMake/Jom format for the depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwaitpkg", mwaitpkg, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwarn-nonportable-cfstrings", mwarn_nonportable_cfstrings, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwatchos-simulator-version-min=", mwatchos_simulator_version_min_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwatchos-version-min=", mwatchos_version_min_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwatchsimulator-version-min=", mwatchsimulator_version_min_EQ, Joined, INVALID, mwatchos_simulator_version_min_EQ, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwavefrontsize64", mwavefrontsize64, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Specify wavefront size 64 mode (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwbnoinvd", mwbnoinvd, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwidekl", mwidekl, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mwindows", mwindows, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mx32", mx32, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mx87", mx87, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxcoff-build-id=", mxcoff_build_id_EQ, Joined, Link_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "On AIX, request creation of a build-id string, \"0xHEXSTRING\", in the string table of the loader section inside the linked binary", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<0xHEXSTRING>", nullptr)
OPTION(prefix_1, "-mxcoff-roptr", mxcoff_roptr, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Place constant objects with relocatable address values in the RO data section and add -bforceimprw to the linker flags (AIX only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxgot", mxgot, Flag, m_mips_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxop", mxop, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxsavec", mxsavec, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxsaveopt", mxsaveopt, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxsaves", mxsaves, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mxsave", mxsave, Flag, m_x86_Features_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-mzos-hlq-clang=", mzos_hlq_clang_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "High level qualifier for z/OS C++RT side deck datasets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<ClangHLQ>", nullptr)
OPTION(prefix_1, "-mzos-hlq-csslib=", mzos_hlq_csslib_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "High level qualifier for z/OS CSSLIB dataset", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<CsslibHLQ>", nullptr)
OPTION(prefix_1, "-mzos-hlq-le=", mzos_hlq_le_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "High level qualifier for z/OS Language Environment datasets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<LeHLQ>", nullptr)
OPTION(prefix_1, "-mzos-sys-include=", mzos_sys_include_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Path to system headers on z/OS", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<SysInclude>", nullptr)
OPTION(prefix_1, "-mzvector", mzvector, Flag, INVALID, fzvector, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-M", M, Flag, M_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Like -MD, but also implies -E and writes to stdout by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-new-struct-path-tbaa", new_struct_path_tbaa, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable enhanced struct-path aware Type Based Alias Analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-canonical-prefixes", no_canonical_prefixes, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Use relative paths for invoking subcommands", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-clear-ast-before-backend", no_clear_ast_before_backend, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't clear the Clang AST before running backend code generation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-code-completion-globals", no_code_completion_globals, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not include global declarations in code-completion results.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-code-completion-ns-level-decls", no_code_completion_ns_level_decls, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-cpp-precomp", no_cpp_precomp, Flag, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-cuda-gpu-arch=", no_cuda_gpu_arch_EQ, Joined, cuda_Group, no_offload_arch_EQ, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-cuda-include-ptx=", no_cuda_include_ptx_EQ, Joined, cuda_Group, INVALID, nullptr, NoXarchOption, DefaultVis | DefaultVis | CLOption, 0,
       "Do not include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-cuda-noopt-device-debug", no_cuda_noopt_device_debug, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-cuda-version-check", no_cuda_version_check, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Don't error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-default-config", no_default_config, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Disable loading default configuration files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-emit-llvm-uselists", no_emit_llvm_uselists, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't preserve order of LLVM use-lists when serializing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-enable-noundef-analysis", no_enable_noundef_analysis, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable analyzing function argument and return types for mandatory definedness", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-finalize-removal", migrator_no_finalize_removal, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not remove finalize method in gc mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-gpu-bundle-output", no_gpu_bundle_output, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not bundle output files of HIP device compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-hip-rt", no_hip_rt, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not link against HIP runtime libraries", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-implicit-float", no_implicit_float, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't generate implicit floating point or vector instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-integrated-as", anonymous_1727, Flag, INVALID, fno_integrated_as, nullptr, 0, DefaultVis | CC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-no-integrated-cpp", no_integrated_cpp, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-line-commands", _no_line_commands, Flag, INVALID, P, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-ns-alloc-error", migrator_no_nsalloc_error, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not error on use of NSAllocateCollectable/NSReallocateCollectable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-offload-add-rpath", no_offload_add_rpath, Flag, INVALID, frtlib_add_rpath, nullptr, NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-offload-arch=", no_offload_arch_EQ, Joined, offload_Group, INVALID, nullptr, NoXarchOption, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. 'all' resets the list to its default value.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-offload-compress", no_offload_compress, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-offload-new-driver", no_offload_new_driver, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Don't Use the new driver for offloading compilation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-no-pedantic", no_pedantic, Flag, pedantic_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-pie", no_pie, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-pthread", no_pthread, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-round-trip-args", no_round_trip_args, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable command line arguments round-trip.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-standard-includes", _no_standard_includes, Flag, INVALID, nostdinc, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-standard-libraries", _no_standard_libraries, Flag, INVALID, nostdlib, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no-struct-path-tbaa", no_struct_path_tbaa, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Turn off struct-path aware Type Based Alias Analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-system-header-prefix=", no_system_header_prefix, Joined, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Treat all #include paths starting with <prefix> as not including a system header.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<prefix>", nullptr)
OPTION(prefix_3, "--no-system-header-prefix", anonymous_1705, Separate, INVALID, no_system_header_prefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-undefined", _no_undefined, Flag, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-warnings", _no_warnings, Flag, INVALID, w, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--no-wasm-opt", no_wasm_opt, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable the wasm-opt optimizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-no_dead_strip_inits_and_terms", no__dead__strip__inits__and__terms, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nobuiltininc", nobuiltininc, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Disable builtin #include directories", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nocpp", nocpp, Flag, f_Group, INVALID, nullptr, 0, FC1Option | FlangOption, 0,
       "Disable predefined and command line preprocessor macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nocudainc", anonymous_1681, Flag, INVALID, nogpuinc, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nocudalib", anonymous_1683, Flag, INVALID, nogpulib, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nodefaultlibs", nodefaultlibs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nodriverkitlib", nodriverkitlib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nofixprebinding", nofixprebinding, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nogpuinc", nogpuinc, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Do not add include paths for CUDA/HIP and do not include the default CUDA/HIP wrapper headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nogpulibc", nogpulibc, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nogpulib", nogpulib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Do not link device library for CUDA/HIP device compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nohipwrapperinc", nohipwrapperinc, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Do not include the default HIP wrapper headers and include paths", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nolibc", nolibc, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/nologo", _SLASH_nologo, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nomultidefs", nomultidefs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nopie", nopie, Flag, INVALID, INVALID, nullptr, TargetSpecific, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-noprebind", noprebind, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-noprofilelib", noprofilelib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-noseglinkedit", noseglinkedit, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostartfiles", nostartfiles, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostdinc++", nostdincxx, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable standard #include directories for the C++ standard library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostdinc", nostdinc, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostdlib++", nostdlibxx, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostdlibinc", nostdlibinc, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostdlib", nostdlib, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-nostdsysteminc", nostdsysteminc, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable standard system #include directories", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--nvptx-arch-tool=", nvptx_arch_tool_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Tool used for detecting NVIDIA GPU arch in the system.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-n", n, Flag, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "Don't automatically start assembly file with a text section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-O0", O0, Flag, O_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/O1", anonymous_2153, Flag, cl_Group, _SLASH_O, "1\0", NoXarchOption, CLOption, 0,
       "Optimize for size  (like /Og     /Os /Oy /Ob2 /GF /Gy)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/O2", anonymous_2154, Flag, cl_Group, _SLASH_O, "2\0", NoXarchOption, CLOption, 0,
       "Optimize for speed (like /Og /Oi /Ot /Oy /Ob2 /GF /Gy)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-O4", O4, Flag, O_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ob0", anonymous_2155, Flag, cl_Group, _SLASH_O, "b0\0", NoXarchOption, CLOption, 0,
       "Disable function inlining", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ob1", anonymous_2156, Flag, cl_Group, _SLASH_O, "b1\0", NoXarchOption, CLOption, 0,
       "Only inline functions explicitly or implicitly marked inline", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ob2", anonymous_2157, Flag, cl_Group, _SLASH_O, "b2\0", NoXarchOption, CLOption, 0,
       "Inline functions as deemed beneficial by the compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ob3", anonymous_2158, Flag, cl_Group, _SLASH_O, "b3\0", NoXarchOption, CLOption, 0,
       "Same as /Ob2", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-ObjC++", ObjCXX, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Treat source input files as Objective-C++ inputs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objc-isystem", objc_isystem, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add directory to the ObjC SYSTEM include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-objcmt-allowlist-dir-path=", objcmt_allowlist_dir_path, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Only modify files with a filename contained in the provided directory path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-atomic-property", objcmt_atomic_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Make migration to 'atomic' properties", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-all", objcmt_migrate_all, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-annotation", objcmt_migrate_annotation, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to property and method annotations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-designated-init", objcmt_migrate_designated_init, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-instancetype", objcmt_migrate_instancetype, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to infer instancetype for method result type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-literals", objcmt_migrate_literals, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-ns-macros", objcmt_migrate_nsmacros, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to NS_ENUM/NS_OPTIONS macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-property-dot-syntax", objcmt_migrate_property_dot_syntax, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration of setter/getter messages to property-dot syntax", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-property", objcmt_migrate_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC property", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-protocol-conformance", objcmt_migrate_protocol_conformance, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to add protocol conformance on classes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-readonly-property", objcmt_migrate_readonly_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC readonly property", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-readwrite-property", objcmt_migrate_readwrite_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC readwrite property", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-migrate-subscripting", objcmt_migrate_subscripting, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC subscripting", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-ns-nonatomic-iosonly", objcmt_ns_nonatomic_iosonly, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-returns-innerpointer-property", objcmt_returns_innerpointer_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to annotate property with NS_RETURNS_INNER_POINTER", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-white-list-dir-path=", anonymous_27, Joined, INVALID, objcmt_allowlist_dir_path, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcmt-whitelist-dir-path=", anonymous_26, Joined, INVALID, objcmt_allowlist_dir_path, nullptr, 0, DefaultVis | CC1Option, 0,
       "Alias for -objcmt-allowlist-dir-path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-objcxx-isystem", objcxx_isystem, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add directory to the ObjC++ SYSTEM include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_1, "-ObjC", ObjC, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Treat source input files as Objective-C inputs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-object-file-name=", object_file_name_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0,
       "Set the output <file> for debug infos", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-object-file-name", object_file_name, Separate, INVALID, object_file_name_EQ, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-object", object, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Od", anonymous_2159, Flag, cl_Group, _SLASH_O, "d\0", NoXarchOption, CLOption | DXCOption, 0,
       "Disable optimization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Ofast", Ofast, Joined, O_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{DefaultVis, CC1Option}}, "Deprecated; use '-O3 -ffast-math' for the same behavior, or '-O3' to enable only conforming optimizations") }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-add-rpath", offload_add_rpath, Flag, INVALID, frtlib_add_rpath, nullptr, NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-arch=", offload_arch_EQ, Joined, offload_Group, INVALID, nullptr, NoXarchOption, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Specify an offloading device architecture for CUDA, HIP, or OpenMP. (e.g. sm_35). If 'native' is used the compiler will detect locally installed architectures. For HIP offloading, the device architecture can be followed by target ID features delimited by a colon (e.g. gfx908:xnack+:sramecc-). May be specified more than once.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-compression-level=", offload_compression_level_EQ, Joined, offload_Group, INVALID, nullptr, HelpHidden, DefaultVis | DefaultVis | CLOption, 0,
       "Compression level for offload device binaries (HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-compress", offload_compress, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Compress offload device binaries (HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-device-only", offload_device_only, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Only compile for the offloading device.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-host-device", offload_host_device, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Compile for both the offloading host and device (default).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-host-only", offload_host_only, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | DefaultVis | CLOption, 0,
       "Only compile for the offloading host.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-link", offload_link, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Use the new offloading linker to perform the link job.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload-new-driver", offload_new_driver, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the new driver for offloading compilation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--offload=", offload_EQ, CommaJoined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Specify comma-separated list of offloading target triples (CUDA and HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Og", anonymous_2160, Flag, cl_Group, _SLASH_O, "g\0", NoXarchOption, CLOption, 0,
       "No effect", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Oi-", anonymous_2162, Flag, cl_Group, _SLASH_O, "i-\0", NoXarchOption, CLOption, 0,
       "Disable use of builtin functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Oi", anonymous_2161, Flag, cl_Group, _SLASH_O, "i\0", NoXarchOption, CLOption, 0,
       "Enable use of builtin functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/openmp-", _SLASH_openmp_, Flag, cl_Group, fno_openmp, nullptr, NoXarchOption, CLOption, 0,
       "Disable OpenMP support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/openmp:experimental", _SLASH_openmp_experimental, Flag, cl_Group, fopenmp, nullptr, NoXarchOption, CLOption, 0,
       "Enable OpenMP support with experimental SIMD support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/openmp", _SLASH_openmp, Flag, cl_Group, fopenmp, nullptr, NoXarchOption, CLOption, 0,
       "Enable OpenMP support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-opt-record-file", opt_record_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "File name to use for YAML optimization record output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-opt-record-format", opt_record_format, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "The format used for serializing remarks (default: YAML)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-opt-record-passes", opt_record_passes, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Only record remark information for passes whose names match the given regular expression", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--optimize=", _optimize_EQ, Joined, INVALID, O, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--optimize", _optimize, Flag, INVALID, O, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Os", anonymous_2163, Flag, cl_Group, _SLASH_O, "s\0", NoXarchOption, CLOption, 0,
       "Optimize for size (like clang -Os)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ot", anonymous_2164, Flag, cl_Group, _SLASH_O, "t\0", NoXarchOption, CLOption, 0,
       "Optimize for speed (like clang -O3)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-output-asm-variant", output_asm_variant, Separate, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "Select the asm variant index to use for output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--output-class-directory=", _output_class_directory_EQ, Joined, INVALID, foutput_class_dir_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--output-class-directory", _output_class_directory, Separate, INVALID, foutput_class_dir_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--output=", _output_EQ, Joined, INVALID, o, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--output", _output, Separate, INVALID, o, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ox", anonymous_2165, Flag, cl_Group, _SLASH_O, "x\0", NoXarchOption, CLOption, 0,
       "Deprecated (like /Og /Oi /Ot /Oy /Ob2); use /O2", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Oy-", anonymous_2167, Flag, cl_Group, _SLASH_O, "y-\0", NoXarchOption, CLOption, 0,
       "Disable frame pointer omission (x86 only, default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Oy", anonymous_2166, Flag, cl_Group, _SLASH_O, "y\0", NoXarchOption, CLOption, 0,
       "Enable frame pointer omission (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-O", O_flag, Flag, INVALID, O, "1\0", 0, DefaultVis | CC1Option | FC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-O", O, Joined, O_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/O", _SLASH_O, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption | DXCOption, 0,
       "Set multiple /O flags at once; e.g. '/O2y-' for '/O2 /Oy-'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<flags>", nullptr)
OPTION(prefix_1, "-o", o, JoinedOrSeparate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | CC1AsOption | FC1Option | FlangOption, 0,
       "Write output to <file>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_2, "/o", _SLASH_o, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Deprecated (set output file name); use /Fe or /Fe", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file or dir/>", nullptr)
OPTION(prefix_1, "-pagezero_size", pagezero__size, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--param=", _param_EQ, Joined, INVALID, _param, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--param", _param, Separate, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-pass-exit-codes", pass_exit_codes, Flag, INVALID, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pch-through-hdrstop-create", pch_through_hdrstop_create, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "When creating a PCH, stop PCH generation after #pragma hdrstop.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pch-through-hdrstop-use", pch_through_hdrstop_use, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "When using a PCH, skip tokens until after a #pragma hdrstop.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pch-through-header=", pch_through_header_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Stop PCH generation after including this file.  When using a PCH, skip tokens until after this file is included.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-pedantic-errors", pedantic_errors, Flag, pedantic_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-pedantic", pedantic, Flag, pedantic_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Warn on language extensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/permissive-", _SLASH_permissive_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable non conforming code from compiling (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/permissive", _SLASH_permissive, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Enable some non conforming code to compile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pg", pg, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable mcount instrumentation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pic-is-pie", pic_is_pie, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "File is for a position independent executable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pic-level", pic_level, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Value for __PIC__", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pie", pie, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-pipe", pipe, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Use pipes between commands, when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-plugin-arg-", plugin_arg, JoinedAndSeparate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Pass <arg> to plugin <name>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name> <arg>", nullptr)
OPTION(prefix_1, "-plugin", plugin, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Use the named plugin action instead of the default action (use \"help\" to list available options)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>", nullptr)
OPTION(prefix_1, "-pointer-tbaa", pointer_tbaa, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Turn on Type Based Alias Analysis for pointer accesses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-preamble-bytes=", preamble_bytes_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Assume that the precompiled header is a precompiled preamble covering the first N bytes of the main file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-prebind_all_twolevel_modules", prebind__all__twolevel__modules, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-prebind", prebind, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--precompile", _precompile, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "Only precompile the input", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--prefix=", _prefix_EQ, Joined, INVALID, B, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--prefix", _prefix, Separate, INVALID, B, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-preload", preload, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--preprocess", _preprocess, Flag, INVALID, E, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--pretty-sgf", emit_pretty_sgf, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit pretty printed symbol graphs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-print-dependency-directives-minimized-source", print_dependency_directives_minimized_source, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Print the output of the dependency directives source minimizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--print-diagnostic-categories", _print_diagnostic_categories, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-diagnostic-options", print_diagnostic_options, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print all of Clang's warning options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-effective-triple", print_effective_triple, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption | CLOption, 0,
       "Print the effective target triple", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-enabled-extensions", print_enabled_extensions, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Print the extensions enabled by the given target and -march/-mcpu options. (AArch64 and RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-file-name=", print_file_name_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the full library path of <file>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_3, "--print-file-name", _print_file_name, Separate, INVALID, print_file_name_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-print-ivar-layout", print_ivar_layout, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable Objective-C Ivar layout bitmap print trace", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-libgcc-file-name", print_libgcc_file_name, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the library path for the currently used compiler runtime library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-library-module-manifest-path", print_std_module_manifest_path, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the path for the C++ Standard library module manifest", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--print-missing-file-dependencies", _print_missing_file_dependencies, Flag, INVALID, MG, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-multi-directory", print_multi_directory, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-multi-flags-experimental", print_multi_flags, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Print the flags used for selecting multilibs (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-multi-lib", print_multi_lib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-multi-os-directory", print_multi_os_directory, Flag, INVALID, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-multiarch", anonymous_1691, Flag, INVALID, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-print-preamble", print_preamble, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Print the \"preamble\" of a file, which is a candidate for implicit precompiled headers.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-prog-name=", print_prog_name_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the full program path of <name>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>", nullptr)
OPTION(prefix_3, "--print-prog-name", _print_prog_name, Separate, INVALID, print_prog_name_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-resource-dir", print_resource_dir, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | FlangOption, 0,
       "Print the resource directory pathname", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{FlangOption}}, "Print the resource directory pathname that contains lib and include directories with the runtime libraries and MODULE files.") }}), nullptr, nullptr)
OPTION(prefix_4, "-print-rocm-search-dirs", print_rocm_search_dirs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the paths used for finding ROCm installation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-runtime-dir", print_runtime_dir, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the directory pathname containing Clang's runtime libraries", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-search-dirs", print_search_dirs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the paths used for finding libraries and programs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-print-stats", print_stats, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print performance metrics and statistics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-supported-cpus", print_supported_cpus, Flag, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Print supported cpu models for the given target (if target is not specified, it will print the supported cpus for the default target)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-supported-extensions", print_supported_extensions, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Print supported -march extensions (RISC-V, AArch64 and ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-target-triple", print_target_triple, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption | CLOption, 0,
       "Print the normalized target triple", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-print-targets", print_targets, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Print the registered targets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-private_bundle", private__bundle, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--product-name=", product_name_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--profile", _profile, Flag, INVALID, p, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pthreads", pthreads, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-pthread", pthread, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Support POSIX threads in generated code", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--ptxas-path=", ptxas_path_EQ, Joined, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Path to ptxas (used for compiling CUDA code)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-P", P, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Disable linemarker output in -E mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/P", _SLASH_P, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Preprocess to file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-p", p, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable mcount instrumentation with prof", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qembed_debug", anonymous_2177, Flag, dxc_Group, INVALID, nullptr, Ignored, DXCOption | DXCOption, 0,
       "Embed PDB in shader container (ignored)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qfast_transcendentals", _SLASH_Qfast_transcendentals, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qgather-", anonymous_2168, Flag, cl_Group, mno_gather, nullptr, NoXarchOption, CLOption, 0,
       "Disable generation of gather instructions in auto-vectorization(x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/QIfist", _SLASH_QIfist, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qimprecise_fwaits", _SLASH_Qimprecise_fwaits, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/QIntel-jcc-erratum", _SLASH_QIntel_jcc_erratum, Flag, cl_Group, mbranches_within_32B_boundaries, nullptr, NoXarchOption, CLOption, 0,
       "Align branches within 32-byte boundaries to mitigate the performance impact of the Intel JCC erratum.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Qn", Qn, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not emit metadata containing compiler name and version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qpar-report", _SLASH_Qpar_report, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qpar", _SLASH_Qpar, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qsafe_fp_loads", _SLASH_Qsafe_fp_loads, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qscatter-", anonymous_2169, Flag, cl_Group, mno_scatter, nullptr, NoXarchOption, CLOption, 0,
       "Disable generation of scatter instructions in auto-vectorization(x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qspectre-load-cf", _SLASH_Qspectre_load_cf, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qspectre-load", _SLASH_Qspectre_load, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qspectre", _SLASH_Qspectre, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Qunused-arguments", Qunused_arguments, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption, 0,
       "Don't emit warning for unused driver arguments", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qvec-report", _SLASH_Qvec_report, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qvec-", _SLASH_Qvec_, Flag, cl_Group, fno_vectorize, nullptr, NoXarchOption, CLOption, 0,
       "Disable the loop vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Qvec", _SLASH_Qvec, Flag, cl_Group, fvectorize, nullptr, NoXarchOption, CLOption, 0,
       "Enable the loop vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Qy", Qy, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit metadata containing compiler name and version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Q", Q, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-rdynamic", rdynamic, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-read_only_relocs", read__only__relocs, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-record-command-line", record_command_line, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "The string to embed in the .LLVM.command.line section.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-reexport-l", reexport_l, Joined, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-reexport_framework", reexport_framework, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-reexport_library", reexport_library, JoinedOrSeparate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/reference", _SLASH_reference, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-regcall4", regcall4, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set __regcall4 as a default calling convention to respect __regcall ABI v.4", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-relaxed-aliasing", relaxed_aliasing, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Turn off Type Based Alias Analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-relocatable-pch", relocatable_pch, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Whether to build a relocatable precompiled header", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-remap-file", remap_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Replace the contents of the <from> file with the contents of the <to> file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<from>;<to>", nullptr)
OPTION(prefix_1, "-remap", remap, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-resource-dir=", resource_dir_EQ, Joined, INVALID, resource_dir, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-resource-dir", resource_dir, Separate, INVALID, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CC1Option | CLOption | DXCOption | FlangOption | FC1Option, 0,
       "The directory which holds the compiler resource files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--resource=", _resource_EQ, Joined, INVALID, fcompile_resource_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--resource", _resource, Separate, INVALID, fcompile_resource_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-rewrite-legacy-objc", rewrite_legacy_objc, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Rewrite Legacy Objective-C source to C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-rewrite-macros", rewrite_macros, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Expand macros without full preprocessing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-rewrite-objc", rewrite_objc, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option, 0,
       "Rewrite Objective-C source to C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-rewrite-test", rewrite_test, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Rewriter playground", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--rocm-device-lib-path=", rocm_device_lib_path_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "ROCm device library path. Alternative to rocm-path.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--rocm-path=", rocm_path_EQ, Joined, hip_Group, INVALID, nullptr, 0, FlangOption | DefaultVis | CLOption, 0,
       "ROCm installation path, used for finding and automatically linking required bitcode libraries.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-round-trip-args", round_trip_args, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable command line arguments round-trip.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Rpass-analysis=", Rpass_analysis_EQ, Joined, R_value_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Report transformation analysis from optimization passes whose name matches the given POSIX regular expression", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Rpass-missed=", Rpass_missed_EQ, Joined, R_value_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Report missed transformations by optimization passes whose name matches the given POSIX regular expression", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Rpass=", Rpass_EQ, Joined, R_value_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Report transformations performed by optimization passes whose name matches the given POSIX regular expression", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-rpath", rpath, Separate, Link_Group, INVALID, nullptr, LinkerInput, DefaultVis | CLOption | DXCOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--rsp-quoting=", rsp_quoting, Joined, internal_driver_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Set the rsp quoting to either 'posix', or 'windows'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/RTC", _SLASH_RTC, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-rtlib=", rtlib_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | FlangOption, 0,
       "Compiler runtime library to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--rtlib", _rtlib, Separate, INVALID, rtlib_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-R", R_Joined, Joined, R_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Enable the specified remark", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<remark>", nullptr)
OPTION(prefix_1, "-r", r, Flag, Link_Group, INVALID, nullptr, LinkerInput | NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-save-stats=", save_stats_EQ, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Save llvm statistics.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-save-stats", save_stats, Flag, INVALID, save_stats_EQ, "cwd\0", NoXarchOption, DefaultVis, 0,
       "Save llvm statistics.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-save-temps=", save_temps_EQ, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Save intermediate compilation results. <arg> can be set to 'cwd' for current working directory, or 'obj' which will save temporary files in the same directory as the final output file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-save-temps", save_temps, Flag, INVALID, save_temps_EQ, "cwd\0", NoXarchOption, DefaultVis | FlangOption | FC1Option, 0,
       "Alias for --save-temps=cwd", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/sdl-", _SLASH_sdl_, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/sdl", _SLASH_sdl, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sectalign", sectalign, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 3, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sectcreate", sectcreate, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 3, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sectobjectsymbols", sectobjectsymbols, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 2, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sectorder", sectorder, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 3, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-seg1addr", seg1addr, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-seg_addr_table_filename", seg__addr__table__filename, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-seg_addr_table", seg__addr__table, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-segaddr", segaddr, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 2, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-segcreate", segcreate, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 3, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-seglinkedit", seglinkedit, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-segprot", segprot, MultiArg, INVALID, INVALID, nullptr, 0, DefaultVis, 3, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-segs_read_only_addr", segs__read__only__addr, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-segs_read_write_addr", segs__read__write__addr, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-segs_read_", segs__read__, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-serialize-diagnostic-file", diagnostic_serialized_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "File for serializing diagnostics in a binary format", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<filename>", nullptr)
OPTION(prefix_4, "-serialize-diagnostics", _serialize_diags, Separate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Serialize compiler diagnostics to a file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-setup-static-analyzer", setup_static_analyzer, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set up preprocessor for static analyzer (done automatically when static analyzer is run).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-shared-libasan", anonymous_238, Flag, INVALID, shared_libsan, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-shared-libgcc", shared_libgcc, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-shared-libsan", shared_libsan, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Dynamically link the sanitizer runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-shared", shared, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-show-encoding", show_encoding, Flag, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "Show instruction encoding information in transliterate mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--show-includes", show_includes, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print cl.exe style /showIncludes to stdout", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-show-inst", show_inst, Flag, INVALID, INVALID, nullptr, 0, CC1AsOption, 0,
       "Show internal instruction representation in transliterate mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/showFilenames-", _SLASH_showFilenames_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Do not print the name of each compiled file (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/showFilenames", _SLASH_showFilenames, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Print the name of each compiled file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/showIncludes:user", _SLASH_showIncludes_user, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Like /showIncludes but omit system headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/showIncludes", _SLASH_showIncludes, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Print info about included files to stderr", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--signed-char", _signed_char, Flag, INVALID, fsigned_char, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-single_module", single__module, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/source-charset:", _SLASH_source_charset, Joined, cl_compile_Group, finput_charset_EQ, nullptr, NoXarchOption, CLOption, 0,
       "Set source encoding, supports only UTF-8", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-source-date-epoch", source_date_epoch, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Time to be used in __DATE__, __TIME__, and __TIMESTAMP__ macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<time since Epoch in seconds>", nullptr)
OPTION(prefix_2, "/sourceDependencies:directives", _SLASH_sourceDependenciesDirectives, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/sourceDependencies", _SLASH_sourceDependencies, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-specs=", specs_EQ, Joined, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-specs", specs, Separate, INVALID, INVALID, nullptr, Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/spirv", spirv, Flag, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Generate SPIR-V code", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-split-dwarf-file", split_dwarf_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Name of the split dwarf debug info file to encode in the object file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-split-dwarf-output", split_dwarf_output, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "File name to use for split dwarf debug info output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-stack-protector-buffer-size", stack_protector_buffer_size, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Lower bound for a buffer to be considered for stack protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-stack-protector", stack_protector, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable stack protectors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "0,1,2,3")
OPTION(prefix_1, "-stack-usage-file", stack_usage_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename (or -) to write stack usage output to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--start-no-unused-arguments", start_no_unused_arguments, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "Don't emit warnings about unused arguments for the following arguments", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-define", static_define, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Should __STATIC__ be defined", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-libasan", anonymous_239, Flag, INVALID, static_libsan, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-libgcc", static_libgcc, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-libgfortran", static_libgfortran, Flag, gfortran_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-libsan", static_libsan, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Statically link the sanitizer runtime (Not supported for ASan, TSan or UBSan on darwin)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-libstdc++", static_libstdcxx, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-openmp", static_openmp, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Use the static host OpenMP runtime while linking.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-static-pie", static_pie, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-static", static, Flag, Link_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CLOption | DXCOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-stats-file-append", stats_file_append, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "If stats should be appended to stats-file instead of overwriting it", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-stats-file=", stats_file, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename to write statistics to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-std-default=", std_default_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/std:", _SLASH_std, Joined, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set language version (c++14,c++17,c++20,c++latest,c11,c17)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-std=", std_EQ, Joined, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Language standard to compile for", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, std_EQ_Values)
OPTION(prefix_1, "-stdlib++-isystem", stdlibxx_isystem, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Use directory as the C++ standard library include path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr)
OPTION(prefix_4, "-stdlib=", stdlib_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "C++ standard library to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "libc++,libstdc++,platform")
OPTION(prefix_3, "--stdlib", _stdlib, Separate, INVALID, stdlib_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--std", _std, Separate, INVALID, std_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sub_library", sub__library, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sub_umbrella", sub__umbrella, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sycl-std=", sycl_std_EQ, Joined, sycl_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | CLOption, 0,
       "SYCL language standard to compile for.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "2020,2017,121,1.2.1,sycl-1.2.1")
OPTION(prefix_3, "--symbol-graph-dir=", symbol_graph_dir_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Directory in which to emit symbol graphs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-sys-header-deps", sys_header_deps, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include system headers in dependency output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--sysroot=", _sysroot_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--sysroot", _sysroot, Separate, INVALID, _sysroot_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--system-header-prefix=", system_header_prefix, Joined, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Treat all #include paths starting with <prefix> as including a system header.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<prefix>", nullptr)
OPTION(prefix_3, "--system-header-prefix", anonymous_1704, Separate, INVALID, system_header_prefix, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-S", S, Flag, Action_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Only run preprocess and compilation steps", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-s", s, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-target-abi", target_abi, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Target a particular ABI type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-target-cpu", target_cpu, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Target a specific cpu type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-target-feature", target_feature, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Target specific attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--target-help", _target_help, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-target-linker-version", target_linker_version, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Target linker version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-target-sdk-version=", target_sdk_version_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "The version of target SDK used for compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--target=", target, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Generate code for the given target", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-target", target_legacy_spelling, Separate, INVALID, target, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/TC", _SLASH_TC, Flag, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Treat all source files as C", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Tc", _SLASH_Tc, JoinedOrSeparate, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Treat <file> as C source file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_1, "-templight-dump", templight_dump, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Dump templight information to stdout", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-test-io", test_io, Flag, Action_Group, INVALID, nullptr, 0, FC1Option, 0,
       "Run the InputOuputTest action. Use for development and testing only.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-time", time, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Time individual commands", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/TP", _SLASH_TP, Flag, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Treat all source files as C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Tp", _SLASH_Tp, JoinedOrSeparate, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Treat <file> as C++ source file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr)
OPTION(prefix_3, "--trace-includes", _trace_includes, Flag, INVALID, H, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-traditional-cpp", traditional_cpp, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable some traditional CPP emulation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-traditional", traditional, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/translateInclude", _SLASH_translateInclude, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-trigraphs", trigraphs, Flag, INVALID, ftrigraphs, nullptr, 0, DefaultVis, 0,
       "Process trigraph sequences", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-trim-egraph", trim_egraph, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Only show error-related paths in the analysis graph", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-triple=", triple_EQ, Joined, INVALID, triple, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-triple", triple, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Specify target triple (e.g. i686-apple-darwin9)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-tune-cpu", tune_cpu, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Tune for a specific cpu type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/tune:", _SLASH_tune, Joined, cl_compile_Group, mtune_EQ, nullptr, NoXarchOption, CLOption, 0,
       "Set CPU for optimization without affecting instruction set", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-twolevel_namespace_hints", twolevel__namespace__hints, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-twolevel_namespace", twolevel__namespace, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-T", T, JoinedOrSeparate, T_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Specify <script> as linker script", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<script>", nullptr)
OPTION(prefix_2, "/T", target_profile, JoinedOrSeparate, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Set target profile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<profile>", "ps_6_0, ps_6_1, ps_6_2, ps_6_3, ps_6_4, ps_6_5, ps_6_6, ps_6_7,vs_6_0, vs_6_1, vs_6_2, vs_6_3, vs_6_4, vs_6_5, vs_6_6, vs_6_7,gs_6_0, gs_6_1, gs_6_2, gs_6_3, gs_6_4, gs_6_5, gs_6_6, gs_6_7,hs_6_0, hs_6_1, hs_6_2, hs_6_3, hs_6_4, hs_6_5, hs_6_6, hs_6_7,ds_6_0, ds_6_1, ds_6_2, ds_6_3, ds_6_4, ds_6_5, ds_6_6, ds_6_7,cs_6_0, cs_6_1, cs_6_2, cs_6_3, cs_6_4, cs_6_5, cs_6_6, cs_6_7,lib_6_3, lib_6_4, lib_6_5, lib_6_6, lib_6_7, lib_6_x,ms_6_5, ms_6_6, ms_6_7,as_6_5, as_6_6, as_6_7")
OPTION(prefix_1, "-t", t, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-umbrella", umbrella, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--undefine-macro=", _undefine_macro_EQ, Joined, INVALID, U, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--undefine-macro", _undefine_macro, Separate, INVALID, U, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-undefined", undefined, JoinedOrSeparate, u_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-undef", undef, Flag, u_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "undef all system defines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-unexported_symbols_list", unexported__symbols__list, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-unoptimized-cfg", analysis_UnoptimizedCFG, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate unoptimized CFGs for all analyses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--unsigned-char", _unsigned_char, Flag, INVALID, funsigned_char, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-unwindlib=", unwindlib_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Unwind library to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "libgcc,unwindlib,platform")
OPTION(prefix_3, "--user-dependencies", _user_dependencies, Flag, INVALID, MM, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/utf-8", _SLASH_utf8, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set source and runtime encoding to UTF-8 (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-U", U, JoinedOrSeparate, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Undefine macro <macro>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<macro>", nullptr)
OPTION(prefix_2, "/U", _SLASH_U, JoinedOrSeparate, cl_Group, U, nullptr, NoXarchOption, CLOption, 0,
       "Undefine macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<macro>", nullptr)
OPTION(prefix_1, "-u", u, JoinedOrSeparate, u_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/u", _SLASH_u, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/validate-charset-", _SLASH_validate_charset_, Flag, cl_Group, W_Joined, "no-invalid-source-encoding\0", NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/validate-charset", _SLASH_validate_charset, Flag, cl_Group, W_Joined, "invalid-source-encoding\0", NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/validator-version", dxil_validator_version, Separate, dxc_Group, INVALID, nullptr, HelpHidden, DXCOption | DefaultVis | CC1Option | DXCOption, 0,
       "Override validator version for module. Format: <major.minor>;Default: DXIL.dll version or current internal version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vctoolsdir", _SLASH_vctoolsdir, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Path to the VCToolChain", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_2, "/vctoolsversion", _SLASH_vctoolsversion, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "For use with /winsysroot, defaults to newest found", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Vd", dxc_disable_validation, Flag, dxc_Group, INVALID, nullptr, 0, DXCOption | DXCOption, 0,
       "Disable validation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vd", _SLASH_vd, Joined, cl_Group, vtordisp_mode_EQ, nullptr, NoXarchOption, CLOption, 0,
       "Control vtordisp placement", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-vectorize-loops", vectorize_loops, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run the Loop vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-vectorize-slp", vectorize_slp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run the SLP vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--verbose", _verbose, Flag, INVALID, v, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--verify-debug-info", verify_debug_info, Flag, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Verify the binary representation of debug output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-verify-ignore-unexpected=", verify_ignore_unexpected_EQ, CommaJoined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Ignore unexpected diagnostic messages", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-verify-ignore-unexpected", verify_ignore_unexpected, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Ignore unexpected diagnostic messages", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-verify-pch", verify_pch, Flag, Action_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Load and verify that a pre-compiled header file is not stale", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-verify=", verify_EQ, CommaJoined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Verify diagnostic output using comment directives that start with prefixes in the comma-separated sequence <prefixes>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<prefixes>", nullptr)
OPTION(prefix_1, "-verify", verify, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Equivalent to -verify=expected", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--version", _version, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | FlangOption, 0,
       "Print version information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-version", version, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Print the compiler version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-vfsoverlay", vfsoverlay, JoinedOrSeparate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Overlay the virtual filesystem described by file over the real file system. Additionally, pass this overlay file to the linker if it supports it", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-via-file-asm", via_file_asm, Flag, internal_debug_Group, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CLOption | DXCOption, 0,
       "Write assembly to file for input to assemble jobs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vmb", _SLASH_vmb, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Use a best-case representation method for member pointers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vmg", _SLASH_vmg, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Use a most-general representation for member pointers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vmm", _SLASH_vmm, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set the default most-general representation to multiple inheritance", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vms", _SLASH_vms, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set the default most-general representation to single inheritance", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/vmv", _SLASH_vmv, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Set the default most-general representation to virtual inheritance", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/volatile:iso", _SLASH_volatile_iso, Flag, INVALID, fno_ms_volatile, nullptr, 0, CLOption, 0,
       "Volatile loads and stores have standard semantics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/volatile:ms", _SLASH_volatile_ms, Flag, INVALID, fms_volatile, nullptr, 0, CLOption, 0,
       "Volatile loads and stores have acquire and release semantics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-vtordisp-mode=", vtordisp_mode_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Control vtordisp placement on win32 targets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-V", V, JoinedOrSeparate, INVALID, INVALID, nullptr, NoXarchOption | Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/V", _SLASH_V, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-v", v, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption | FlangOption, 0,
       "Show commands to run and use verbose output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/W0", _SLASH_W0, Flag, cl_Group, w, nullptr, NoXarchOption, CLOption, 0,
       "Disable all warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/W1", _SLASH_W1, Flag, cl_Group, Wall, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wall", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/W2", _SLASH_W2, Flag, cl_Group, Wall, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wall", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/W3", _SLASH_W3, Flag, cl_Group, Wall, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wall", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/W4", _SLASH_W4, Flag, cl_Group, WCL4, nullptr, NoXarchOption, CLOption, 0,
       "Enable -Wall and -Wextra", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wa,", Wa_COMMA, CommaJoined, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass the comma separated arguments in <arg> to the assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_4, "-Waliasing", unsupported_warning_wanonymous_1741, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wall", Wall, Flag, W_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Wall", _SLASH_Wall, Flag, cl_Group, W_Joined, "everything\0", NoXarchOption, CLOption, 0,
       "Enable -Weverything", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wampersand", unsupported_warning_wanonymous_1742, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--warn-=", _warn__EQ, Joined, INVALID, W_Joined, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--warn-", _warn_, Joined, INVALID, W_Joined, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Warray-bounds", unsupported_warning_wanonymous_1743, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--wasm-opt", wasm_opt, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable the wasm-opt optimizer (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wc-binding-type", unsupported_warning_wanonymous_1744, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wcharacter-truncation", unsupported_warning_wanonymous_1745, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-WCL4", WCL4, Flag, W_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wconversion", unsupported_warning_wanonymous_1746, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wdeprecated", Wdeprecated, Flag, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable warnings for deprecated constructs and define __DEPRECATED", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wdo-subscript", unsupported_warning_wanonymous_1747, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/wd", _SLASH_wd, Joined, cl_compile_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-weak-l", weak_l, Joined, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-weak_framework", weak__framework, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-weak_library", weak__library, Separate, INVALID, INVALID, nullptr, LinkerInput, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-weak_reference_mismatches", weak__reference__mismatches, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wextra", unsupported_warning_wanonymous_1740, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wframe-larger-than=", Wframe_larger_than_EQ, Joined, W_value_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wframe-larger-than", Wframe_larger_than, Flag, INVALID, Wframe_larger_than_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wfrontend-loop-interchange", unsupported_warning_wanonymous_1764, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wfunction-elimination", unsupported_warning_wanonymous_1748, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-whatsloaded", whatsloaded, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-why_load", why_load, Flag, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-whyload", whyload, Flag, INVALID, why_load, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wimplicit-interface", unsupported_warning_wanonymous_1749, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wimplicit-procedure", unsupported_warning_wanonymous_1750, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/winsdkdir", _SLASH_winsdkdir, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Path to the Windows SDK", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_2, "/winsdkversion", _SLASH_winsdkversion, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Full version of the Windows SDK, defaults to newest found", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/winsysroot", _SLASH_winsysroot, JoinedOrSeparate, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Same as \"/diasdkdir <dir>/DIA SDK\" /vctoolsdir <dir>/VC/Tools/MSVC/<vctoolsversion> \"/winsdkdir <dir>/Windows Kits/10\"", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr)
OPTION(prefix_4, "-Wintrinsic-shadow", unsupported_warning_wanonymous_1751, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wintrinsics-std", unsupported_warning_wanonymous_1753, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Winvalid-constexpr", Winvalid_constexpr, Flag, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Enable checking of constexpr function bodies for validity within a constant expression context", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wl,", Wl_COMMA, CommaJoined, Link_Group, INVALID, nullptr, LinkerInput | RenderAsInput, DefaultVis | FlangOption, 0,
       "Pass the comma separated arguments in <arg> to the linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Wlarge-by-value-copy=", Wlarge_by_value_copy_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wlarge-by-value-copy", Wlarge_by_value_copy_def, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis, 0,
       "Warn if a function definition returns or accepts an object larger in bytes than a given value", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wlarger-than-", Wlarger_than_, Joined, INVALID, Wlarger_than_EQ, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wlarger-than=", Wlarger_than_EQ, Joined, clang_ignored_f_Group, INVALID, nullptr, Ignored, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wline-truncation", unsupported_warning_wanonymous_1754, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/WL", _SLASH_WL, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wno-align-commons", unsupported_warning_wanonymous_1755, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wno-deprecated", Wno_deprecated, Flag, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wno-invalid-constexpr", Wno_invalid_constexpr, Flag, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Disable checking of constexpr function bodies for validity within a constant expression context", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wno-nonportable-cfstrings", Wno_nonportable_cfstrings, Joined, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wno-overwrite-recursive", unsupported_warning_wanonymous_1756, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wno-rewrite-macros", Wno_rewrite_macros, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Silence ObjC rewriting warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wno-system-headers", Wno_system_headers, Flag, W_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wno-tabs", unsupported_warning_wanonymous_1757, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wno-write-strings", Wno_write_strings, Flag, W_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wnonportable-cfstrings", Wnonportable_cfstrings, Joined, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-working-directory=", working_directory_EQ, Joined, INVALID, working_directory, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-working-directory", working_directory, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Resolve file paths relative to the specified directory", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wp,", Wp_COMMA, CommaJoined, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass the comma separated arguments in <arg> to the preprocessor", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_2, "/Wp64", _SLASH_Wp64, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wreal-q-constant", unsupported_warning_wanonymous_1758, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wrealloc-lhs-all", unsupported_warning_wanonymous_1763, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wrealloc-lhs", unsupported_warning_wanonymous_1762, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--write-dependencies", _write_dependencies, Flag, INVALID, MD, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_3, "--write-user-dependencies", _write_user_dependencies, Flag, INVALID, MMD, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wsurprising", unsupported_warning_wanonymous_1759, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wsystem-headers-in-module=", Wsystem_headers_in_module_EQ, Joined, INVALID, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0,
       "Enable -Wsystem-headers when building <module>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<module>", nullptr)
OPTION(prefix_1, "-Wsystem-headers", Wsystem_headers, Flag, W_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wtarget-lifetime", unsupported_warning_wanonymous_1765, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wundef-prefix=", Wundef_prefix_EQ, CommaJoined, W_value_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Enable warnings for undefined macros with a prefix in the comma separated list <arg>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_4, "-Wunderflow", unsupported_warning_wanonymous_1760, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wunused-parameter", unsupported_warning_wanonymous_1761, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_4, "-Wuse-without-only", unsupported_warning_wanonymous_1752, Flag, flang_ignored_w_Group, INVALID, nullptr, Ignored, FlangOption | FlangOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Wv", _SLASH_Wv_, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Wwrite-strings", Wwrite_strings, Flag, W_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/WX-", _SLASH_WX_, Flag, cl_Group, W_Joined, "no-error\0", NoXarchOption, CLOption, 0,
       "Do not treat warnings as errors (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/WX", _SLASH_WX, Flag, cl_Group, W_Joined, "error\0", NoXarchOption, CLOption, 0,
       "Treat warnings as errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-W", W_Joined, Joined, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption | FC1Option | FlangOption, 0,
       "Enable the specified warning", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<warning>", nullptr)
OPTION(prefix_1, "-w", w, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Suppress all warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/w", _SLASH_w_flag, Flag, cl_Group, w, nullptr, NoXarchOption, CLOption, 0,
       "Disable all warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/w", _SLASH_w, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xanalyzer", Xanalyzer, Separate, StaticAnalyzer_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to the static analyzer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xarch_device", Xarch_device, Separate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Pass <arg> to the CUDA/HIP device compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xarch_host", Xarch_host, Separate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0,
       "Pass <arg> to the CUDA/HIP host compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xarch_", Xarch__, JoinedAndSeparate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xassembler", Xassembler, Separate, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to the assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xclang=", anonymous_54, Joined, CompileOnly_Group, Xclang, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption, 0,
       "Alias for -Xclang", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xclang", Xclang, Separate, CompileOnly_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption, 0,
       "Pass <arg> to clang -cc1", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xcompiler", anonymous_56, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xcuda-fatbinary", Xcuda_fatbinary, Separate, INVALID, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to fatbinary invocation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xcuda-ptxas", Xcuda_ptxas, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Pass <arg> to the ptxas assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xflang", Xflang, Separate, CompileOnly_Group, INVALID, nullptr, NoXarchOption, FlangOption | CLOption, 0,
       "Pass <arg> to the flang compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xlinker", Xlinker, Separate, Link_Group, INVALID, nullptr, LinkerInput | RenderAsInput, DefaultVis, 0,
       "Pass <arg> to the linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xmicrosoft-visualc-tools-root", anonymous_2170, Separate, INVALID, _SLASH_vctoolsdir, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xmicrosoft-visualc-tools-version", anonymous_2171, Separate, INVALID, _SLASH_vctoolsversion, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xmicrosoft-windows-sdk-root", anonymous_2172, Separate, INVALID, _SLASH_winsdkdir, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xmicrosoft-windows-sdk-version", anonymous_2173, Separate, INVALID, _SLASH_winsdkversion, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xmicrosoft-windows-sys-root", anonymous_2174, Separate, INVALID, _SLASH_winsysroot, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xoffload-linker", Xoffload_linker, JoinedAndSeparate, Link_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to the offload linkers or the ones idenfied by -<triple>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<triple> <arg>", nullptr)
OPTION(prefix_1, "-Xopenmp-target=", Xopenmp_target_EQ, JoinedAndSeparate, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to the target offloading toolchain identified by <triple>.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<triple> <arg>", nullptr)
OPTION(prefix_1, "-Xopenmp-target", Xopenmp_target, Separate, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to the target offloading toolchain.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-Xparser", anonymous_55, Flag, INVALID, INVALID, nullptr, HelpHidden, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Xpreprocessor", Xpreprocessor, Separate, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Pass <arg> to the preprocessor", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_1, "-X", X_Flag, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/X", _SLASH_X, Flag, cl_Group, nostdlibinc, nullptr, NoXarchOption, CLOption, 0,
       "Do not add %INCLUDE% to include search path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-x", x, JoinedOrSeparate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FlangOption | FC1Option | CLOption, 0,
       "Treat subsequent input files as having type <language>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<language>", nullptr)
OPTION(prefix_2, "/Y-", _SLASH_Y_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable precompiled headers, overrides /Yc and /Yu", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Yc", _SLASH_Yc, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Generate a pch file for all code up to and including <filename>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<filename>", nullptr)
OPTION(prefix_2, "/Yd", _SLASH_Yd, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Yl", _SLASH_Yl, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Yu", _SLASH_Yu, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Load a pch file and use it instead of all code up to and including <filename>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<filename>", nullptr)
OPTION(prefix_1, "-y", y, Joined, INVALID, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Z-reserved-lib-cckext", Z_reserved_lib_cckext, Flag, reserved_lib_Group, INVALID, nullptr, LinkerInput | NoArgumentUnused | Unsupported | Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Z-reserved-lib-stdc++", Z_reserved_lib_stdcxx, Flag, reserved_lib_Group, INVALID, nullptr, LinkerInput | NoArgumentUnused | Unsupported | Unsupported, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Z-Xlinker-no-demangle", Z_Xlinker__no_demangle, Flag, INVALID, INVALID, nullptr, Unsupported | NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Z7", _SLASH_Z7, Flag, cl_Group, g_Flag, nullptr, NoXarchOption, CLOption, 0,
       "Enable CodeView debug information in object files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Za", _SLASH_Za, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:__cplusplus", _SLASH_Zc___cplusplus, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:__STDC__", _SLASH_Zc___STDC__, Flag, cl_Group, fms_define_stdc, nullptr, NoXarchOption, CLOption, 0,
       "Define __STDC__", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:alignedNew-", _SLASH_Zc_alignedNew_, Flag, cl_Group, fno_aligned_allocation, nullptr, NoXarchOption, CLOption, 0,
       "Disable C++17 aligned allocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:alignedNew", _SLASH_Zc_alignedNew, Flag, cl_Group, faligned_allocation, nullptr, NoXarchOption, CLOption, 0,
       "Enable C++17 aligned allocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:auto", _SLASH_Zc_auto, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:char8_t-", _SLASH_Zc_char8_t_, Flag, cl_Group, fno_char8__t, nullptr, NoXarchOption, CLOption, 0,
       "Disable char8_t from c++2a", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:char8_t", _SLASH_Zc_char8_t, Flag, cl_Group, fchar8__t, nullptr, NoXarchOption, CLOption, 0,
       "Enable char8_t from C++2a", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:dllexportInlines-", _SLASH_Zc_dllexportInlines_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Do not dllexport/dllimport inline member functions of dllexport/import classes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:dllexportInlines", _SLASH_Zc_dllexportInlines, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "dllexport/dllimport inline member functions of dllexport/import classes (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:forScope", _SLASH_Zc_forScope, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:inline", _SLASH_Zc_inline, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:rvalueCast", _SLASH_Zc_rvalueCast, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:sizedDealloc-", _SLASH_Zc_sizedDealloc_, Flag, cl_Group, fno_sized_deallocation, nullptr, NoXarchOption, CLOption, 0,
       "Disable C++14 sized global deallocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:sizedDealloc", _SLASH_Zc_sizedDealloc, Flag, cl_Group, fsized_deallocation, nullptr, NoXarchOption, CLOption, 0,
       "Enable C++14 sized global deallocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:strictStrings", _SLASH_Zc_strictStrings, Flag, cl_Group, W_Joined, "error=c++11-compat-deprecated-writable-strings\0", NoXarchOption, CLOption, 0,
       "Treat string literals as const", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:ternary", _SLASH_Zc_ternary, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:threadSafeInit-", _SLASH_Zc_threadSafeInit_, Flag, cl_Group, fno_threadsafe_statics, nullptr, NoXarchOption, CLOption, 0,
       "Disable thread-safe initialization of static variables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:threadSafeInit", _SLASH_Zc_threadSafeInit, Flag, cl_Group, fthreadsafe_statics, nullptr, NoXarchOption, CLOption, 0,
       "Enable thread-safe initialization of static variables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:trigraphs-", _SLASH_Zc_trigraphs_off, Flag, cl_Group, fno_trigraphs, nullptr, NoXarchOption, CLOption, 0,
       "Disable trigraphs (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:trigraphs", _SLASH_Zc_trigraphs, Flag, cl_Group, ftrigraphs, nullptr, NoXarchOption, CLOption, 0,
       "Enable trigraphs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:twoPhase-", _SLASH_Zc_twoPhase_, Flag, cl_Group, fdelayed_template_parsing, nullptr, NoXarchOption, CLOption, 0,
       "Disable two-phase name lookup in templates (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:twoPhase", _SLASH_Zc_twoPhase, Flag, cl_Group, fno_delayed_template_parsing, nullptr, NoXarchOption, CLOption, 0,
       "Enable two-phase name lookup in templates", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:wchar_t-", _SLASH_Zc_wchar_t_, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Disable C++ builtin type wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:wchar_t", _SLASH_Zc_wchar_t, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0,
       "Enable C++ builtin type wchar_t (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zc:", _SLASH_Zc, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Ze", _SLASH_Ze, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zg", _SLASH_Zg, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/ZH:MD5", _SLASH_ZH_MD5, Flag, cl_Group, gsrc_hash_EQ, "md5\0", NoXarchOption, CLOption, 0,
       "Use MD5 for file checksums in debug info (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/ZH:SHA1", _SLASH_ZH_SHA1, Flag, cl_Group, gsrc_hash_EQ, "sha1\0", NoXarchOption, CLOption, 0,
       "Use SHA1 for file checksums in debug info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/ZH:SHA_256", _SLASH_ZH_SHA_256, Flag, cl_Group, gsrc_hash_EQ, "sha256\0", NoXarchOption, CLOption, 0,
       "Use SHA256 for file checksums in debug info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/ZI", _SLASH_ZI, Flag, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zi", _SLASH_Zi, Flag, cl_Group, g_Flag, nullptr, NoXarchOption, CLOption | DXCOption, 0,
       "Like /Z7", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Zlinker-input", Zlinker_input, Separate, INVALID, INVALID, nullptr, Unsupported | NoArgumentUnused, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zl", _SLASH_Zl, Flag, cl_Group, fms_omit_default_lib, nullptr, NoXarchOption, CLOption, 0,
       "Do not let object file auto-link default libraries", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zm", _SLASH_Zm, Joined, cl_ignored_Group, INVALID, nullptr, NoXarchOption | HelpHidden, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zo-", _SLASH_Zo_, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zo", _SLASH_Zo, Flag, cl_ignored_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zp", _SLASH_Zp_flag, Flag, cl_Group, fpack_struct_EQ, "1\0", NoXarchOption, CLOption, 0,
       "Set default maximum struct packing alignment to 1", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zp", _SLASH_Zp, Joined, cl_Group, fpack_struct_EQ, nullptr, NoXarchOption, CLOption, 0,
       "Set default maximum struct packing alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/Zs", _SLASH_Zs, Flag, cl_Group, fsyntax_only, nullptr, NoXarchOption, CLOption, 0,
       "Run the preprocessor, parser and semantic analysis stages", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_2, "/ZW", _SLASH_ZW, Joined, cl_Group, INVALID, nullptr, NoXarchOption, CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-Z", Z_Flag, Flag, Link_Group, INVALID, nullptr, 0, DefaultVis, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
OPTION(prefix_1, "-z", z, Separate, Link_Group, INVALID, nullptr, LinkerInput, DefaultVis, 0,
       "Pass -z <arg> to the linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr)
OPTION(prefix_3, "--", _DASH_DASH, RemainingArgs, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | DXCOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr)
#endif // OPTION
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-arcmt-migrate-report-output", arcmt_migrate_report_output, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Output path for the plist report", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ARCMTMigrateReportOut, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-arcmt-migrate-emit-errors", arcmt_migrate_emit_arc_errors, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit ARC errors even if the migrator can fix them", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ARCMTMigrateEmitARCErrors, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-literals", objcmt_migrate_literals, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_Literals), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_Literals), FrontendOptions::ObjCMT_Literals>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-subscripting", objcmt_migrate_subscripting, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC subscripting", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_Subscripting), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_Subscripting), FrontendOptions::ObjCMT_Subscripting>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-property", objcmt_migrate_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC property", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_Property), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_Property), FrontendOptions::ObjCMT_Property>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-all", objcmt_migrate_all, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_MigrateDecls), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_MigrateDecls), FrontendOptions::ObjCMT_MigrateDecls>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-readonly-property", objcmt_migrate_readonly_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC readonly property", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_ReadonlyProperty), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_ReadonlyProperty), FrontendOptions::ObjCMT_ReadonlyProperty>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-readwrite-property", objcmt_migrate_readwrite_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to modern ObjC readwrite property", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_ReadwriteProperty), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_ReadwriteProperty), FrontendOptions::ObjCMT_ReadwriteProperty>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-property-dot-syntax", objcmt_migrate_property_dot_syntax, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration of setter/getter messages to property-dot syntax", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_PropertyDotSyntax), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_PropertyDotSyntax), FrontendOptions::ObjCMT_PropertyDotSyntax>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-annotation", objcmt_migrate_annotation, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to property and method annotations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_Annotation), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_Annotation), FrontendOptions::ObjCMT_Annotation>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-instancetype", objcmt_migrate_instancetype, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to infer instancetype for method result type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_Instancetype), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_Instancetype), FrontendOptions::ObjCMT_Instancetype>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-ns-macros", objcmt_migrate_nsmacros, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to NS_ENUM/NS_OPTIONS macros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_NsMacros), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_NsMacros), FrontendOptions::ObjCMT_NsMacros>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-protocol-conformance", objcmt_migrate_protocol_conformance, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to add protocol conformance on classes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_ProtocolConformance), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_ProtocolConformance), FrontendOptions::ObjCMT_ProtocolConformance>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-atomic-property", objcmt_atomic_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Make migration to 'atomic' properties", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_AtomicProperty), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_AtomicProperty), FrontendOptions::ObjCMT_AtomicProperty>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-returns-innerpointer-property", objcmt_returns_innerpointer_property, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to annotate property with NS_RETURNS_INNER_POINTER", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_ReturnsInnerPointerProperty), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_ReturnsInnerPointerProperty), FrontendOptions::ObjCMT_ReturnsInnerPointerProperty>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-ns-nonatomic-iosonly", objcmt_ns_nonatomic_iosonly, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty), FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-migrate-designated-init", objcmt_migrate_designated_init, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAction, 0u, false, 0u, makeFlagToValueNormalizer(FrontendOptions::ObjCMT_DesignatedInitializer), denormalizeSimpleFlag, mergeMaskValue, (extractMaskValue<unsigned, decltype(FrontendOptions::ObjCMT_DesignatedInitializer), FrontendOptions::ObjCMT_DesignatedInitializer>), -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-objcmt-allowlist-dir-path=", objcmt_allowlist_dir_path, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Only modify files with a filename contained in the provided directory path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ObjCMTAllowListPath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-CC", CC, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include comments from within macros in preprocessed output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.ShowMacroComments, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-C", C, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include comments in preprocessed output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.ShowComments, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-H", H, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Show header includes and nesting depth", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.ShowHeaderIncludes, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fshow-skipped-includes", fshow_skipped_includes, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Show skipped includes in -H output.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.ShowSkippedHeaderIncludes, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-MG", MG, Flag, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Add missing headers to depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.AddMissingHeaderDeps, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-MP", MP, Flag, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Create phony target for each dependency (other than main file)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.UsePhonyTargets, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-MT", MT, JoinedOrSeparate, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify name of main file output in depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.Targets, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-MV", MV, Flag, M_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use NMake/Jom format for the depfile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.OutputFormat, DependencyOutputFormat::Make, false, DependencyOutputFormat::Make, makeFlagToValueNormalizer(DependencyOutputFormat::NMake), denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-P", P, Flag, Preprocessor_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Disable linemarker output in -E mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.ShowLineMarkers, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-Wsystem-headers-in-module=", Wsystem_headers_in_module_EQ, Joined, INVALID, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option, 0,
       "Enable -Wsystem-headers when building <module>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<module>", nullptr, true, 0, DiagnosticOpts->SystemHeaderWarningsModules, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-Wno-invalid-constexpr", Wno_invalid_constexpr, Flag, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Disable checking of constexpr function bodies for validity within a constant expression context", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CheckConstexprFunctionBodies, !LangOpts->CPlusPlus23, false, true, makeBooleanOptionNormalizer(false, true, OPT_Winvalid_constexpr), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-Winvalid-constexpr", Winvalid_constexpr, Flag, W_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Enable checking of constexpr function bodies for validity within a constant expression context", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CheckConstexprFunctionBodies, !LangOpts->CPlusPlus23, false, true, makeBooleanOptionNormalizer(true, false, OPT_Wno_invalid_constexpr), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-Wundef-prefix=", Wundef_prefix_EQ, CommaJoined, W_value_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Enable warnings for undefined macros with a prefix in the comma separated list <arg>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr, true, 0, DiagnosticOpts->UndefPrefixes, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-foffload-uniform-block", foffload_uniform_block, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Assume that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OffloadUniformBlock, LangOpts->CUDA, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_offload_uniform_block), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-offload-uniform-block", fno_offload_uniform_block, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't assume that kernels are launched with uniform block sizes (default true for CUDA/HIP and false otherwise)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OffloadUniformBlock, LangOpts->CUDA, false, false, makeBooleanOptionNormalizer(false, true, OPT_foffload_uniform_block), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-complex-range=", complex_range_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "full,improved,promoted,basic", true, 0, LangOpts->ComplexRange, LangOptions::CX_Full, false, LangOptions::CX_Full, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 0)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-cl-single-precision-constant", cl_single_precision_constant, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Treat double precision floating-point constant as single precision constant.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SinglePrecisionConstants, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-cl-finite-math-only", cl_finite_math_only, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CLFiniteMathOnly, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-cl-kernel-arg-info", cl_kernel_arg_info, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Generate kernel argument metadata.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitOpenCLArgMetadata, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-cl-unsafe-math-optimizations", cl_unsafe_math_optimizations, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow unsafe floating-point optimizations.  Also implies -cl-no-signed-zeros and -cl-mad-enable.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CLUnsafeMath, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-cl-fast-relaxed-math", cl_fast_relaxed_math, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FastRelaxedMath, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-cl-mad-enable", cl_mad_enable, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow use of less precise MAD computations in the generated binary.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LessPreciseFPMAD, false, false || LangOpts->CLUnsafeMath || LangOpts->FastRelaxedMath, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-cl-no-signed-zeros", cl_no_signed_zeros, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CLNoSignedZero, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-cl-fp32-correctly-rounded-divide-sqrt", cl_fp32_correctly_rounded_divide_sqrt, Flag, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.OpenCLCorrectlyRoundedDivSqrt, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-cl-ext=", cl_ext_EQ, CommaJoined, opencl_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "OpenCL only. Enable or disable OpenCL extensions/optional features. The argument is a comma-separated sequence of one or more extension names, each prefixed by '+' or '-'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->OpenCLExtensionsAsWritten, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-convergent-functions", fno_convergent_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Assume all functions may be convergent.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ConvergentFunctions, false, false, true, makeBooleanOptionNormalizer(false, true, OPT_fconvergent_functions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fconvergent-functions", fconvergent_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ConvergentFunctions, false, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_convergent_functions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_3, "--offload-new-driver", offload_new_driver, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the new driver for offloading compilation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OffloadingNewDriver, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgpu-rdc", fgpu_rdc, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Generate relocatable device code, also known as separate compilation mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPURelocatableDeviceCode, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gpu_rdc), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gpu-rdc", fno_gpu_rdc, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPURelocatableDeviceCode, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgpu_rdc), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-foffload-implicit-host-device-templates", foffload_implicit_host_device_templates, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Template functions or specializations without host, device and global attributes have implicit host device attributes (CUDA/HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OffloadImplicitHostDeviceTemplates, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_offload_implicit_host_device_templates), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-offload-implicit-host-device-templates", fno_offload_implicit_host_device_templates, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OffloadImplicitHostDeviceTemplates, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_foffload_implicit_host_device_templates), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgpu-default-stream=", fgpu_default_stream_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specify default stream. The default value is 'legacy'. (CUDA/HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "legacy,per-thread", true, 0, LangOpts->GPUDefaultStream, LangOptions::GPUDefaultStreamKind::Legacy, false, LangOptions::GPUDefaultStreamKind::Legacy, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgpu-defer-diag", fgpu_defer_diag, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Defer host/device related diagnostic messages for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPUDeferDiag, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gpu_defer_diag), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gpu-defer-diag", fno_gpu_defer_diag, Flag, offload_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't defer host/device related diagnostic messages for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPUDeferDiag, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgpu_defer_diag), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgpu-exclude-wrong-side-overloads", fgpu_exclude_wrong_side_overloads, Flag, offload_Group, INVALID, nullptr, HelpHidden, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Always exclude wrong side overloads in overloading resolution for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPUExcludeWrongSideOverloads, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gpu_exclude_wrong_side_overloads), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gpu-exclude-wrong-side-overloads", fno_gpu_exclude_wrong_side_overloads, Flag, offload_Group, INVALID, nullptr, HelpHidden, DefaultVis | DefaultVis | CLOption, 0,
       "Exclude wrong side overloads only if there are same side overloads in overloading resolution for CUDA/HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPUExcludeWrongSideOverloads, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgpu_exclude_wrong_side_overloads), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-cuid=", cuid_EQ, Joined, offload_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "An ID for compilation unit, which should be the same for the same compilation unit but different for different compilation units. It is used to externalize device-side static variables for single source offloading languages CUDA and HIP so that they can be accessed by the host code of the same compilation unit.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CUID, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-fcuda-short-ptr", fcuda_short_ptr, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Use 32-bit pointers for accessing const/local/shared address spaces", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->NVPTXUseShortPointers, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_cuda_short_ptr), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-fno-cuda-short-ptr", fno_cuda_short_ptr, Flag, cuda_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->NVPTXUseShortPointers, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcuda_short_ptr), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-mprintf-kind=", mprintf_kind_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specify the printf lowering scheme (AMDGPU only), allowed values are \"hostcall\"(printing happens during kernel execution, this scheme relies on hostcalls which require system to support pcie atomics) and \"buffered\"(printing happens after all kernel threads exit, this uses a printf buffer and does not rely on pcie atomic support)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "hostcall,buffered", true, 0, TargetOpts->AMDGPUPrintfKindVal, TargetOptions::AMDGPUPrintfKind::Hostcall, false, TargetOptions::AMDGPUPrintfKind::Hostcall, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 2)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_3, "--hipstdpar", hipstdpar, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable HIP acceleration for standard parallel algorithms", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HIPStdPar, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_3, "--hipstdpar-interpose-alloc", hipstdpar_interpose_alloc, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Replace all memory allocation / deallocation calls with hipManagedMalloc / hipFree equivalents", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HIPStdParInterposeAlloc, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fhip-new-launch-api", fhip_new_launch_api, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Use new kernel launching API for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HIPUseNewLaunchAPI, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_hip_new_launch_api), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-hip-new-launch-api", fno_hip_new_launch_api, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't use new kernel launching API for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HIPUseNewLaunchAPI, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fhip_new_launch_api), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fhip-fp32-correctly-rounded-divide-sqrt", fhip_fp32_correctly_rounded_divide_sqrt, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, CodeGenOpts.HIPCorrectlyRoundedDivSqrt, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_hip_fp32_correctly_rounded_divide_sqrt), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-hip-fp32-correctly-rounded-divide-sqrt", fno_hip_fp32_correctly_rounded_divide_sqrt, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Don't specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, CodeGenOpts.HIPCorrectlyRoundedDivSqrt, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fhip_fp32_correctly_rounded_divide_sqrt), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fhip-kernel-arg-name", fhip_kernel_arg_name, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Specify that kernel argument names are preserved (HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, CodeGenOpts.HIPSaveKernelArgName, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_hip_kernel_arg_name), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-hip-kernel-arg-name", fno_hip_kernel_arg_name, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't specify that kernel argument names are preserved (HIP only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, CodeGenOpts.HIPSaveKernelArgName, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fhip_kernel_arg_name), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgpu-allow-device-init", fgpu_allow_device_init, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Allow device side init function in HIP (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, LangOpts->GPUAllowDeviceInit, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gpu_allow_device_init), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gpu-allow-device-init", fno_gpu_allow_device_init, Flag, hip_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Don't allow device side init function in HIP (experimental)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, LangOpts->GPUAllowDeviceInit, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgpu_allow_device_init), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_3, "--gpu-max-threads-per-block=", gpu_max_threads_per_block_EQ, Joined, hip_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Default max threads per block for kernel launch bounds for HIP", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->HIP, 0, LangOpts->GPUMaxThreadsPerBlock, 1024, false, 1024, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-dI", dI, Flag, d_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print include directives in -E mode in addition to normal output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.ShowIncludeDirectives, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-dE", dE, Flag, d_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Print embed directives in -E mode in addition to normal output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.ShowEmbedDirectives, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-dependency-file", dependency_file, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Filename (or -) to write dependency output to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.OutputFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-dependency-dot", dependency_dot, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Filename to write DOT-formatted header dependencies to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.DOTOutputFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-module-dependency-dir", module_dependency_dir, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Directory to dump module dependencies to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.ModuleDependencyOutputDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_3, "--product-name=", product_name_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ProductName, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-emit-symbol-graph", emit_symbol_graph, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate Extract API information as a side effect of compilation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.EmitSymbolGraph, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_3, "--emit-extension-symbol-graphs", emit_extension_symbol_graphs, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate additional symbol graphs for extended modules.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.EmitExtensionSymbolGraphs, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_3, "--extract-api-ignores=", extract_api_ignores_EQ, CommaJoined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Comma separated list of files containing a new line separated list of API symbols to ignore when extracting API information.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ExtractAPIIgnoresFileList, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_3, "--symbol-graph-dir=", symbol_graph_dir_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Directory in which to emit symbol graphs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.SymbolGraphOutputDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_3, "--pretty-sgf", emit_pretty_sgf, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit pretty printed symbol graphs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.EmitPrettySymbolGraphs, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_3, "--emit-sgf-symbol-labels-for-testing", emit_sgf_symbol_labels_for_testing, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.EmitSymbolGraphSymbolLabelsForTesting, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmax-tokens=", fmax_tokens_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Max total number of preprocessed tokens for -Wmax-tokens.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MaxTokens, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-access-control", fno_access_control, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable C++ access control", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AccessControl, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_faccess_control), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-faccess-control", faccess_control, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AccessControl, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_access_control), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-falign-loops=", falign_loops_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "N must be a power of two. Align loops to the boundary", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr, true, 0, CodeGenOpts.LoopAlignment, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fallow-editor-placeholders", fallow_editor_placeholders, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Treat editor placeholders as valid source code", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AllowEditorPlaceholders, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_allow_editor_placeholders), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-allow-editor-placeholders", fno_allow_editor_placeholders, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AllowEditorPlaceholders, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fallow_editor_placeholders), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapple-kext", fapple_kext, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Use Apple's kernel extensions ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AppleKext, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fstrict-flex-arrays=", fstrict_flex_arrays_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable optimizations based on the strict definition of flexible arrays", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<n>", "0,1,2,3", true, 0, LangOpts->StrictFlexArraysLevel, LangOptions::StrictFlexArraysLevelKind::Default, false, LangOptions::StrictFlexArraysLevelKind::Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 3)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapple-pragma-pack", fapple_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable Apple gcc-compatible #pragma pack handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ApplePragmaPack, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_apple_pragma_pack), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-apple-pragma-pack", fno_apple_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ApplePragmaPack, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fapple_pragma_pack), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxl-pragma-pack", fxl_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable IBM XL #pragma pack handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XLPragmaPack, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_xl_pragma_pack), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-xl-pragma-pack", fno_xl_pragma_pack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XLPragmaPack, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fxl_pragma_pack), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fassume-unique-vtables", fassume_unique_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AssumeUniqueVTables, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_assume_unique_vtables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-assume-unique-vtables", fno_assume_unique_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable optimizations based on vtable pointer identity", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AssumeUniqueVTables, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fassume_unique_vtables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdouble-square-bracket-attributes", fdouble_square_bracket_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DoubleSquareBracketAttributes, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_double_square_bracket_attributes), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-double-square-bracket-attributes", fno_double_square_bracket_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DoubleSquareBracketAttributes, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdouble_square_bracket_attributes), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-late-parse-attributes", fexperimental_late_parse_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable experimental late parsing of attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ExperimentalLateParseAttributes, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_experimental_late_parse_attributes), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-experimental-late-parse-attributes", fno_experimental_late_parse_attributes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable experimental late parsing of attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ExperimentalLateParseAttributes, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fexperimental_late_parse_attributes), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-autolink", fno_autolink, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable generation of linker directives for automatic library linking", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Autolink, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fautolink), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fautolink", fautolink, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Autolink, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_autolink), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-auto-import", fno_auto_import, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis, 0,
       "MinGW specific. Disable support for automatic dllimport in code generation and linking", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AutoImport, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fauto_import), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fauto-import", fauto_import, Flag, f_Group, INVALID, nullptr, TargetSpecific, DefaultVis, 0,
       "MinGW specific. Enable code generation support for automatic dllimport, and enable support for it in the linker. Enabled by default.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AutoImport, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_auto_import), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcoroutines", fcoroutines, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable support for the C++ Coroutines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Coroutines, LangOpts->CPlusPlus20, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_coroutines), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-coroutines", fno_coroutines, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Coroutines, LangOpts->CPlusPlus20, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcoroutines), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcoro-aligned-allocation", fcoro_aligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Prefer aligned allocation for C++ Coroutines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CoroAlignedAllocation, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_coro_aligned_allocation), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-coro-aligned-allocation", fno_coro_aligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CoroAlignedAllocation, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcoro_aligned_allocation), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-library", fexperimental_library, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DefaultVis, 0,
       "Control whether unstable and experimental library features are enabled. This option enables various library features that are either experimental (also known as TSes), or have been but are not stable yet in the selected Standard Library implementation. It is not recommended to use this option in production code, since neither ABI nor API stability are guaranteed. This is intended to provide a preview of features that will ship in the future for experimentation purposes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ExperimentalLibrary, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_experimental_library), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-experimental-library", fno_experimental_library, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ExperimentalLibrary, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fexperimental_library), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fembed-offload-object=", fembed_offload_object_EQ, Joined, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | FC1Option, 0,
       "Embed Offloading device-side binary into host object file as a section.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.OffloadObjects, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fembed-bitcode=", fembed_bitcode_EQ, Joined, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | CC1AsOption, 0,
       "Embed LLVM bitcode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<option>", "off,all,bitcode,marker", true, 0, CodeGenOpts.EmbedBitcode, CodeGenOptions::Embed_Off, false, CodeGenOptions::Embed_Off, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 4)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gnu-inline-asm", fno_gnu_inline_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable GNU style inline asm", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GNUAsm, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fgnu_inline_asm), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgnu-inline-asm", fgnu_inline_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GNUAsm, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_gnu_inline_asm), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-sample-use=", fprofile_sample_use_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable sample-based profile guided optimizations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SampleProfileFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-sample-accurate", fprofile_sample_accurate, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies that the sample profile is accurate", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ProfileSampleAccurate, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdebug-compilation-dir=", fdebug_compilation_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0,
       "The compilation directory to embed in the debug info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugCompilationDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fcoverage-compilation-dir=", fcoverage_compilation_dir_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption, 0,
       "The compilation directory to embed in the coverage mapping.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CoverageCompilationDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdebug-info-for-profiling", fdebug_info_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Emit extra debug info to make sample profile more accurate", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugInfoForProfiling, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_debug_info_for_profiling), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-debug-info-for-profiling", fno_debug_info_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugInfoForProfiling, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdebug_info_for_profiling), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-remapping-file=", fprofile_remapping_file_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Use the remappings described in <file> to match the profile data against names in the program", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, CodeGenOpts.ProfileRemappingFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fcoverage-mapping", fcoverage_mapping, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Generate coverage mapping to enable code coverage analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CoverageMapping, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_coverage_mapping), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-coverage-mapping", fno_coverage_mapping, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable code coverage analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CoverageMapping, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcoverage_mapping), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fcoverage-mcdc", fmcdc_coverage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable MC/DC criteria when generating code coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MCDCCoverage, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_mcdc_coverage), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-coverage-mcdc", fno_mcdc_coverage, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable MC/DC coverage criteria", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MCDCCoverage, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmcdc_coverage), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fmcdc-max-conditions=", fmcdc_max_conditions_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Maximum number of conditions in MC/DC coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MCDCMaxConds, 32767, false, 32767, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fmcdc-max-test-vectors=", fmcdc_max_test_vectors_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Maximum number of test vectors in MC/DC coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MCDCMaxTVs, 0x7FFFFFFE, false, 0x7FFFFFFE, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-filter-files=", fprofile_filter_files_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Instrument only functions from files where names match any regex separated by a semi-colon", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ProfileFilterFiles, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-exclude-files=", fprofile_exclude_files_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Instrument only functions from files where names don't match all the regexes separated by a semi-colon", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ProfileExcludeFiles, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-update=", fprofile_update_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set update method of profile counters", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<method>", "atomic,prefer-atomic,single", true, 0, CodeGenOpts.AtomicProfileUpdate, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpseudo-probe-for-profiling", fpseudo_probe_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Emit pseudo probes for sample profiling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PseudoProbeForProfiling, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_pseudo_probe_for_profiling), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-pseudo-probe-for-profiling", fno_pseudo_probe_for_profiling, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Do not emit pseudo probes for sample profiling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PseudoProbeForProfiling, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fpseudo_probe_for_profiling), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-list=", fprofile_list_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Filename defining the list of functions/files to instrument. The file uses the sanitizer special case list format.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ProfileListFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-function-groups=", fprofile_function_groups, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Partition functions into N groups and select only functions in group i to be instrumented using -fprofile-selected-function-group", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr, true, 0, CodeGenOpts.ProfileTotalFunctionGroups, 1, false, 1, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-selected-function-group=", fprofile_selected_function_group, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Partition functions into N groups using -fprofile-function-groups and select only functions in group i to be instrumented. The valid range is 0 to N-1 inclusive", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<i>", nullptr, true, 0, CodeGenOpts.ProfileSelectedFunctionGroup, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fswift-async-fp=", fswift_async_fp_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption, 0,
       "Control emission of Swift async extended frame info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<option>", "auto,always,never", true, 0, CodeGenOpts.SwiftAsyncFramePointer, CodeGenOptions::SwiftAsyncFramePointerKind::Always, false, CodeGenOptions::SwiftAsyncFramePointerKind::Always, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 5)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapinotes", fapinotes, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->APINotes, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_apinotes), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-apinotes", fno_apinotes, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->APINotes, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fapinotes), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapinotes-modules", fapinotes_modules, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable module-based external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->APINotesModules, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_apinotes_modules), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-apinotes-modules", fno_apinotes_modules, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable module-based external API notes support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->APINotesModules, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fapinotes_modules), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-bounds-safety", fbounds_safety, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Enable experimental bounds safety extension for C", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BoundsSafety, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_bounds_safety), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-experimental-bounds-safety", fno_bounds_safety, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Disable experimental bounds safety extension for C", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BoundsSafety, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fbounds_safety), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-faddrsig", faddrsig, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Emit an address-significance table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Addrsig, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_addrsig), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-addrsig", fno_addrsig, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Don't emit an address-significance table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Addrsig, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_faddrsig), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fborland-extensions", fborland_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Accept non-standard constructs supported by the Borland compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Borland, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_borland_extensions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-borland-extensions", fno_borland_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Borland, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fborland_extensions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-caret-diagnostics", fno_caret_diagnostics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowCarets, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fcaret_diagnostics), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fcaret-diagnostics", fcaret_diagnostics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowCarets, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_caret_diagnostics), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fansi-escape-codes", fansi_escape_codes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Use ANSI escape codes for diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->UseANSIEscapeCodes, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcomment-block-commands=", fcomment_block_commands, CommaJoined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Treat each comma separated argument in <arg> as a documentation comment block command", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<arg>", nullptr, true, 0, LangOpts->CommentOpts.BlockCommandNames, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fparse-all-comments", fparse_all_comments, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CommentOpts.ParseAllComments, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fcommon", fcommon, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Place uninitialized global variables in a common block", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoCommon, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcomplete-member-pointers", fcomplete_member_pointers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Require member pointer base types to be complete if they would be significant under the Microsoft ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CompleteMemberPointers, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_complete_member_pointers), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-complete-member-pointers", fno_complete_member_pointers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CompleteMemberPointers, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcomplete_member_pointers), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcf-runtime-abi=", fcf_runtime_abi_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "unspecified,standalone,objc,swift,swift-5.0,swift-4.2,swift-4.1", true, 0, LangOpts->CFRuntime, LangOptions::CoreFoundationABI::ObjectiveC, false, LangOptions::CoreFoundationABI::ObjectiveC, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 6)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-constant-cfstrings", fno_constant_cfstrings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable creation of CodeFoundation-type constant strings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoConstantCFStrings, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fconstant_cfstrings), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fconstant-cfstrings", fconstant_cfstrings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoConstantCFStrings, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_constant_cfstrings), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fconstexpr-depth=", fconstexpr_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum depth of recursive constexpr function calls", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ConstexprCallDepth, 512, false, 512, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fconstexpr-steps=", fconstexpr_steps_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of steps in constexpr function evaluation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ConstexprStepLimit, 1048576, false, 1048576, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-new-constant-interpreter", fexperimental_new_constant_interpreter, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable the experimental new constant interpreter", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EnableNewConstInterp, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fconstexpr-backtrace-limit=", fconstexpr_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of entries to print in a constexpr evaluation backtrace (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ConstexprBacktraceLimit, DiagnosticOptions::DefaultConstexprBacktraceLimit, false, DiagnosticOptions::DefaultConstexprBacktraceLimit, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcxx-exceptions", fcxx_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable C++ exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CXXExceptions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_cxx_exceptions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-cxx-exceptions", fno_cxx_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CXXExceptions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcxx_exceptions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fasync-exceptions", fasync_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable EH Asynchronous exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EHAsynch, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_async_exceptions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-async-exceptions", fno_async_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EHAsynch, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fasync_exceptions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-cxx-modules", fno_cxx_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable modules for C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->CPlusPlus, 0, LangOpts->CPlusPlusModules, LangOpts->CPlusPlus20, false, true, makeBooleanOptionNormalizer(false, true, OPT_fcxx_modules), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcxx-modules", fcxx_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable modules for C++", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->CPlusPlus, 0, LangOpts->CPlusPlusModules, LangOpts->CPlusPlus20, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_cxx_modules), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-diagnostics-fixit-info", fno_diagnostics_fixit_info, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not include fixit information in diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowFixits, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-parseable-fixits", fdiagnostics_parseable_fixits, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Print fix-its in machine parseable form", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowParseableFixits, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-print-source-range-info", fdiagnostics_print_source_range_info, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print source range spans in numeric form", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowSourceRanges, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-show-hotness", fdiagnostics_show_hotness, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable profile hotness information in diagnostic line", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DiagnosticsWithHotness, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_diagnostics_show_hotness), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-diagnostics-show-hotness", fno_diagnostics_show_hotness, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DiagnosticsWithHotness, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdiagnostics_show_hotness), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-diagnostics-show-option", fno_diagnostics_show_option, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowOptionNames, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fdiagnostics_show_option), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-show-option", fdiagnostics_show_option, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Print option name with mappable diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowOptionNames, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_diagnostics_show_option), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-show-note-include-stack", fdiagnostics_show_note_include_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Display include stacks for diagnostic notes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowNoteIncludeStack, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_diagnostics_show_note_include_stack), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-diagnostics-show-note-include-stack", fno_diagnostics_show_note_include_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowNoteIncludeStack, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdiagnostics_show_note_include_stack), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-show-template-tree", fdiagnostics_show_template_tree, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Print a template comparison tree for differing templates", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowTemplateTree, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fsafe-buffer-usage-suggestions", fsafe_buffer_usage_suggestions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Display suggestions to update code associated with -Wunsafe-buffer-usage warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowSafeBufferUsageSuggestions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_safe_buffer_usage_suggestions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-safe-buffer-usage-suggestions", fno_safe_buffer_usage_suggestions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowSafeBufferUsageSuggestions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsafe_buffer_usage_suggestions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdollars-in-identifiers", fdollars_in_identifiers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Allow '$' in identifiers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DollarIdents, !LangOpts->AsmPreprocessor, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_dollars_in_identifiers), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-dollars-in-identifiers", fno_dollars_in_identifiers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disallow '$' in identifiers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DollarIdents, !LangOpts->AsmPreprocessor, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdollars_in_identifiers), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-dwarf-directory-asm", fno_dwarf_directory_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoDwarfDirectoryAsm, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fdwarf_directory_asm), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdwarf-directory-asm", fdwarf_directory_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoDwarfDirectoryAsm, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_dwarf_directory_asm), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-elide-constructors", fno_elide_constructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable C++ copy constructor elision", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ElideConstructors, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_felide_constructors), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-felide-constructors", felide_constructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ElideConstructors, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_elide_constructors), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-elide-type", fno_elide_type, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not elide types when printing diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ElideType, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-femit-all-decls", femit_all_decls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Emit all declarations, even if unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EmitAllDecls, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-femulated-tls", femulated_tls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use emutls functions to access thread_local variables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmulatedTLS, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_emulated_tls), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-emulated-tls", fno_emulated_tls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmulatedTLS, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_femulated_tls), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexceptions", fexceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable support for exception handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Exceptions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_exceptions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-exceptions", fno_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable support for exception handling", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Exceptions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fexceptions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-exception-model", exception_model, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The exception model", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "dwarf,sjlj,seh,wasm", true, 0, LangOpts->ExceptionHandling, LangOptions::ExceptionHandlingKind::None, false, LangOptions::ExceptionHandlingKind::None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 7)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fignore-exceptions", fignore_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable support for ignoring exception handling constructs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->IgnoreExceptions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fassume-nothrow-exception-dtor", fassume_nothrow_exception_dtor, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Assume that exception objects' destructors are non-throwing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AssumeNothrowExceptionDtor, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_assume_nothrow_exception_dtor), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-assume-nothrow-exception-dtor", fno_assume_nothrow_exception_dtor, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AssumeNothrowExceptionDtor, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fassume_nothrow_exception_dtor), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffloat16-excess-precision=", ffloat16_excess_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Allows control over excess precision on targets where native support for Float16 precision types is not available. By default, excess precision is used to calculate intermediate results following the rules specified in ISO C99.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "standard,fast,none", true, 0, LangOpts->Float16ExcessPrecision, LangOptions::FPP_Standard, false, LangOptions::FPP_Standard, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 8)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fbfloat16-excess-precision=", fbfloat16_excess_precision_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Allows control over excess precision on targets where native support for BFloat16 precision types is not available. By default, excess precision is used to calculate intermediate results following the rules specified in ISO C99.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "standard,fast,none", true, 0, LangOpts->BFloat16ExcessPrecision, LangOptions::FPP_Standard, false, LangOptions::FPP_Standard, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 9)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffp-eval-method=", ffp_eval_method_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies the evaluation method to use for floating-point arithmetic.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "source,double,extended", true, 0, LangOpts->FPEvalMethod, LangOptions::FEM_UnsetOnCommandLine, false, LangOptions::FEM_UnsetOnCommandLine, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 10)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffp-exception-behavior=", ffp_exception_behavior_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies the exception behavior of floating-point operations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "ignore,maytrap,strict", true, 0, LangOpts->FPExceptionMode, LangOptions::FPE_Default, false, LangOptions::FPE_Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 11)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffast-math", ffast_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow aggressive, lossy floating-point optimizations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FastMath, false, false || LangOpts->FastRelaxedMath, true, makeBooleanOptionNormalizer(true, false, OPT_fno_fast_math), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-fast-math", fno_fast_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FastMath, false, false || LangOpts->FastRelaxedMath, true, makeBooleanOptionNormalizer(false, true, OPT_ffast_math), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmath-errno", fmath_errno, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Require math functions to indicate errors by setting errno", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, !LangOpts->OpenCL, 0, LangOpts->MathErrno, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_math_errno), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-math-errno", fno_math_errno, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, !LangOpts->OpenCL, 0, LangOpts->MathErrno, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmath_errno), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fextend-arguments=", fextend_args_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option, 0,
       "Controls how scalar integer arguments are extended in calls to unprototyped and varargs functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "32,64", true, 0, LangOpts->ExtendIntArgs, LangOptions::ExtendArgsKind::ExtendTo32, false, LangOptions::ExtendArgsKind::ExtendTo32, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 12)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-jump-tables", fno_jump_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not use jump tables for lowering switches", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoUseJumpTables, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fjump_tables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fjump-tables", fjump_tables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Use jump tables for lowering switches", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoUseJumpTables, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_jump_tables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-fforce-enable-int128", fforce_enable_int128, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable support for int128_t type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->ForceEnableInt128, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_force_enable_int128), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-fno-force-enable-int128", fno_force_enable_int128, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable support for int128_t type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->ForceEnableInt128, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fforce_enable_int128), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fkeep-static-consts", fkeep_static_consts, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Keep static const variables even if unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.KeepStaticConsts, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_keep_static_consts), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-keep-static-consts", fno_keep_static_consts, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Don't keep static const variables even if unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.KeepStaticConsts, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fkeep_static_consts), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fkeep-persistent-storage-variables", fkeep_persistent_storage_variables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable keeping all variables that have a persistent storage duration, including global, static and thread-local variables, to guarantee that they can be directly addressed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.KeepPersistentStorageVariables, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_keep_persistent_storage_variables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-keep-persistent-storage-variables", fno_keep_persistent_storage_variables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Disable keeping all variables that have a persistent storage duration, including global, static and thread-local variables, to guarantee that they can be directly addressed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.KeepPersistentStorageVariables, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fkeep_persistent_storage_variables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffixed-point", ffixed_point, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable fixed point types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FixedPoint, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_fixed_point), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-fixed-point", fno_fixed_point, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable fixed point types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FixedPoint, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_ffixed_point), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-c++-static-destructors", fno_cxx_static_destructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable C++ static destructor registration", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RegisterStaticDestructors, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fcxx_static_destructors), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fc++-static-destructors", fcxx_static_destructors, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RegisterStaticDestructors, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_cxx_static_destructors), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsymbol-partition=", fsymbol_partition_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SymbolPartition, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fmemory-profile-use=", fmemory_profile_use_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Use memory profile for profile-guided memory optimization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<pathname>", nullptr, true, 0, CodeGenOpts.MemoryProfileUsePath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-allowlist=", fsanitize_coverage_allowlist, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageAllowlistFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-ignorelist=", fsanitize_coverage_ignorelist, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageIgnorelistFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-sanitize-metadata-ignorelist=", fexperimental_sanitize_metadata_ignorelist_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable sanitizer metadata for modules and functions that match the provided special case list", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMetadataIgnorelistFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-memory-track-origins=", fsanitize_memory_track_origins_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable origins tracking in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMemoryTrackOrigins, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-memory-use-after-dtor", fsanitize_memory_use_after_dtor, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable use-after-destroy detection in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMemoryUseAfterDtor, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_memory_use_after_dtor), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-memory-use-after-dtor", fno_sanitize_memory_use_after_dtor, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable use-after-destroy detection in MemorySanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMemoryUseAfterDtor, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_memory_use_after_dtor), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-field-padding=", fsanitize_address_field_padding, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Level of field padding for AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SanitizeAddressFieldPadding, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-use-after-scope", fsanitize_address_use_after_scope, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable use-after-scope detection in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressUseAfterScope, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_address_use_after_scope), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-address-use-after-scope", fno_sanitize_address_use_after_scope, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable use-after-scope detection in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressUseAfterScope, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_address_use_after_scope), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-use-after-return=", sanitize_address_use_after_return_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Select the mode of detecting stack use-after-return in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<mode>", "never,runtime,always", true, 0, CodeGenOpts.SanitizeAddressUseAfterReturn, llvm::AsanDetectStackUseAfterReturnMode::Runtime, false, llvm::AsanDetectStackUseAfterReturnMode::Runtime, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 13)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-poison-custom-array-cookie", fsanitize_address_poison_custom_array_cookie, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable poisoning array cookies when using custom operator new[] in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressPoisonCustomArrayCookie, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_address_poison_custom_array_cookie), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-address-poison-custom-array-cookie", fno_sanitize_address_poison_custom_array_cookie, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable poisoning array cookies when using custom operator new[] in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressPoisonCustomArrayCookie, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_address_poison_custom_array_cookie), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-globals-dead-stripping", fsanitize_address_globals_dead_stripping, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable linker dead stripping of globals in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressGlobalsDeadStripping, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_address_globals_dead_stripping), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-address-globals-dead-stripping", fno_sanitize_address_globals_dead_stripping, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable linker dead stripping of globals in AddressSanitizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressGlobalsDeadStripping, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_address_globals_dead_stripping), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-use-odr-indicator", fsanitize_address_use_odr_indicator, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressUseOdrIndicator, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_address_use_odr_indicator), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-address-use-odr-indicator", fno_sanitize_address_use_odr_indicator, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable ODR indicator globals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeAddressUseOdrIndicator, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_address_use_odr_indicator), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-address-destructor=", sanitize_address_destructor_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set the kind of module destructors emitted by AddressSanitizer instrumentation. These destructors are emitted to unregister instrumented global variables when code is unloaded (e.g. via `dlclose()`).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,global", true, 0, CodeGenOpts.SanitizeAddressDtor, llvm::AsanDtorKind::Global, false, llvm::AsanDtorKind::Global, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 14)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-memory-param-retval", fsanitize_memory_param_retval, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable detection of uninitialized parameters and return values", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMemoryParamRetval, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_memory_param_retval), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-memory-param-retval", fno_sanitize_memory_param_retval, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable detection of uninitialized parameters and return values", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMemoryParamRetval, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_memory_param_retval), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-minimal-runtime", fsanitize_minimal_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMinimalRuntime, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_minimal_runtime), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-minimal-runtime", fno_sanitize_minimal_runtime, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeMinimalRuntime, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_minimal_runtime), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-cfi-cross-dso", fsanitize_cfi_cross_dso, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable control flow integrity (CFI) checks for cross-DSO calls.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCfiCrossDso, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_cfi_cross_dso), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-cfi-cross-dso", fno_sanitize_cfi_cross_dso, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable control flow integrity (CFI) checks for cross-DSO calls.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCfiCrossDso, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_cfi_cross_dso), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-cfi-icall-generalize-pointers", fsanitize_cfi_icall_generalize_pointers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Generalize pointers in CFI indirect call type signature checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCfiICallGeneralizePointers, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-cfi-icall-experimental-normalize-integers", fsanitize_cfi_icall_normalize_integers, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Normalize integers in CFI indirect call type signature checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCfiICallNormalizeIntegers, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-cfi-canonical-jump-tables", fsanitize_cfi_canonical_jump_tables, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Make the jump table addresses canonical in the symbol table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCfiCanonicalJumpTables, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_cfi_canonical_jump_tables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-cfi-canonical-jump-tables", fno_sanitize_cfi_canonical_jump_tables, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Do not make the jump table addresses canonical in the symbol table", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCfiCanonicalJumpTables, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_cfi_canonical_jump_tables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-stats", fsanitize_stats, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable sanitizer statistics gathering.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeStats, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sanitize_stats), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sanitize-stats", fno_sanitize_stats, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable sanitizer statistics gathering.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeStats, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsanitize_stats), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-undefined-strip-path-components=", fsanitize_undefined_strip_path_components_EQ, Joined, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Strip (or keep only, if negative) a given number of path components when emitting check metadata.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<number>", nullptr, true, 0, CodeGenOpts.EmitCheckPathComponentsToStrip, 0, false, 0, normalizeStringIntegral<int>, denormalizeString<int>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-funsafe-math-optimizations", funsafe_math_optimizations, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Allow unsafe floating-point math optimizations which may decrease precision", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->UnsafeFPMath, false, false || LangOpts->CLUnsafeMath || LangOpts->FastMath, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-freciprocal-math", freciprocal_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow division operations to be reassociated", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AllowRecip, false, false || LangOpts->UnsafeFPMath, true, makeBooleanOptionNormalizer(true, false, OPT_fno_reciprocal_math), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-reciprocal-math", fno_reciprocal_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AllowRecip, false, false || LangOpts->UnsafeFPMath, true, makeBooleanOptionNormalizer(false, true, OPT_freciprocal_math), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapprox-func", fapprox_func, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow certain math function calls to be replaced with an approximately equivalent calculation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ApproxFunc, false, false || LangOpts->UnsafeFPMath, true, makeBooleanOptionNormalizer(true, false, OPT_fno_approx_func), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-approx-func", fno_approx_func, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ApproxFunc, false, false || LangOpts->UnsafeFPMath, true, makeBooleanOptionNormalizer(false, true, OPT_fapprox_func), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffinite-math-only", ffinite_math_only, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Allow floating-point optimizations that assume arguments and results are not NaNs or +-inf. This defines the \\_\\_FINITE\\_MATH\\_ONLY\\_\\_ preprocessor macro.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FiniteMathOnly, false, false || LangOpts->CLFiniteMathOnly || LangOpts->FastMath, true, makeBooleanOptionNormalizer(true, false, OPT_fno_finite_math_only), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-finite-math-only", fno_finite_math_only, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FiniteMathOnly, false, false || LangOpts->CLFiniteMathOnly || LangOpts->FastMath, true, makeBooleanOptionNormalizer(false, true, OPT_ffinite_math_only), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-signed-zeros", fno_signed_zeros, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "Allow optimizations that ignore the sign of floating point zeros", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoSignedZero, false, false || LangOpts->CLNoSignedZero || LangOpts->UnsafeFPMath, true, makeBooleanOptionNormalizer(true, false, OPT_fsigned_zeros), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsigned-zeros", fsigned_zeros, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FC1Option | FlangOption | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoSignedZero, false, false || LangOpts->CLNoSignedZero || LangOpts->UnsafeFPMath, true, makeBooleanOptionNormalizer(false, true, OPT_fno_signed_zeros), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frounding-math", frounding_math, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RoundingMath, false, false, false, makeFlagToValueNormalizer(llvm::RoundingMode::Dynamic), denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-strict-float-cast-overflow", fno_strict_float_cast_overflow, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictFloatCastOverflow, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fstrict_float_cast_overflow), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fstrict-float-cast-overflow", fstrict_float_cast_overflow, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Assume that overflowing float-to-int casts are undefined (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictFloatCastOverflow, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_strict_float_cast_overflow), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fprotect-parens", fprotect_parens, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | DefaultVis, 0,
       "Determines whether the optimizer honors parentheses when floating-point expressions are evaluated", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ProtectParens, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_protect_parens), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-protect-parens", fno_protect_parens, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ProtectParens, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fprotect_parens), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-frewrite-imports", frewrite_imports, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.RewriteImports, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_rewrite_imports), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fno-rewrite-imports", fno_rewrite_imports, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.RewriteImports, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_frewrite_imports), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-frewrite-includes", frewrite_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.RewriteIncludes, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_rewrite_includes), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fno-rewrite-includes", fno_rewrite_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.RewriteIncludes, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_frewrite_includes), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-delete-null-pointer-checks", fno_delete_null_pointer_checks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Do not treat usage of null pointers as undefined behavior", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NullPointerIsValid, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fdelete_null_pointer_checks), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdelete-null-pointer-checks", fdelete_null_pointer_checks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Treat usage of null pointers as undefined behavior (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NullPointerIsValid, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_delete_null_pointer_checks), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fuse-line-directives", fuse_line_directives, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use #line in preprocessed output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.UseLineDirectives, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_use_line_directives), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fno-use-line-directives", fno_use_line_directives, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.UseLineDirectives, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fuse_line_directives), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fminimize-whitespace", fminimize_whitespace, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Ignore the whitespace from the input file when emitting preprocessor output. It will only contain whitespace when necessary, e.g. to keep two minus signs from merging into to an increment operator. Useful with the -P option to normalize whitespace such that two files with only formatting changes are equal.\n\nOnly valid with -E on C-like inputs and incompatible with -traditional-cpp.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.MinimizeWhitespace, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_minimize_whitespace), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fno-minimize-whitespace", fno_minimize_whitespace, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.MinimizeWhitespace, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fminimize_whitespace), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fkeep-system-includes", fkeep_system_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Instead of expanding system headers when emitting preprocessor output, preserve the #include directive. Useful when producing preprocessed output for test case reduction. May produce incorrect output if preprocessor symbols that control the included content (e.g. _XOPEN_SOURCE) are defined in the including source file. The portability of the resulting source to other compilation environments is not guaranteed.\n\nOnly valid with -E.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.KeepSystemIncludes, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_keep_system_includes), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-fno-keep-system-includes", fno_keep_system_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOutputOpts.KeepSystemIncludes, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fkeep_system_includes), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffreestanding", ffreestanding, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Assert that the compilation takes place in a freestanding environment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Freestanding, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgnu-keywords", fgnu_keywords, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Allow GNU-extension keywords regardless of language standard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GNUKeywords, LangOpts->GNUMode, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gnu_keywords), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gnu-keywords", fno_gnu_keywords, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GNUKeywords, LangOpts->GNUMode, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgnu_keywords), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgnu89-inline", fgnu89_inline, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use the gnu89 inline semantics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, !LangOpts->CPlusPlus, 0, LangOpts->GNUInline, !LangOpts->C99 && !LangOpts->CPlusPlus, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gnu89_inline), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gnu89-inline", fno_gnu89_inline, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, !LangOpts->CPlusPlus, 0, LangOpts->GNUInline, !LangOpts->C99 && !LangOpts->CPlusPlus, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgnu89_inline), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fheinous-gnu-extensions", fheinous_gnu_extensions, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HeinousExtensions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-finline-max-stacksize=", finline_max_stacksize_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Suppress inlining of functions whose stack size exceeds the given value", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.InlineMaxStackSize, UINT_MAX, false, UINT_MAX, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fjmc", fjmc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable just-my-code debugging", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.JMCInstrument, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_jmc), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-jmc", fno_jmc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.JMCInstrument, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fjmc), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-strict-floating-point", fexperimental_strict_floating_point, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enables the use of non-default rounding modes and non-default exception handling on targets that are not currently ready.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ExpStrictFP, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-finstrument-functions", finstrument_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate calls to instrument function entry and exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.InstrumentFunctions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-finstrument-functions-after-inlining", finstrument_functions_after_inlining, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Like -finstrument-functions, but insert the calls after inlining", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.InstrumentFunctionsAfterInlining, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-finstrument-function-entry-bare", finstrument_function_entry_bare, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Instrument function entry only, after inlining, without arguments to the instrumentation call", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.InstrumentFunctionEntryBare, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mfunction-return=", mfunction_return_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | DefaultVis | CLOption, 0,
       "Replace returns with jumps to ``__x86_return_thunk`` (x86 only, error otherwise)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,thunk-extern", true, 0, CodeGenOpts.FunctionReturnThunks, llvm::FunctionReturnThunksKind::Keep, false, llvm::FunctionReturnThunksKind::Keep, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 15)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mindirect-branch-cs-prefix", mindirect_branch_cs_prefix, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option | DefaultVis | CLOption, 0,
       "Add cs prefix to call and jmp to indirect thunk", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.IndirectBranchCSPrefix, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-instrument", fxray_instrument, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Generate XRay instrumentation sleds on function entry and exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayInstrument, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_xray_instrument), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-xray-instrument", fno_xray_instrument, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayInstrument, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fxray_instrument), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-instruction-threshold=", fxray_instruction_threshold_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Sets the minimum function size to instrument with XRay", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRayInstructionThreshold, 200, false, 200, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-always-instrument=", fxray_always_instrument, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayAlwaysInstrumentFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-never-instrument=", fxray_never_instrument, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayNeverInstrumentFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-attr-list=", fxray_attr_list, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Filename defining the list of functions/types for imbuing XRay attributes.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayAttrListFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-always-emit-customevents", fxray_always_emit_customevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Always emit __xray_customevent(...) calls even if the containing function is not always instrumented", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayAlwaysEmitCustomEvents, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_xray_always_emit_customevents), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-xray-always-emit-customevents", fno_xray_always_emit_customevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayAlwaysEmitCustomEvents, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fxray_always_emit_customevents), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-always-emit-typedevents", fxray_always_emit_typedevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayAlwaysEmitTypedEvents, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_xray_always_emit_typedevents), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-xray-always-emit-typedevents", fno_xray_always_emit_typedevents, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->XRayAlwaysEmitTypedEvents, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fxray_always_emit_typedevents), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-ignore-loops", fxray_ignore_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't instrument functions with loops unless they also meet the minimum function size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRayIgnoreLoops, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_xray_ignore_loops), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-xray-ignore-loops", fno_xray_ignore_loops, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRayIgnoreLoops, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fxray_ignore_loops), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-function-index", fxray_function_index, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRayFunctionIndex, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_xray_function_index), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-xray-function-index", fno_xray_function_index, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Omit function index section at the expense of single-function patching performance", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRayFunctionIndex, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fxray_function_index), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-function-groups=", fxray_function_groups, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Only instrument 1 of N groups", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRayTotalFunctionGroups, 1, false, 1, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fxray-selected-function-group=", fxray_selected_function_group, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "When using -fxray-function-groups, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.XRaySelectedFunctionGroup, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ffine-grained-bitfield-accesses", ffine_grained_bitfield_accesses, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use separate accesses for consecutive bitfield runs with legal widths and alignments.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FineGrainedBitfieldAccesses, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_fine_grained_bitfield_accesses), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-fine-grained-bitfield-accesses", fno_fine_grained_bitfield_accesses, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use large-integer access for consecutive bitfield runs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FineGrainedBitfieldAccesses, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_ffine_grained_bitfield_accesses), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-omit-vtable-rtti", fexperimental_omit_vtable_rtti, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Omit the RTTI component from virtual tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OmitVTableRTTI, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_experimental_omit_vtable_rtti), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-experimental-omit-vtable-rtti", fno_experimental_omit_vtable_rtti, Flag, f_Group, INVALID, nullptr, 0, CC1Option | CC1Option, 0,
       "Do not omit the RTTI component from virtual tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OmitVTableRTTI, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fexperimental_omit_vtable_rtti), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-flax-vector-conversions=", flax_vector_conversions_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable implicit vector bit-casts", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,integer,all", true, 0, LangOpts->LaxVectorConversions, LangOpts->OpenCL ? LangOptions::LaxVectorConversionKind::None : LangOptions::LaxVectorConversionKind::All, false, LangOpts->OpenCL ? LangOptions::LaxVectorConversionKind::None : LangOptions::LaxVectorConversionKind::All, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 16)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fclangir", fclangir, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Use the ClangIR pipeline to compile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.UseClangIRPipeline, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_clangir), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fno-clangir", fno_clangir, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Use the AST -> LLVM pipeline to compile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.UseClangIRPipeline, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fclangir), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-funified-lto", funified_lto, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use the unified LTO pipeline", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UnifiedLTO, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_unified_lto), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-unified-lto", fno_unified_lto, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Use distinct LTO pipelines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UnifiedLTO, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_funified_lto), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fthin-link-bitcode=", fthin_link_bitcode_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption | CC1Option, 0,
       "Write minimized bitcode to <file> for the ThinLTO thin link only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ThinLinkBitcodeFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ffat-lto-objects", ffat_lto_objects, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Enable fat LTO object support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FatLTO, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_fat_lto_objects), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-fat-lto-objects", fno_fat_lto_objects, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "Disable fat LTO object support", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FatLTO, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_ffat_lto_objects), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fmacro-backtrace-limit=", fmacro_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Set the maximum number of entries to print in a macro expansion backtrace (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->MacroBacktraceLimit, DiagnosticOptions::DefaultMacroBacktraceLimit, false, DiagnosticOptions::DefaultMacroBacktraceLimit, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fcaret-diagnostics-max-lines=", fcaret_diagnostics_max_lines_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Set the maximum number of source lines to show in a caret diagnostic (0 = no limit).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->SnippetLineLimit, DiagnosticOptions::DefaultSnippetLineLimit, false, DiagnosticOptions::DefaultSnippetLineLimit, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fmerge-all-constants", fmerge_all_constants, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DefaultVis, 0,
       "Allow merging of constants", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MergeAllConstants, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_merge_all_constants), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-merge-all-constants", fno_merge_all_constants, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disallow merging of constants", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MergeAllConstants, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmerge_all_constants), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fmessage-length=", fmessage_length_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Format message diagnostics so that they fit within N columns", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->MessageLength, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fms-compatibility", fms_compatibility, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Enable full Microsoft Visual C++ compatibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MSVCCompat, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fms-define-stdc", fms_define_stdc, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Define '__STDC__' to '1' in MSVC Compatibility mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MSVCEnableStdcMacro, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fms-extensions", fms_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Accept some non-standard constructs supported by the Microsoft compiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MicrosoftExt, false, false || LangOpts->MSVCCompat, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fasm-blocks", fasm_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AsmBlocks, LangOpts->MicrosoftExt, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_asm_blocks), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-asm-blocks", fno_asm_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AsmBlocks, LangOpts->MicrosoftExt, false, false, makeBooleanOptionNormalizer(false, true, OPT_fasm_blocks), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fms-volatile", fms_volatile, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Volatile loads and stores have acquire and release semantics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MSVolatile, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_ms_volatile), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-ms-volatile", fno_ms_volatile, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MSVolatile, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fms_volatile), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdelayed-template-parsing", fdelayed_template_parsing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Parse templated function definitions at the end of the translation unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DelayedTemplateParsing, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_delayed_template_parsing), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-delayed-template-parsing", fno_delayed_template_parsing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "Disable delayed template parsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DelayedTemplateParsing, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdelayed_template_parsing), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fms-memptr-rep=", fms_memptr_rep_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "single,multiple,virtual", true, 0, LangOpts->MSPointerToMemberRepresentationMethod, LangOptions::PPTMK_BestCase, false, LangOptions::PPTMK_BestCase, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 17)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fms-kernel", fms_kernel, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Kernel, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdeclspec", fdeclspec, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Allow __declspec as a keyword", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DeclSpecKeyword, false, false || LangOpts->MicrosoftExt || LangOpts->Borland || LangOpts->CUDA, true, makeBooleanOptionNormalizer(true, false, OPT_fno_declspec), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-declspec", fno_declspec, Flag, f_clang_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disallow __declspec as a keyword", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DeclSpecKeyword, false, false || LangOpts->MicrosoftExt || LangOpts->Borland || LangOpts->CUDA, true, makeBooleanOptionNormalizer(false, true, OPT_fdeclspec), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-user-build-path", fmodules_user_build_path, Separate, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the module user build path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<directory>", nullptr, true, 0, HeaderSearchOpts->ModuleUserBuildPath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fprebuilt-implicit-modules", fprebuilt_implicit_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Look up implicit modules in the prebuilt module path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->EnablePrebuiltImplicitModules, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_prebuilt_implicit_modules), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fno-prebuilt-implicit-modules", fno_prebuilt_implicit_modules, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->EnablePrebuiltImplicitModules, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fprebuilt_implicit_modules), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-output=", fmodule_output_EQ, Joined, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption | CC1Option, 0,
       "Save intermediate module file results when compiling a standard C++ module unit.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ModuleOutputPath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fskip-odr-check-in-gmf", fskip_odr_check_in_gmf, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Skip ODR checks for decls in the global module fragment.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SkipODRCheckInGMF, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_skip_odr_check_in_gmf), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-skip-odr-check-in-gmf", fno_skip_odr_check_in_gmf, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Perform ODR checks for decls in the global module fragment.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SkipODRCheckInGMF, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fskip_odr_check_in_gmf), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-modules-reduced-bmi", modules_reduced_bmi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate the reduced BMI", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.GenReducedBMI, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-prune-interval=", fmodules_prune_interval, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the interval (in seconds) between attempts to prune the module cache", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<seconds>", nullptr, true, 0, HeaderSearchOpts->ModuleCachePruneInterval, 7 * 24 * 60 * 60, false, 7 * 24 * 60 * 60, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-prune-after=", fmodules_prune_after, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the interval (in seconds) after which a module file will be considered unused", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<seconds>", nullptr, true, 0, HeaderSearchOpts->ModuleCachePruneAfter, 31 * 24 * 60 * 60, false, 31 * 24 * 60 * 60, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fbuild-session-timestamp=", fbuild_session_timestamp, Joined, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Time when the current build session started", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<time since Epoch in seconds>", nullptr, true, 0, HeaderSearchOpts->BuildSessionTimestamp, 0, false, 0, normalizeStringIntegral<uint64_t>, denormalizeString<uint64_t>, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-validate-once-per-build-session", fmodules_validate_once_per_build_session, Flag, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't verify input files for the modules if the module has been successfully validated or loaded during this build session", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesValidateOncePerBuildSession, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-disable-diagnostic-validation", fmodules_disable_diagnostic_validation, Flag, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable validation of the diagnostic options when loading the module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesValidateDiagnosticOptions, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-validate-system-headers", fmodules_validate_system_headers, Flag, i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Validate the system headers that a module depends on when loading the module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesValidateSystemHeaders, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_modules_validate_system_headers), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-validate-system-headers", fno_modules_validate_system_headers, Flag, i_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesValidateSystemHeaders, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmodules_validate_system_headers), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-validate-textual-header-includes", fno_modules_validate_textual_header_includes, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Do not enforce -fmodules-decluse and private header restrictions for textual headers. This flag will be removed in a future Clang release.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesValidateTextualHeaderIncludes, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-skip-diagnostic-options", fmodules_skip_diagnostic_options, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Disable writing diagnostic options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesSkipDiagnosticOptions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_modules_skip_diagnostic_options), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-skip-diagnostic-options", fno_modules_skip_diagnostic_options, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesSkipDiagnosticOptions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmodules_skip_diagnostic_options), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-skip-header-search-paths", fmodules_skip_header_search_paths, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Disable writing header search paths", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesSkipHeaderSearchPaths, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_modules_skip_header_search_paths), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-skip-header-search-paths", fno_modules_skip_header_search_paths, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesSkipHeaderSearchPaths, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmodules_skip_header_search_paths), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-prune-non-affecting-module-map-files", fno_modules_prune_non_affecting_module_map_files, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Do not prune non-affecting module map files when writing module files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesPruneNonAffectingModuleMaps, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fincremental-extensions", fincremental_extensions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable incremental processing extensions such as processingstatements on the global scope.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->IncrementalExtensions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fvalidate-ast-input-files-content", fvalidate_ast_input_files_content, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Compute and store the hash of input files used to build an AST. Files with mismatching mtime's are considered valid if both contents is identical", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ValidateASTInputFilesContent, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fforce-check-cxx20-modules-input-files", fforce_check_cxx20_modules_input_files, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Check the input source files from C++20 modules explicitly", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ForceCheckCXX20ModulesInputFiles, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fpch-instantiate-templates", fpch_instantiate_templates, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | CLOption, 0,
       "Instantiate templates already while building a PCH", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PCHInstantiateTemplates, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_pch_instantiate_templates), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-pch-instantiate-templates", fno_pch_instantiate_templates, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PCHInstantiateTemplates, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fpch_instantiate_templates), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fimplicit-module-maps", fimplicit_module_maps, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Implicitly search the file system for module map files.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ImplicitModuleMaps, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules", fmodules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable the 'modules' language feature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Modules, LangOpts->CPlusPlusModules, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_modules), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules", fno_modules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Modules, LangOpts->CPlusPlusModules, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmodules), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fbuiltin-headers-in-system-modules", fbuiltin_headers_in_system_modules, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "builtin headers belong to system modules, and _Builtin_ modules are ignored for cstdlib headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->Modules, 0, LangOpts->BuiltinHeadersInSystemModules, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-name=", fmodule_name_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Specify the name of the module to build", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>", nullptr, true, 0, LangOpts->ModuleName, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fsystem-module", fsystem_module, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Build this module as a system module. Only used with -emit-module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.IsSystemModule, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-map-file=", fmodule_map_file, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Load this module map file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, FrontendOpts.ModuleMapFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-strict-decluse", fmodules_strict_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Like -fmodules-decluse but requires all headers to be in modules", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesStrictDeclUse, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-decluse", fmodules_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Require declaration of modules used within a module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesDeclUse, LangOpts->ModulesStrictDeclUse, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_modules_decluse), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-decluse", fno_modules_decluse, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesDeclUse, LangOpts->ModulesStrictDeclUse, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmodules_decluse), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-search-all", fmodules_search_all, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | CLOption, 0,
       "Search even non-imported modules to resolve references", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->Modules, 0, LangOpts->ModulesSearchAll, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_modules_search_all), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-search-all", fno_modules_search_all, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->Modules, 0, LangOpts->ModulesSearchAll, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fmodules_search_all), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-implicit-modules", fno_implicit_modules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ImplicitModules, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fimplicit_modules), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fimplicit-modules", fimplicit_modules, Flag, f_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ImplicitModules, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_implicit_modules), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-check-relocated", fno_modules_check_relocated, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Skip checks for relocated modules when loading PCM files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->ModulesCheckRelocated, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fretain-comments-from-system-headers", fretain_comments_from_system_headers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RetainCommentsFromSystemHeaders, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-knr-functions", fno_knr_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Disable support for K&R C function declarations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DisableKNRFunctions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-assume-sane-operator-new", fno_assume_sane_operator_new, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't assume that C++'s global operator new can't alias any pointer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AssumeSaneOperatorNew, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdigraphs", fdigraphs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Digraphs, LangStandard::getLangStandardForKind(LangOpts->LangStd).hasDigraphs(), false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_digraphs), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-digraphs", fno_digraphs, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Digraphs, LangStandard::getLangStandardForKind(LangOpts->LangStd).hasDigraphs(), false, false, makeBooleanOptionNormalizer(false, true, OPT_fdigraphs), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fveclib=", fveclib, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Use the given vector functions library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "Accelerate,libmvec,MASSV,SVML,SLEEF,Darwin_libsystem_m,ArmPL,AMDLIBM,none", true, 0, CodeGenOpts.VecLib, llvm::driver::VectorLibrary::NoLibrary, false, llvm::driver::VectorLibrary::NoLibrary, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 18)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-operator-names", fno_operator_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not treat C++ operator name keywords as synonyms for operators", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CXXOperatorNames, LangOpts->CPlusPlus, false, true, makeBooleanOptionNormalizer(false, true, OPT_foperator_names), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-foperator-names", foperator_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CXXOperatorNames, LangOpts->CPlusPlus, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_operator_names), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-absolute-paths", fdiagnostics_absolute_paths, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Print absolute paths in diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->AbsolutePath, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-diagnostics-show-line-numbers", fno_diagnostics_show_line_numbers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Show line numbers in diagnostic code snippets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowLineNumbers, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fdiagnostics_show_line_numbers), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-show-line-numbers", fdiagnostics_show_line_numbers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowLineNumbers, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_diagnostics_show_line_numbers), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fno-temp-file", fno_temp_file, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.UseTemporary, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-use-cxa-atexit", fno_use_cxa_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't use __cxa_atexit for calling destructors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CXAAtExit, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fuse_cxa_atexit), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fuse-cxa-atexit", fuse_cxa_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CXAAtExit, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_use_cxa_atexit), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-verbose-asm", fno_verbose_asm, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AsmVerbose, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-encode-cxx-class-template-spec", fobjc_encode_cxx_class_template_spec, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Fully encode c++ class template specialization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EncodeCXXClassTemplateSpec, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_objc_encode_cxx_class_template_spec), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-objc-encode-cxx-class-template-spec", fno_objc_encode_cxx_class_template_spec, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EncodeCXXClassTemplateSpec, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fobjc_encode_cxx_class_template_spec), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-objc-convert-messages-to-runtime-calls", fno_objc_convert_messages_to_runtime_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ObjCConvertMessagesToRuntimeCalls, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fobjc_convert_messages_to_runtime_calls), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-convert-messages-to-runtime-calls", fobjc_convert_messages_to_runtime_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ObjCConvertMessagesToRuntimeCalls, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_objc_convert_messages_to_runtime_calls), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-arc-exceptions", fobjc_arc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use EH-safe code when synthesizing retains and releases in -fobjc-arc", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ObjCAutoRefCountExceptions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_objc_arc_exceptions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-objc-arc-exceptions", fno_objc_arc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ObjCAutoRefCountExceptions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fobjc_arc_exceptions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-exceptions", fobjc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable Objective-C exceptions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCExceptions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_objc_exceptions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-objc-exceptions", fno_objc_exceptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCExceptions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fobjc_exceptions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapplication-extension", fapplication_extension, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Restrict code to those available for App Extensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AppExt, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_application_extension), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-application-extension", fno_application_extension, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AppExt, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fapplication_extension), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frelaxed-template-template-args", frelaxed_template_template_args, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "Enable C++17 relaxed template template argument matching", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RelaxedTemplateTemplateArgs, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_relaxed_template_template_args), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-relaxed-template-template-args", fno_relaxed_template_template_args, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Disable C++17 relaxed template template argument matching", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RelaxedTemplateTemplateArgs, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_frelaxed_template_template_args), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsized-deallocation", fsized_deallocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable C++14 sized global deallocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SizedDeallocation, LangOpts->CPlusPlus14, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_sized_deallocation), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-sized-deallocation", fno_sized_deallocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SizedDeallocation, LangOpts->CPlusPlus14, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsized_deallocation), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-faligned-allocation", faligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable C++17 aligned allocation functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AlignedAllocation, LangOpts->CPlusPlus17, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_aligned_allocation), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-aligned-allocation", fno_aligned_allocation, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AlignedAllocation, LangOpts->CPlusPlus17, false, false, makeBooleanOptionNormalizer(false, true, OPT_faligned_allocation), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fnew-alignment=", fnew_alignment_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specifies the largest alignment guaranteed by '::operator new(size_t)'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<align>", nullptr, true, 0, LangOpts->NewAlignOverride, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-objc-infer-related-result-type", fno_objc_infer_related_result_type, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "do not infer Objective-C related result type based on method family", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCInferRelatedResultType, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fobjc_infer_related_result_type), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-infer-related-result-type", fobjc_infer_related_result_type, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCInferRelatedResultType, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_objc_infer_related_result_type), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-disable-direct-methods-for-testing", fobjc_disable_direct_methods_for_testing, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Ignore attribute objc_direct so that direct methods can be tested", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCDisableDirectMethodsForTesting, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-avoid-heapify-local-blocks", fobjc_avoid_heapify_local_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Try to avoid heapifying local blocks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ObjCAvoidHeapifyLocalBlocks, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_objc_avoid_heapify_local_blocks), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-objc-avoid-heapify-local-blocks", fno_objc_avoid_heapify_local_blocks, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't try to avoid heapifying local blocks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ObjCAvoidHeapifyLocalBlocks, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fobjc_avoid_heapify_local_blocks), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdisable-block-signature-string", fdisable_block_signature_string, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable block signature string)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableBlockSignatureString, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_disable_block_signature_string), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-disable-block-signature-string", fno_disable_block_signature_string, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Don't disable block signature string)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableBlockSignatureString, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdisable_block_signature_string), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fopenmp-extensions", fopenmp_extensions, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable all Clang extensions for OpenMP directives and clauses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPExtensions, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_openmp_extensions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-openmp-extensions", fno_openmp_extensions, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable all Clang extensions for OpenMP directives and clauses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPExtensions, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_fopenmp_extensions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fopenmp-assume-no-thread-state", fopenmp_assume_no_thread_state, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Assert no thread in a parallel region modifies an ICV", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPNoThreadState, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fopenmp-assume-no-nested-parallelism", fopenmp_assume_no_nested_parallelism, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option | FC1Option | FlangOption, 0,
       "Assert no nested parallel regions in the GPU", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPNoNestedParallelism, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fopenmp-offload-mandatory", fopenmp_offload_mandatory, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option, 0,
       "Do not create a host fallback if offloading to the device fails.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPOffloadMandatory, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fopenmp-force-usm", fopenmp_force_usm, Flag, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Force behvaior as if the user specified pragma omp requires unified_shared_memory.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPForceUSM, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fopenmp-optimistic-collapse", fopenmp_optimistic_collapse, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPOptimisticCollapse, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_openmp_optimistic_collapse), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-openmp-optimistic-collapse", fno_openmp_optimistic_collapse, Flag, f_Group, INVALID, nullptr, NoArgumentUnused | HelpHidden, 0, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->OpenMPOptimisticCollapse, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fopenmp_optimistic_collapse), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-optimize-sibling-calls", fno_optimize_sibling_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable tail call optimization, keeping the call stack accurate", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableTailCalls, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-escaping-block-tail-calls", fno_escaping_block_tail_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoEscapingBlockTailCalls, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fescaping_block_tail_calls), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fescaping-block-tail-calls", fescaping_block_tail_calls, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoEscapingBlockTailCalls, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_escaping_block_tail_calls), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fpack-struct=", fpack_struct_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the default maximum struct packing alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PackStruct, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmax-type-align=", fmax_type_align_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Specify the maximum alignment to enforce on pointers lacking an explicit alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MaxTypeAlign, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fpascal-strings", fpascal_strings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Recognize and construct Pascal-style string literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PascalStrings, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_pascal_strings), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-pascal-strings", fno_pascal_strings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PascalStrings, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fpascal_strings), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpatchable-function-entry=", fpatchable_function_entry_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Generate M NOPs before function entry and N-M NOPs after function entry", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N,M>", nullptr, true, 0, CodeGenOpts.PatchableFunctionEntryCount, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fms-hotpatch", fms_hotpatch, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Ensure that all functions can be hotpatched at runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.HotPatch, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-plt", fno_plt, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use GOT indirection instead of PLT to make external function calls (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoPLT, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fplt), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fplt", fplt, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoPLT, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_plt), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fropi", fropi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "Generate read-only position independent code (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ROPI, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_ropi), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-ropi", fno_ropi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ROPI, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fropi), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frwpi", frwpi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "Generate read-write position independent code (ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RWPI, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_rwpi), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-rwpi", fno_rwpi, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RWPI, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_frwpi), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpass-plugin=", fpass_plugin_EQ, Joined, f_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Load pass plugin from a dynamic shared object file (only with new pass manager).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dsopath>", nullptr, true, 0, CodeGenOpts.PassPlugins, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mtocdata", mtocdata, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "All suitable variables will have the TOC data transformation applied", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AllTocData, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_tocdata), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-tocdata", mno_tocdata, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "This is the default. TOC data transformation is not applied to anyvariables. Only variables specified explicitly in -mtocdata= willhave the TOC data transformation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AllTocData, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_mtocdata), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mtocdata=", mtocdata_EQ, CommaJoined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specifies a list of variables to which the TOC data transformationwill be applied.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.TocDataVarsUserSpecified, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-tocdata=", mno_tocdata_EQ, CommaJoined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specifies a list of variables to be exempt from the TOC datatransformation.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoTocDataVars, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-preserve-as-comments", fno_preserve_as_comments, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not preserve comments in inline assembly", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PreserveAsmComments, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fpreserve_as_comments), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpreserve-as-comments", fpreserve_as_comments, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PreserveAsmComments, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_preserve_as_comments), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-rtti", fno_rtti, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable generation of rtti information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->CPlusPlus, 0, LangOpts->RTTI, LangOpts->CPlusPlus, false, true, makeBooleanOptionNormalizer(false, true, OPT_frtti), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frtti", frtti, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->CPlusPlus, 0, LangOpts->RTTI, LangOpts->CPlusPlus, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_rtti), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-rtti-data", fno_rtti_data, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable generation of RTTI data", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->RTTI, 0, LangOpts->RTTIData, LangOpts->RTTI, false, true, makeBooleanOptionNormalizer(false, true, OPT_frtti_data), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frtti-data", frtti_data, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->RTTI, 0, LangOpts->RTTIData, LangOpts->RTTI, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_rtti_data), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fshort-enums", fshort_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Allocate to an enum type only as many bytes as it needs for the declared range of possible values", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ShortEnums, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_short_enums), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-short-enums", fno_short_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ShortEnums, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fshort_enums), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fchar8_t", fchar8__t, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable C++ builtin type char8_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Char8, LangOpts->CPlusPlus20, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_char8__t), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-char8_t", fno_char8__t, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable C++ builtin type char8_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Char8, LangOpts->CPlusPlus20, false, false, makeBooleanOptionNormalizer(false, true, OPT_fchar8__t), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fshow-overloads=", fshow_overloads_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Which overload candidates to show when overload resolution fails. Defaults to 'all'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "best,all", true, 0, DiagnosticOpts->ShowOverloads, Ovl_All, false, Ovl_All, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 19)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-show-column", fno_show_column, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not include column number on diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowColumn, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fshow_column), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fshow-column", fshow_column, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowColumn, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_show_column), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-show-source-location", fno_show_source_location, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not include source location information with diagnostics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowLocation, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fshow_source_location), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fshow-source-location", fshow_source_location, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowLocation, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_show_source_location), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-spell-checking", fno_spell_checking, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable spell-checking", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SpellChecking, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fspell_checking), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fspell-checking", fspell_checking, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SpellChecking, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_spell_checking), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fspell-checking-limit=", fspell_checking_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of times to perform spell checking on unrecognized identifiers (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->SpellCheckingLimit, DiagnosticOptions::DefaultSpellCheckingLimit, false, DiagnosticOptions::DefaultSpellCheckingLimit, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-signed-char", fno_signed_char, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "char is unsigned", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, !LangOpts->OpenCL, 0, LangOpts->CharIsSigned, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fsigned_char), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsigned-char", fsigned_char, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "char is signed", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, !LangOpts->OpenCL, 0, LangOpts->CharIsSigned, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_signed_char), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-split-stack", fno_split_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Wouldn't use segmented stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableSegmentedStacks, false, false, true, makeBooleanOptionNormalizer(false, true, OPT_fsplit_stack), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsplit-stack", fsplit_stack, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use segmented stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableSegmentedStacks, false, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_split_stack), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fstack-clash-protection", fstack_clash_protection, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable stack clash protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackClashProtector, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_stack_clash_protection), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-stack-clash-protection", fno_stack_clash_protection, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable stack clash protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackClashProtector, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fstack_clash_protection), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ftrivial-auto-var-init=", ftrivial_auto_var_init, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Initialize trivial automatic stack variables. Defaults to 'uninitialized'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "uninitialized,zero,pattern", true, 0, LangOpts->TrivialAutoVarInit, LangOptions::TrivialAutoVarInitKind::Uninitialized, false, LangOptions::TrivialAutoVarInitKind::Uninitialized, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 20)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ftrivial-auto-var-init-stop-after=", ftrivial_auto_var_init_stop_after, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Stop initializing trivial automatic stack variables after the specified number of instances", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->TrivialAutoVarInitStopAfter, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ftrivial-auto-var-init-max-size=", ftrivial_auto_var_init_max_size, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Stop initializing trivial automatic stack variables if var size exceeds the specified number of instances (in bytes)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->TrivialAutoVarInitMaxSize, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fstrict-enums", fstrict_enums, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable optimizations based on the strict definition of an enum's value range", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictEnums, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fstrict-vtable-pointers", fstrict_vtable_pointers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable optimizations based on the strict rules for overwriting polymorphic C++ objects", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictVTablePointers, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_strict_vtable_pointers), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-strict-vtable-pointers", fno_strict_vtable_pointers, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictVTablePointers, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fstrict_vtable_pointers), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ftemplate-depth=", ftemplate_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum depth of recursive template instantiation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->InstantiationDepth, 1024, false, 1024, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-ftemplate-backtrace-limit=", ftemplate_backtrace_limit_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the maximum number of entries to print in a template instantiation backtrace (0 = no limit)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->TemplateBacktraceLimit, DiagnosticOptions::DefaultTemplateBacktraceLimit, false, DiagnosticOptions::DefaultTemplateBacktraceLimit, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-foperator-arrow-depth=", foperator_arrow_depth_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Maximum number of 'operator->'s to call for a member access", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ArrowDepth, 256, false, 256, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-assumptions", fno_assumptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Disable codegen and compile-time checks for C++23's [[assume]] attribute", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CXXAssumptions, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fassumptions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fassumptions", fassumptions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CXXAssumptions, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_assumptions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-Wlarge-by-value-copy=", Wlarge_by_value_copy_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NumLargeByValueCopy, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-threadsafe-statics", fno_threadsafe_statics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Do not emit code to make initialization of local statics thread safe", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ThreadsafeStatics, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fthreadsafe_statics), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fthreadsafe-statics", fthreadsafe_statics, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ThreadsafeStatics, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_threadsafe_statics), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ftime-report", ftime_report, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.TimePasses, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ftime-report=", ftime_report_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "(For new pass manager) 'per-pass': one report for each pass; 'per-pass-run': one report for each pass invocation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "per-pass,per-pass-run", true, 0, CodeGenOpts.TimePassesPerRun, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ftime-trace-granularity=", ftime_trace_granularity_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Minimum time granularity (in microseconds) traced by time profiler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.TimeTraceGranularity, 500u, false, 500u, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ftime-trace-verbose", ftime_trace_verbose, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Make time trace capture verbose event details (e.g. source filenames). This can increase the size of the output by 2-3 times", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.TimeTraceVerbose, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ftime-trace=", ftime_trace_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Similar to -ftime-trace. Specify the JSON file or a directory which will contain the JSON file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.TimeTracePath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ftls-model=", ftlsmodel_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "global-dynamic,local-dynamic,initial-exec,local-exec", true, 0, CodeGenOpts.DefaultTLSModel, CodeGenOptions::GeneralDynamicTLSModel, false, CodeGenOptions::GeneralDynamicTLSModel, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 21)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ftrap-function=", ftrap_function_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Issue call to specified function rather than a trap instruction", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.TrapFuncName, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fregister-global-dtors-with-atexit", fregister_global_dtors_with_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use atexit or __cxa_atexit to register global destructors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RegisterGlobalDtorsWithAtExit, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_register_global_dtors_with_atexit), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-register-global-dtors-with-atexit", fno_register_global_dtors_with_atexit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Don't use atexit or __cxa_atexit to register global destructors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RegisterGlobalDtorsWithAtExit, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fregister_global_dtors_with_atexit), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-use-init-array", fno_use_init_array, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use .ctors/.dtors instead of .init_array/.fini_array", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UseInitArray, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fuse_init_array), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fuse-init-array", fuse_init_array, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UseInitArray, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_use_init_array), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-from-dllstorageclass", fvisibility_from_dllstorageclass, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Override the visibility of globals based on their final DLL storage class.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VisibilityFromDLLStorageClass, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_visibility_from_dllstorageclass), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-visibility-from-dllstorageclass", fno_visibility_from_dllstorageclass, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VisibilityFromDLLStorageClass, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fvisibility_from_dllstorageclass), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-dllexport=", fvisibility_dllexport_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for dllexport definitions. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default", LangOpts->VisibilityFromDLLStorageClass, 0, LangOpts->DLLExportVisibility, LangOptions::VisibilityFromDLLStorageClassKinds::Default, false, LangOptions::VisibilityFromDLLStorageClassKinds::Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 22)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-nodllstorageclass=", fvisibility_nodllstorageclass_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for definitions without an explicit DLL storage class. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default", LangOpts->VisibilityFromDLLStorageClass, 0, LangOpts->NoDLLStorageClassVisibility, LangOptions::VisibilityFromDLLStorageClassKinds::Hidden, false, LangOptions::VisibilityFromDLLStorageClassKinds::Hidden, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 23)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-externs-dllimport=", fvisibility_externs_dllimport_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for dllimport external declarations. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default", LangOpts->VisibilityFromDLLStorageClass, 0, LangOpts->ExternDeclDLLImportVisibility, LangOptions::VisibilityFromDLLStorageClassKinds::Default, false, LangOptions::VisibilityFromDLLStorageClassKinds::Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 24)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-externs-nodllstorageclass=", fvisibility_externs_nodllstorageclass_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for external declarations without an explicit DLL storage class. If Keep is specified the visibility is not adjusted [-fvisibility-from-dllstorageclass]", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "keep,hidden,protected,default", LangOpts->VisibilityFromDLLStorageClass, 0, LangOpts->ExternDeclNoDLLStorageClassVisibility, LangOptions::VisibilityFromDLLStorageClassKinds::Hidden, false, LangOptions::VisibilityFromDLLStorageClassKinds::Hidden, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 25)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility=", fvisibility_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Set the default symbol visibility for all global definitions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "default,hidden,internal,protected", true, 0, LangOpts->ValueVisibilityMode, DefaultVisibility, false, DefaultVisibility, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 26)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-inlines-hidden", fvisibility_inlines_hidden, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Give inline C++ member functions hidden visibility by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->InlineVisibilityHidden, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_visibility_inlines_hidden), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-visibility-inlines-hidden", fno_visibility_inlines_hidden, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->InlineVisibilityHidden, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fvisibility_inlines_hidden), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-inlines-hidden-static-local-var", fvisibility_inlines_hidden_static_local_var, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CC1Option, 0,
       "When -fvisibility-inlines-hidden is enabled, static variables in inline C++ member functions will also be given hidden visibility by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VisibilityInlinesHiddenStaticLocalVar, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_visibility_inlines_hidden_static_local_var), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-visibility-inlines-hidden-static-local-var", fno_visibility_inlines_hidden_static_local_var, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disables -fvisibility-inlines-hidden-static-local-var (this is the default on non-darwin targets)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VisibilityInlinesHiddenStaticLocalVar, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fvisibility_inlines_hidden_static_local_var), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fvisibility-global-new-delete=", fvisibility_global_new_delete_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "The visibility for global C++ operator new and delete declarations. If 'source' is specified the visibility is not adjusted", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "force-default,force-protected,force-hidden,source", true, 0, LangOpts->GlobalAllocationFunctionVisibility, LangOptions::VisibilityForcedKinds::ForceDefault, false, LangOptions::VisibilityForcedKinds::ForceDefault, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 27)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mdefault-visibility-export-mapping=", mdefault_visibility_export_mapping_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Mapping between default visibility and export", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,explicit,all", true, 0, LangOpts->DefaultVisibilityExportMapping, LangOptions::DefaultVisiblityExportMapping::None, false, LangOptions::DefaultVisiblityExportMapping::None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 28)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fnew-infallible", fnew_infallible, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Enable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NewInfallible, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_new_infallible), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-new-infallible", fno_new_infallible, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Disable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NewInfallible, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fnew_infallible), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fwhole-program-vtables", fwhole_program_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enables whole-program vtable optimization. Requires -flto", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.WholeProgramVTables, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_whole_program_vtables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-whole-program-vtables", fno_whole_program_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.WholeProgramVTables, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fwhole_program_vtables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsplit-lto-unit", fsplit_lto_unit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enables splitting of the LTO unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableSplitLTOUnit, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_split_lto_unit), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-split-lto-unit", fno_split_lto_unit, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableSplitLTOUnit, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsplit_lto_unit), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fforce-emit-vtables", fforce_emit_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Emits more virtual tables to improve devirtualization", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ForceEmitVTables, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_force_emit_vtables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-force-emit-vtables", fno_force_emit_vtables, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ForceEmitVTables, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fforce_emit_vtables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fvirtual-function-elimination", fvirtual_function_elimination, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enables dead virtual function elimination optimization. Requires -flto=full", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.VirtualFunctionElimination, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_virtual_function_elimination), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-virtual-function-elimination", fno_virtual_function_elimination, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.VirtualFunctionElimination, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fvirtual_function_elimination), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fwritable-strings", fwritable_strings, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Store string literals as writable data", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->WritableStrings, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-zero-initialized-in-bss", fno_zero_initialized_in_bss, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't place zero initialized data in BSS", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoZeroInitializedInBSS, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fzero_initialized_in_bss), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fzero-initialized-in-bss", fzero_initialized_in_bss, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoZeroInitializedInBSS, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_zero_initialized_in_bss), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ffunction-sections", ffunction_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Place each function in its own section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FunctionSections, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_function_sections), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-function-sections", fno_function_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FunctionSections, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_ffunction_sections), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fbasic-block-address-map", fbasic_block_address_map, Flag, f_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Emit the basic block address map section.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.BBAddrMap, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_basic_block_address_map), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-basic-block-address-map", fno_basic_block_address_map, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.BBAddrMap, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fbasic_block_address_map), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fbasic-block-sections=", fbasic_block_sections_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Place each function's basic blocks in unique sections (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "all,labels,none,list=", true, 0, CodeGenOpts.BBSections, "none", false, "none", normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdata-sections", fdata_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Place each data in its own section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DataSections, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_data_sections), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-data-sections", fno_data_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DataSections, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdata_sections), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fstack-size-section", fstack_size_section, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Emit section containing metadata on function stack sizes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackSizeSection, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_stack_size_section), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-stack-size-section", fno_stack_size_section, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackSizeSection, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fstack_size_section), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-stack-usage-file", stack_usage_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename (or -) to write stack usage output to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackUsageOutput, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-funique-basic-block-section-names", funique_basic_block_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use unique names for basic block sections (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UniqueBasicBlockSectionNames, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_unique_basic_block_section_names), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-unique-basic-block-section-names", fno_unique_basic_block_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UniqueBasicBlockSectionNames, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_funique_basic_block_section_names), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-funique-internal-linkage-names", funique_internal_linkage_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UniqueInternalLinkageNames, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_unique_internal_linkage_names), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-unique-internal-linkage-names", fno_unique_internal_linkage_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UniqueInternalLinkageNames, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_funique_internal_linkage_names), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-unique-section-names", fno_unique_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't use unique names for text and data sections", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UniqueSectionNames, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_funique_section_names), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-funique-section-names", funique_section_names, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UniqueSectionNames, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_unique_section_names), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fseparate-named-sections", fseparate_named_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use separate unique sections for named sections (ELF Only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SeparateNamedSections, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_separate_named_sections), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-separate-named-sections", fno_separate_named_sections, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SeparateNamedSections, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fseparate_named_sections), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsplit-machine-functions", fsplit_machine_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable late function splitting using profile information (x86 ELF)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SplitMachineFunctions, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_split_machine_functions), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-split-machine-functions", fno_split_machine_functions, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Disable late function splitting using profile information (x86 ELF)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SplitMachineFunctions, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsplit_machine_functions), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-strict-return", fno_strict_return, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Don't treat control flow paths that fall off the end of a non-void function as unreachable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictReturn, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fstrict_return), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fstrict-return", fstrict_return, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StrictReturn, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_strict_return), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fenable-matrix", fenable_matrix, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable matrix data type and related builtin functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MatrixTypes, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fraw-string-literals", fraw_string_literals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable raw string literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RawStringLiterals, LangStandard::getLangStandardForKind(LangOpts->LangStd).hasRawStringLiterals(), false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_raw_string_literals), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-raw-string-literals", fno_raw_string_literals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable raw string literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RawStringLiterals, LangStandard::getLangStandardForKind(LangOpts->LangStd).hasRawStringLiterals(), false, false, makeBooleanOptionNormalizer(false, true, OPT_fraw_string_literals), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fzero-call-used-regs=", fzero_call_used_regs_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Clear call-used registers upon function return (AArch64/x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "skip,used-gpr-arg,used-gpr,used-arg,used,all-gpr-arg,all-gpr,all-arg,all", true, 0, CodeGenOpts.ZeroCallUsedRegs, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip, false, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 29)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdebug-ranges-base-address", fdebug_ranges_base_address, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use DWARF base address selection entries in .debug_ranges", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugRangesBaseAddress, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_debug_ranges_base_address), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-debug-ranges-base-address", fno_debug_ranges_base_address, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugRangesBaseAddress, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdebug_ranges_base_address), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-split-dwarf-inlining", fno_split_dwarf_inlining, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SplitDwarfInlining, false, false, true, makeBooleanOptionNormalizer(false, true, OPT_fsplit_dwarf_inlining), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsplit-dwarf-inlining", fsplit_dwarf_inlining, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SplitDwarfInlining, false, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_split_dwarf_inlining), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fforce-dwarf-frame", fforce_dwarf_frame, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Always emit a debug frame section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ForceDwarfFrameSection, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_force_dwarf_frame), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-force-dwarf-frame", fno_force_dwarf_frame, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ForceDwarfFrameSection, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fforce_dwarf_frame), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-femit-dwarf-unwind=", femit_dwarf_unwind_EQ, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "When to emit DWARF unwind (EH frame) info", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "always,no-compact-unwind,default", true, 0, CodeGenOpts.EmitDwarfUnwind, llvm::EmitDwarfUnwindType::Default, false, llvm::EmitDwarfUnwindType::Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 30)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-femit-compact-unwind-non-canonical", femit_compact_unwind_non_canonical, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | DefaultVis, 0,
       "Try emitting Compact-Unwind for non-canonical entries. Maybe overriden by other constraints", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitCompactUnwindNonCanonical, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_emit_compact_unwind_non_canonical), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-emit-compact-unwind-non-canonical", fno_emit_compact_unwind_non_canonical, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitCompactUnwindNonCanonical, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_femit_compact_unwind_non_canonical), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gdwarf64", gdwarf64, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Enables DWARF64 format for ELF binaries, if debug information emission is enabled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Dwarf64, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gcodeview", gcodeview, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0,
       "Generate CodeView debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitCodeView, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gcodeview-ghash", gcodeview_ghash, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "Emit type record hashes in a .debug$H section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CodeViewGHash, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_gno_codeview_ghash), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gno-codeview-ghash", gno_codeview_ghash, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CodeViewGHash, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_gcodeview_ghash), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gcodeview-command-line", gcodeview_command_line, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Emit compiler path and command line into CodeView debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CodeViewCommandLine, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_gno_codeview_command_line), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gno-codeview-command-line", gno_codeview_command_line, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption | DXCOption | CC1Option, 0,
       "Don't emit compiler path and command line into CodeView debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CodeViewCommandLine, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_gcodeview_command_line), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gno-inline-line-tables", gno_inline_line_tables, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "Don't emit inline line tables.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoInlineLineTables, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_ginline_line_tables), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ginline-line-tables", ginline_line_tables, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoInlineLineTables, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_gno_inline_line_tables), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gstrict-dwarf", gstrict_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "Restrict DWARF features to those defined in the specified version, avoiding features from later versions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugStrictDwarf, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_gno_strict_dwarf), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gno-strict-dwarf", gno_strict_dwarf, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugStrictDwarf, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_gstrict_dwarf), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gno-omit-unreferenced-methods", gno_omit_unreferenced_methods, Flag, g_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugOmitUnreferencedMethods, false, false, true, makeBooleanOptionNormalizer(false, true, OPT_gomit_unreferenced_methods), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gomit-unreferenced-methods", gomit_unreferenced_methods, Flag, g_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugOmitUnreferencedMethods, false, false, true, makeBooleanOptionNormalizer(true, false, OPT_gno_omit_unreferenced_methods), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gno-column-info", gno_column_info, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugColumnInfo, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_gcolumn_info), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gcolumn-info", gcolumn_info, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DXCOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugColumnInfo, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_gno_column_info), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gsrc-hash=", gsrc_hash_EQ, Joined, g_flags_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "md5,sha1,sha256", true, 0, CodeGenOpts.DebugSrcHash, CodeGenOptions::DSH_MD5, false, CodeGenOptions::DSH_MD5, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 31)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-gembed-source", gembed_source, Flag, g_flags_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Embed source text in DWARF debug sections", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmbedSource, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_4, "-help", help, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | FC1Option | FlangOption | DXCOption, 0,
       "Display available options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ShowHelp, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_4, "-imacros", imacros, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include macros from file before parsing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, PreprocessorOpts->MacroIncludes, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-include-pch", include_pch, Separate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Include precompiled header file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, PreprocessorOpts->ImplicitPCHInclude, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_4, "-relocatable-pch", relocatable_pch, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Whether to build a relocatable precompiled header", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.RelocatablePCH, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-isysroot", isysroot, JoinedOrSeparate, clang_i_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption, 0,
       "Set the system root directory (usually /)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dir>", nullptr, true, 0, HeaderSearchOpts->Sysroot, "/", false, "/", normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mqdsp6-compat", mqdsp6_compat, Flag, m_Group, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable hexagon-qdsp6 backward compatibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HexagonQdsp6Compat, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mdouble=", mdouble_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Force double to be <n> bits", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<n", "32,64", true, 0, LangOpts->DoubleSize, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-inline-asm=", inline_asm_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "att,intel", true, 0, CodeGenOpts.InlineAsmDialect, CodeGenOptions::IAD_ATT, false, CodeGenOptions::IAD_ATT, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 32)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-mcmodel=", mcmodel_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->CodeModel, "default", false, "default", normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-mlarge-data-threshold=", mlarge_data_threshold_EQ, Joined, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | FlangOption | FC1Option | DefaultVis | CLOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->LargeDataThreshold, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mtls-size=", mtls_size_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specify bit size of immediate TLS offsets (AArch64 ELF only): 12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.TLSSize, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-malign-double", malign_double, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Align doubles to two words in structs (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AlignDouble, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-mllvm", mllvm, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption | FC1Option | FlangOption, 0,
       "Additional arguments to forward to LLVM's option processing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.LLVMArgs, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffuchsia-api-level=", ffuchsia_api_level_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set Fuchsia API level", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FuchsiaAPILevel, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mms-bitfields", mms_bitfields, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set the default structure layout to be compatible with the Microsoft compiler standard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->MSBitfields, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mskip-rax-setup", mskip_rax_setup, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Skip setting up RAX register when passing variable arguments (x86 only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SkipRaxSetup, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstackrealign", mstackrealign, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Force realign the stack at entry to every function", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackRealignment, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstack-alignment=", mstack_alignment, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set the stack alignment", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackAlignment, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstack-probe-size=", mstack_probe_size, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set the stack probe size", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackProbeSize, 4096, false, 4096, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-stack-arg-probe", mno_stack_arg_probe, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable stack probes which are enabled by default", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoStackArgProbe, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mthread-model", mthread_model, Separate, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "The thread model to use. Defaults to 'posix')", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "posix,single", true, 0, LangOpts->ThreadModel, LangOptions::ThreadModelKind::POSIX, false, LangOptions::ThreadModelKind::POSIX, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 33)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-meabi", meabi, Separate, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set EABI type. Default depends on triple)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "default,4,5,gnu", true, 0, TargetOpts->EABIVersion, llvm::EABI::Default, false, llvm::EABI::Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 34)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-tls-direct-seg-refs", mno_tls_direct_seg_refs, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Disable direct TLS access through segment registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.IndirectTlsSegRefs, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mspeculative-load-hardening", mspeculative_load_hardening, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SpeculativeLoadHardening, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_speculative_load_hardening), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-speculative-load-hardening", mno_speculative_load_hardening, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CLOption | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SpeculativeLoadHardening, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_mspeculative_load_hardening), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mcmse", mcmse, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Allow use of CMSE (Armv8-M Security Extensions)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Cmse, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-faapcs-bitfield-load", ForceAAPCSBitfieldLoad, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ForceAAPCSBitfieldLoad, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-aapcs-bitfield-width", fno_aapcs_bitfield_width, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Do not follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AAPCSBitfieldWidth, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_faapcs_bitfield_width), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-faapcs-bitfield-width", faapcs_bitfield_width, Flag, m_arm_Features_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AAPCSBitfieldWidth, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_aapcs_bitfield_width), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mvscale-min=", mvscale_min_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Specify the vscale minimum. Defaults to \"1\". (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VScaleMin, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mvscale-max=", mvscale_max_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Specify the vscale maximum. Defaults to the vector length agnostic value of \"0\". (AArch64/RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VScaleMax, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mamdgpu-ieee", mamdgpu_ieee, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Sets the IEEE bit in the expected default floating point  mode register. Floating point opcodes that support exception flag gathering quiet and propagate signaling NaN inputs per IEEE 754-2008. This option changes the ABI. (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitIEEENaNCompliantInsts, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_amdgpu_ieee), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-amdgpu-ieee", mno_amdgpu_ieee, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitIEEENaNCompliantInsts, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_mamdgpu_ieee), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-mcode-object-version=", mcode_object_version_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | FlangOption | CC1Option | FC1Option | DefaultVis | CLOption, 0,
       "Specify code object ABI version. Defaults to 5. (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,4,5,6", true, 0, TargetOpts->CodeObjectVersion, llvm::CodeObjectVersionKind::COV_5, false, llvm::CodeObjectVersionKind::COV_5, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 35)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-munsafe-fp-atomics", munsafe_fp_atomics, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Enable generation of unsafe floating point atomic instructions. May generate more efficient code, but may not respect rounding and denormal modes, and may give incorrect results for certain memory destinations. (AMDGPU only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->AllowAMDGPUUnsafeFPAtomics, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_unsafe_fp_atomics), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-mno-unsafe-fp-atomics", mno_unsafe_fp_atomics, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->AllowAMDGPUUnsafeFPAtomics, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_munsafe_fp_atomics), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mabi=quadword-atomics", mabi_EQ_quadword_atomics, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Enable quadword atomics ABI on AIX (AIX PPC64 only). Uses lqarx/stqcx. instructions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EnableAIXQuadwordAtomicsABI, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mregnames", mregnames, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | DefaultVis | DefaultVis | CLOption, 0,
       "Use full register names when writing assembly output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PPCUseFullRegisterNames, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_regnames), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-regnames", mno_regnames, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | DefaultVis | DefaultVis | CLOption, 0,
       "Use only register numbers when writing assembly output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PPCUseFullRegisterNames, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_mregnames), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-msse2avx", msse2avx, Flag, m_Group, INVALID, nullptr, TargetSpecific, DefaultVis | CC1Option | CC1AsOption | DefaultVis | CLOption, 0,
       "Specify that the assembler should encode SSE instructions with VEX prefix", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SSE2AVX, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fzvector", fzvector, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Enable System z vector language extension", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ZVector, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_zvector), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-zvector", fno_zvector, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ZVector, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fzvector), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mbackchain", mbackchain, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Link stack frames through backchain on System Z", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Backchain, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_backchain), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-backchain", mno_backchain, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Backchain, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_mbackchain), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mrelax-all", mrelax_all, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | DefaultVis | CLOption, 0,
       "(integrated-as) Relax all machine instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RelaxAll, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mincremental-linker-compatible", mincremental_linker_compatible, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | DefaultVis | CLOption, 0,
       "(integrated-as) Emit an object file which can be used with an incremental linker", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.IncrementalLinkerCompatible, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-msoft-float", msoft_float, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use software floating point", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SoftFloat, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mrecip=", mrecip_EQ, CommaJoined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Control use of approximate reciprocal and reciprocal square root instructions followed by <n> iterations of Newton-Raphson refinement. <value> = ( ['!'] ['vec-'] ('rcp'|'sqrt') [('h'|'s'|'d')] [':'<n>] ) | 'all' | 'default' | 'none'", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Reciprocals, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mprefer-vector-width=", mprefer_vector_width_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PreferVectorWidth, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstack-protector-guard=", mstack_protector_guard_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given guard (global, tls) for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackProtectorGuard, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstack-protector-guard-offset=", mstack_protector_guard_offset_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given offset for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackProtectorGuardOffset, INT_MAX, false, INT_MAX, normalizeStringIntegral<int>, denormalizeString<int>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstack-protector-guard-symbol=", mstack_protector_guard_symbol_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given symbol for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackProtectorGuardSymbol, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mstack-protector-guard-reg=", mstack_protector_guard_reg_EQ, Joined, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use the given reg for addressing the stack-protector guard", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StackProtectorGuardReg, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mfentry", mfentry, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Insert calls to fentry at function entry (x86/SystemZ only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CallFEntry, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mnop-mcount", mnop_mcount, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MNopMCount, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mrecord-mcount", mrecord_mcount, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Generate a __mcount_loc section entry for each __fentry__ call.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RecordMCount, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mpacked-stack", mpacked_stack, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Use packed stack layout (SystemZ only).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PackedStack, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-nobuiltininc", nobuiltininc, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption, 0,
       "Disable builtin #include directories", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->UseBuiltinIncludes, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-nogpulib", nogpulib, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Do not link device library for CUDA/HIP device compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoGPULib, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-nostdinc++", nostdincxx, Flag, IncludePath_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Disable standard #include directories for the C++ standard library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->UseStandardCXXIncludes, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-o", o, JoinedOrSeparate, INVALID, INVALID, nullptr, NoXarchOption, DefaultVis | CC1Option | CC1AsOption | FC1Option | FlangOption, 0,
       "Write output to <file>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, FrontendOpts.OutputFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-object-file-name=", object_file_name_EQ, Joined, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption | CLOption | DXCOption, 0,
       "Set the output <file> for debug infos", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, CodeGenOpts.ObjectFilenameForDebug, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_4, "-pedantic-errors", pedantic_errors, Flag, pedantic_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->PedanticErrors, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_4, "-pedantic", pedantic, Flag, pedantic_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Warn on language extensions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->Pedantic, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-pg", pg, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable mcount instrumentation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.InstrumentForProfiling, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-print-ivar-layout", print_ivar_layout, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable Objective-C Ivar layout bitmap print trace", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCGCBitmapPrint, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-pthread", pthread, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Support POSIX threads in generated code", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->POSIXThreads, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_no_pthread), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-no-pthread", no_pthread, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->POSIXThreads, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_pthread), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-resource-dir", resource_dir, Separate, INVALID, INVALID, nullptr, NoXarchOption | HelpHidden, DefaultVis | CC1Option | CLOption | DXCOption | FlangOption | FC1Option, 0,
       "The directory which holds the compiler resource files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ResourceDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-regcall4", regcall4, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis | CLOption, 0,
       "Set __regcall4 as a default calling convention to respect __regcall ABI v.4", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RegCall4, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_4, "-print-supported-cpus", print_supported_cpus, Flag, CompileOnly_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Print supported cpu models for the given target (if target is not specified, it will print the supported cpus for the default target)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.PrintSupportedCPUs, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_4, "-print-supported-extensions", print_supported_extensions, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Print supported -march extensions (RISC-V, AArch64 and ARM only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.PrintSupportedExtensions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_4, "-print-enabled-extensions", print_enabled_extensions, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption, 0,
       "Print the extensions enabled by the given target and -march/-mcpu options. (AArch64 and RISC-V only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.PrintEnabledExtensions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_4, "-traditional-cpp", traditional_cpp, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Enable some traditional CPP emulation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->TraditionalCPP, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-undef", undef, Flag, u_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "undef all system defines", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->UsePredefines, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-v", v, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CLOption | DXCOption | FlangOption, 0,
       "Show commands to run and use verbose output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->Verbose, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-faltivec-src-compat=", altivec_src_compat, Joined, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Source-level compatibility for Altivec vectors (for PowerPC targets). This includes results of vector comparison (scalar for 'xl', vector for 'gcc') as well as behavior when initializing with a scalar (splatting for 'xl', element zero only for 'gcc'). For 'mixed', the compatibility is as 'gcc' for 'vector bool/vector pixel' and as 'xl' for other types. Current default is 'mixed'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "mixed,gcc,xl", true, 0, LangOpts->AltivecSrcCompat, LangOptions::AltivecSrcCompatKind::Mixed, false, LangOptions::AltivecSrcCompatKind::Mixed, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 36)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-w", w, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | FC1Option, 0,
       "Suppress all warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->IgnoreWarnings, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-integrated-as", fno_integrated_as, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | DefaultVis, 0,
       "Disable the integrated assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableIntegratedAS, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fintegrated_as), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fintegrated-as", fintegrated_as, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | FlangOption | DefaultVis, 0,
       "Enable the integrated assembler", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableIntegratedAS, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fno_integrated_as), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef FILE_SYSTEM_OPTION_WITH_MARSHALLING
FILE_SYSTEM_OPTION_WITH_MARSHALLING(prefix_1, "-working-directory", working_directory, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "Resolve file paths relative to the specified directory", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FileSystemOpts.WorkingDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FILE_SYSTEM_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcheck-new", fcheck_new, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | DefaultVis | CC1Option, 0,
       "Do not assume C++ operator new may not return NULL", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CheckNew, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_check_new), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-check-new", fno_check_new, Flag, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CheckNew, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fcheck_new), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsemantic-interposition", fsemantic_interposition, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SemanticInterposition, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_semantic_interposition), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-semantic-interposition", fno_semantic_interposition, Flag, f_Group, INVALID, nullptr, 0, DefaultVis, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SemanticInterposition, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fsemantic_interposition), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-target-abi", target_abi, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Target a particular ABI type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->ABI, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-darwin-target-variant-triple", darwin_target_variant_triple, Separate, INVALID, INVALID, nullptr, 0, DefaultVis | CC1Option | CC1AsOption, 0,
       "Specify the darwin target variant triple", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->DarwinTargetVariantTriple, std::string(), false, std::string(), normalizeTriple, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-tune-cpu", tune_cpu, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Tune for a specific cpu type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->TuneCPU, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-target-cpu", target_cpu, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Target a specific cpu type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->CPU, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-target-feature", target_feature, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Target specific attributes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->FeaturesAsWritten, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-triple", triple, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Specify target triple (e.g. i686-apple-darwin9)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 1, TargetOpts->Triple, llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()), false, llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()), normalizeTriple, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-target-linker-version", target_linker_version, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Target linker version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->LinkerVersion, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-mfpmath", mfpmath, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Which unit to use for fp math", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->FPMath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fpadding-on-unsigned-fixed-point", fpadding_on_unsigned_fixed_point, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Force each unsigned fixed point type to have an extra bit of padding to align their scales with those of signed fixed point types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->FixedPoint, 0, LangOpts->PaddingOnUnsignedFixedPoint, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_padding_on_unsigned_fixed_point), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-padding-on-unsigned-fixed-point", fno_padding_on_unsigned_fixed_point, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->FixedPoint, 0, LangOpts->PaddingOnUnsignedFixedPoint, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fpadding_on_unsigned_fixed_point), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-unoptimized-cfg", analysis_UnoptimizedCFG, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate unoptimized CFGs for all analyses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->UnoptimizedCFG, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-opt-analyze-headers", analyzer_opt_analyze_headers, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Force the static analyzer to analyze functions defined in header files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->AnalyzeAll, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-display-progress", analyzer_display_progress, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit verbose output about the analyzer's progress", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->AnalyzerDisplayProgress, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-note-analysis-entry-points", analyzer_note_analysis_entry_points, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add a note for each bug report to denote their analysis entry points", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->AnalyzerNoteAnalysisEntryPoints, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyze-function", analyze_function, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run analysis on specific function (for C++ include parameters in name)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->AnalyzeSpecificFunction, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-trim-egraph", trim_egraph, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Only show error-related paths in the analysis graph", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->TrimGraph, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-viz-egraph-graphviz", analyzer_viz_egraph_graphviz, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display exploded graph using GraphViz", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->visualizeExplodedGraphWithGraphViz, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-dump-egraph", analyzer_dump_egraph, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump exploded graph to the specified file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->DumpExplodedGraphTo, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-inline-max-stack-depth", analyzer_inline_max_stack_depth, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Bound on stack depth while inlining (4 by default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->InlineMaxStackDepth, 5, false, 5, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-disable-retry-exhausted", analyzer_disable_retry_exhausted, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not re-analyze paths leading to exhausted nodes with a different strategy (may decrease code coverage)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->NoRetryExhausted, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-max-loop", analyzer_max_loop, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The maximum number of times the analyzer will go through a loop", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->maxBlockVisitOnPath, 4, false, 4, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-stats", analyzer_stats, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print internal analyzer statistics.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->PrintStats, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-disable-all-checks", analyzer_disable_all_checks, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable all static analyzer checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->DisableAllCheckers, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-checker-help", analyzer_checker_help, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of analyzer checkers that are available", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowCheckerHelp, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-checker-help-alpha", analyzer_checker_help_alpha, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of in development analyzer checkers. These are NOT considered safe, they are unstable and will emit incorrect reports. Enable ONLY FOR DEVELOPMENT purposes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowCheckerHelpAlpha, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-checker-help-developer", analyzer_checker_help_developer, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of developer-only checkers such as modeling and debug checkers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowCheckerHelpDeveloper, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-config-help", analyzer_config_help, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of -analyzer-config options. These are meant for development purposes only!", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowConfigOptionsList, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-list-enabled-checkers", analyzer_list_enabled_checkers, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of enabled analyzer checkers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowEnabledCheckerList, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-checker-option-help", analyzer_checker_option_help, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of checker and package options", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowCheckerOptionList, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-checker-option-help-alpha", analyzer_checker_option_help_alpha, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of in development checker and package options. These are NOT considered safe, they are unstable and will emit incorrect reports. Enable ONLY FOR DEVELOPMENT purposes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowCheckerOptionAlphaList, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-checker-option-help-developer", analyzer_checker_option_help_developer, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Display the list of checker and package options meant for development purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->ShowCheckerOptionDeveloperList, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-config-compatibility-mode", analyzer_config_compatibility_mode, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't emit errors on invalid analyzer-config inputs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "true,false", true, 0, AnalyzerOpts->ShouldEmitErrorsOnInvalidConfigValue, true, false, true, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 37)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef ANALYZER_OPTION_WITH_MARSHALLING
ANALYZER_OPTION_WITH_MARSHALLING(prefix_1, "-analyzer-werror", analyzer_werror, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit analyzer results as errors rather than warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, AnalyzerOpts->AnalyzerWerror, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // ANALYZER_OPTION_WITH_MARSHALLING
#ifdef MIGRATOR_OPTION_WITH_MARSHALLING
MIGRATOR_OPTION_WITH_MARSHALLING(prefix_1, "-no-ns-alloc-error", migrator_no_nsalloc_error, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not error on use of NSAllocateCollectable/NSReallocateCollectable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, MigratorOpts.NoNSAllocReallocError, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // MIGRATOR_OPTION_WITH_MARSHALLING
#ifdef MIGRATOR_OPTION_WITH_MARSHALLING
MIGRATOR_OPTION_WITH_MARSHALLING(prefix_1, "-no-finalize-removal", migrator_no_finalize_removal, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not remove finalize method in gc mode", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, MigratorOpts.NoFinalizeRemoval, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // MIGRATOR_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mrelocation-model", mrelocation_model, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "The relocation model to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic", true, 0, CodeGenOpts.RelocationModel, llvm::Reloc::PIC_, false, llvm::Reloc::PIC_, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 38)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-debug-info-macro", debug_info_macro, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Emit macro debug information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MacroDebugInfo, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-default-function-attr", default_function_attr, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Apply given attribute to all functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DefaultFunctionAttrs, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-dwarf-version=", dwarf_version_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DwarfVersion, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-debugger-tuning=", debugger_tuning_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "gdb,lldb,sce,dbx", true, 0, CodeGenOpts.DebuggerTuning, llvm::DebuggerKind::Default, false, llvm::DebuggerKind::Default, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 39)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-dwarf-debug-flags", dwarf_debug_flags, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "The string to embed in the Dwarf debug flags record.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DwarfDebugFlags, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-record-command-line", record_command_line, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "The string to embed in the .LLVM.command.line section.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RecordCommandLine, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_4, "-compress-debug-sections=", compress_debug_sections_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "DWARF debug sections compression type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,zlib,zstd", true, 0, CodeGenOpts.CompressDebugSections, llvm::DebugCompressionType::None, false, llvm::DebugCompressionType::None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 40)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mnoexecstack", mno_exec_stack, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Mark the file as not needing an executable stack", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoExecStack, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-massembler-no-warn", massembler_no_warn, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Make assembler not emit warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoWarn, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-massembler-fatal-warnings", massembler_fatal_warnings, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Make assembler warnings fatal", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FatalWarnings, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_3, "--crel", crel, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Enable CREL relocation format (ELF only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.Crel, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mrelax-relocations=no", mrelax_relocations_no, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Disable x86 relax relocations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RelaxELFRelocations, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-msave-temp-labels", msave_temp_labels, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Save temporary labels in the symbol table. Note this may change .s semantics and shouldn't generally be used on compiler-generated code.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SaveTempLabels, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-type-check", mno_type_check, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Don't perform type checking of the assembly code (wasm only)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoTypeCheck, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-math-builtin", fno_math_builtin, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Disable implicit builtin knowledge of math functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoMathBuiltin, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-as-secure-log-file", as_secure_log_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Emit .secure_log_unique directives to this filename.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.AsSecureLogFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-llvm-verify-each", llvm_verify_each, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run the LLVM verifier after every LLVM pass", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.VerifyEach, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-disable-llvm-verifier", disable_llvm_verifier, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't run the LLVM IR verifier pass", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.VerifyModule, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-disable-llvm-passes", disable_llvm_passes, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use together with -emit-llvm to get pristine LLVM IR from the frontend by not running any LLVM passes at all", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableLLVMPasses, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-disable-lifetime-markers", disable_lifetimemarkers, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable lifetime-markers emission even when optimizations are enabled", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableLifetimeMarkers, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-disable-O0-optnone", disable_O0_optnone, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable adding the optnone attribute to functions at O0", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableO0ImplyOptNone, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-disable-red-zone", disable_red_zone, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not emit code that uses the red zone.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DisableRedZone, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-dwarf-ext-refs", dwarf_ext_refs, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate debug info with external references to clang modules or precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugTypeExtRefs, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-dwarf-explicit-import", dwarf_explicit_import, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate explicit import from anonymous namespace to containing scope", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugExplicitImport, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-debug-forward-template-params", debug_forward_template_params, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit complete descriptions of template parameters in forward declarations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugFwdTemplateParams, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fforbid-guard-variables", fforbid_guard_variables, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit an error if a C++ static local initializer would need a guard variable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ForbidGuardVariables, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-no-implicit-float", no_implicit_float, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't generate implicit floating point or vector instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NoImplicitFloat, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdump-vtable-layouts", fdump_vtable_layouts, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump the layouts of all vtables that will be emitted in a translation unit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DumpVTableLayouts, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fmerge-functions", fmerge_functions, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Permit merging of identical functions when optimizing.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MergeFunctions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-coverage-data-file=", anonymous_1859, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CoverageDataFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-coverage-notes-file=", anonymous_1861, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CoverageNotesFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-dump-coverage-mapping", dump_coverage_mapping, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump the coverage mapping records, for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DumpCoverageMapping, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fuse-register-sized-bitfield-access", fuse_register_sized_bitfield_access, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use register sized accesses to bit-fields, when possible.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UseRegisterSizedBitfieldAccess, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-relaxed-aliasing", relaxed_aliasing, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Turn off Type Based Alias Analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.RelaxedAliasing, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-pointer-tbaa", pointer_tbaa, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Turn on Type Based Alias Analysis for pointer accesses", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PointerTBAA, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-no-struct-path-tbaa", no_struct_path_tbaa, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Turn off struct-path aware Type Based Alias Analysis", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.StructPathTBAA, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mdebug-pass", mdebug_pass, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable additional debug output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugPass, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mabi=ieeelongdouble", mabi_EQ_ieeelongdouble, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use IEEE 754 quadruple-precision for long double", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PPCIEEELongDouble, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mabi=vec-extabi", mabi_EQ_vec_extabi, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable the extended Altivec ABI on AIX. Use volatile and nonvolatile vector registers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EnableAIXExtendedAltivecABI, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mfloat-abi", mfloat_abi, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The float ABI to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.FloatABI, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mlimit-float-precision", mlimit_float_precision, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Limit float precision to the given value", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LimitFloatPrecision, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mregparm", mregparm, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Limit the number of registers available for integer arguments", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.NumRegisterParameters, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-msmall-data-limit", msmall_data_limit, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Put global and static data smaller than the limit into a special section", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SmallDataLimit, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-funwind-tables=", funwind_tables_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate unwinding tables for all functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.UnwindTables, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mconstructor-aliases", mconstructor_aliases, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Enable emitting complete constructors and destructors as aliases when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CXXCtorDtorAliases, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_constructor_aliases), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-constructor-aliases", mno_constructor_aliases, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Disable emitting complete constructors and destructors as aliases when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CXXCtorDtorAliases, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_mconstructor_aliases), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mlink-builtin-bitcode-postopt", mlink_builtin_bitcode_postopt, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "Link builtin bitcodes after the optimization pipeline", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LinkBitcodePostopt, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_mno_link_builtin_bitcode_postopt), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mno-link-builtin-bitcode-postopt", mno_link_builtin_bitcode_postopt, Flag, m_Group, INVALID, nullptr, 0, CC1Option | DefaultVis | CLOption, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LinkBitcodePostopt, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_mlink_builtin_bitcode_postopt), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-vectorize-loops", vectorize_loops, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run the Loop vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.VectorizeLoop, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-vectorize-slp", vectorize_slp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Run the SLP vectorization passes", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.VectorizeSLP, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_3, "--linker-option=", linker_option, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Add linker option", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LinkerOptions, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-type=", fsanitize_coverage_type, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Sanitizer coverage type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageType, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-indirect-calls", fsanitize_coverage_indirect_calls, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable sanitizer coverage for indirect calls", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageIndirectCalls, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-bb", fsanitize_coverage_trace_bb, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable basic block tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTraceBB, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-cmp", fsanitize_coverage_trace_cmp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable cmp instruction tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTraceCmp, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-div", fsanitize_coverage_trace_div, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable div instruction tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTraceDiv, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-gep", fsanitize_coverage_trace_gep, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable gep instruction tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTraceGep, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-8bit-counters", fsanitize_coverage_8bit_counters, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable frequency counters in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverage8bitCounters, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-inline-8bit-counters", fsanitize_coverage_inline_8bit_counters, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable inline 8-bit counters in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageInline8bitCounters, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-inline-bool-flag", fsanitize_coverage_inline_bool_flag, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable inline bool flag in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageInlineBoolFlag, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-pc-table", fsanitize_coverage_pc_table, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Create a table of coverage-instrumented PCs", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoveragePCTable, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-control-flow", fsanitize_coverage_control_flow, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Collect control flow of function", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageControlFlow, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-pc", fsanitize_coverage_trace_pc, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable PC tracing in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTracePC, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-pc-guard", fsanitize_coverage_trace_pc_guard, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable PC tracing with guard in sanitizer coverage", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTracePCGuard, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-no-prune", fsanitize_coverage_no_prune, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable coverage pruning (i.e. instrument all blocks/edges)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageNoPrune, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-stack-depth", fsanitize_coverage_stack_depth, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable max stack depth tracing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageStackDepth, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-loads", fsanitize_coverage_trace_loads, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable tracing of loads", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTraceLoads, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fsanitize-coverage-trace-stores", fsanitize_coverage_trace_stores, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable tracing of stores", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeCoverageTraceStores, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-sanitize-metadata=covered", fexperimental_sanitize_metadata_EQ_covered, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit PCs for code covered with binary analysis sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeBinaryMetadataCovered, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-sanitize-metadata=atomics", fexperimental_sanitize_metadata_EQ_atomics, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit PCs for atomic operations used by binary analysis sanitizers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeBinaryMetadataAtomics, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-sanitize-metadata=uar", fexperimental_sanitize_metadata_EQ_uar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit PCs for start of functions that are subject for use-after-return checking.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SanitizeBinaryMetadataUAR, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpatchable-function-entry-offset=", fpatchable_function_entry_offset_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate M NOPs before function entry", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<M>", nullptr, true, 0, CodeGenOpts.PatchableFunctionEntryOffset, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-instrument=", fprofile_instrument_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable PGO instrumentation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,clang,llvm,csllvm", true, 0, CodeGenOpts.ProfileInstr, CodeGenOptions::ProfileNone, false, CodeGenOptions::ProfileNone, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 41)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-instrument-path=", fprofile_instrument_path_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.InstrProfileOutput, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fprofile-instrument-use-path=", fprofile_instrument_use_path_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Specify the profile path in PGO use compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ProfileInstrumentUsePath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-flto-visibility-public-std", flto_visibility_public_std, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use public LTO visibility for classes in std and stdext namespaces", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LTOVisibilityPublicStd, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-flto-unit", flto_unit, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit IR to support LTO unit features (CFI, whole program vtable opt)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LTOUnit, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_lto_unit), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-lto-unit", fno_lto_unit, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.LTOUnit, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_flto_unit), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fverify-debuginfo-preserve", fverify_debuginfo_preserve, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable Debug Info Metadata preservation testing in optimizations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableDIPreservationVerify, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fverify-debuginfo-preserve-export=", fverify_debuginfo_preserve_export, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Export debug info (by testing original Debug Info) failures into specified (JSON) file (should be abs path as we use append mode to insert new JSON objects).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, CodeGenOpts.DIBugsReportFilePath, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fwarn-stack-size=", fwarn_stack_size_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.WarnStackSize, UINT_MAX, false, UINT_MAX, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mbranch-target-enforce", mbranch_target_enforce, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BranchTargetEnforcement, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mbranch-protection-pauth-lr", mbranch_protection_pauth_lr, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BranchProtectionPAuthLR, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mguarded-control-stack", mguarded_control_stack, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GuardedControlStack, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-dllexport-inlines", fno_dllexport_inlines, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DllExportInlines, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-cfguard-no-checks", cfguard_no_checks, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit Windows Control Flow Guard tables only (no checks)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ControlFlowGuardNoChecks, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-cfguard", cfguard, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit Windows Control Flow Guard tables and checks", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ControlFlowGuard, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-ehcontguard", ehcontguard, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Emit Windows EH Continuation Guard tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EHContGuard, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fctor-dtor-return-this", fctor_dtor_return_this, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Change the C++ ABI to returning `this` pointer from constructors and non-deleting destructors. (No effect on Microsoft ABI)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CtorDtorReturnThis, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-assignment-tracking=", fexperimental_assignment_tracking_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "disabled,enabled,forced", true, 0, CodeGenOpts.AssignmentTrackingMode, CodeGenOptions::AssignmentTrackingOpts::Enabled, false, CodeGenOptions::AssignmentTrackingOpts::Enabled, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 42)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-enable-tlsdesc", enable_tlsdesc, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0, nullptr, (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableTLSDESC, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-sys-header-deps", sys_header_deps, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include system headers in dependency output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.IncludeSystemHeaders, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-module-file-deps", module_file_deps, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include module files in dependency output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.IncludeModuleFiles, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-header-include-file", header_include_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename (or -) to write header include output to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DependencyOutputOpts.HeaderIncludeOutputFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-header-include-format=", header_include_format_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "set format in which header info is emitted", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "textual,json", true, 0, DependencyOutputOpts.HeaderIncludeFormat, HIFMT_Textual, false, HIFMT_Textual, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 43)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(prefix_1, "-header-include-filtering=", header_include_filtering_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "set the flag that enables filtering header information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,only-direct-system", true, 0, DependencyOutputOpts.HeaderIncludeFiltering, HIFIL_None, false, HIFIL_None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 44)
#endif // DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-diagnostic-log-file", diagnostic_log_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename (or -) to log diagnostics to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->DiagnosticLogFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-format", fdiagnostics_format, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Change diagnostic formatting to match IDE and command line tools", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "clang,msvc,vi,sarif,SARIF", true, 0, DiagnosticOpts->Format, DiagnosticOptions::Clang, false, DiagnosticOptions::Clang, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 45)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fdiagnostics-show-category", fdiagnostics_show_category, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print diagnostic category", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "none,id,name", true, 0, DiagnosticOpts->ShowCategories, 0, false, 0, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 46)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-diagnostics-use-presumed-location", fno_diagnostics_use_presumed_location, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Ignore #line directives when displaying diagnostic locations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->ShowPresumedLoc, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-ftabstop", ftabstop, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set the tab stop distance.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr, true, 0, DiagnosticOpts->TabStop, DiagnosticOptions::DefaultTabStop, false, DiagnosticOptions::DefaultTabStop, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-ferror-limit", ferror_limit, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set the maximum number of errors to emit before stopping (0 = no limit).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr, true, 0, DiagnosticOpts->ErrorLimit, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef DIAG_OPTION_WITH_MARSHALLING
DIAG_OPTION_WITH_MARSHALLING(prefix_1, "-Wno-rewrite-macros", Wno_rewrite_macros, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Silence ObjC rewriting warnings", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, DiagnosticOpts->NoRewriteMacros, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // DIAG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ast-merge", ast_merge, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Merge the given AST file into the translation unit being compiled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<ast file>", nullptr, true, 0, FrontendOpts.ASTMergeFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-aux-triple", aux_triple, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Auxiliary target triple.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.AuxTriple, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-code-completion-macros", code_completion_macros, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include macros in code-completion results", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.CodeCompleteOpts.IncludeMacros, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-code-completion-patterns", code_completion_patterns, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include code patterns in code-completion results", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.CodeCompleteOpts.IncludeCodePatterns, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-no-code-completion-globals", no_code_completion_globals, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not include global declarations in code-completion results.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.CodeCompleteOpts.IncludeGlobals, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-no-code-completion-ns-level-decls", no_code_completion_ns_level_decls, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not include declarations inside namespaces (incl. global namespace) in the code-completion results.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.CodeCompleteOpts.IncludeNamespaceLevelDecls, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-code-completion-brief-comments", code_completion_brief_comments, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include brief documentation comments in code-completion results.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.CodeCompleteOpts.IncludeBriefComments, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-code-completion-with-fixits", code_completion_with_fixits, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Include code completion results which require small fix-its.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.CodeCompleteOpts.IncludeFixIts, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-disable-free", disable_free, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable freeing of memory on exit", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.DisableFree, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-clear-ast-before-backend", clear_ast_before_backend, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Clear the Clang AST before running backend code generation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ClearASTBeforeBackend, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_no_clear_ast_before_backend), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-no-clear-ast-before-backend", no_clear_ast_before_backend, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't clear the Clang AST before running backend code generation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.ClearASTBeforeBackend, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_clear_ast_before_backend), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-enable-noundef-analysis", enable_noundef_analysis, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable analyzing function argument and return types for mandatory definedness", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableNoundefAttrs, true, false, false, makeBooleanOptionNormalizer(true, false, OPT_no_enable_noundef_analysis), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-no-enable-noundef-analysis", no_enable_noundef_analysis, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable analyzing function argument and return types for mandatory definedness", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EnableNoundefAttrs, true, false, false, makeBooleanOptionNormalizer(false, true, OPT_enable_noundef_analysis), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-discard-value-names", discard_value_names, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Discard value names in LLVM IR", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DiscardValueNames, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-add-plugin", add_plugin, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the named plugin action in addition to the default action", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<name>", nullptr, true, 0, FrontendOpts.AddPluginActions, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ast-dump-filter", ast_dump_filter, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use with -ast-dump or -ast-print to dump/print only AST declaration nodes having a certain substring in a qualified name. Use -ast-list to list all filterable declaration node names.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<dump_filter>", nullptr, true, 0, FrontendOpts.ASTDumpFilter, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-global-index", fno_modules_global_index, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not automatically generate or update the global module index", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.UseGlobalModuleIndex, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-error-recovery", fno_modules_error_recovery, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Do not automatically import modules for error recovery", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesErrorRecovery, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-map-file-home-is-cwd", fmodule_map_file_home_is_cwd, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the current working directory as the home directory of module maps specified by -fmodule-map-file=<FILE>", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModuleMapFileHomeIsCwd, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-file-home-is-cwd", fmodule_file_home_is_cwd, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the current working directory as the base directory of compiled module files.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModuleFileHomeIsCwd, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-feature", fmodule_feature, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable <feature> in module map requires declarations", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<feature>", nullptr, true, 0, LangOpts->ModuleFeatures, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-embed-file=", fmodules_embed_file_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Embed the contents of the specified file into the module file being compiled.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<file>", nullptr, true, 0, FrontendOpts.ModulesEmbedFiles, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-embed-all-files", fmodules_embed_all_files, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Embed the contents of all files read by this compilation into the produced module file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ModulesEmbedAllFiles, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fno-implicit-modules-use-lock", fno_fimplicit_modules_use_lock, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.BuildingImplicitModuleUsesLock, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_ffimplicit_modules_use_lock), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fimplicit-modules-use-lock", ffimplicit_modules_use_lock, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use filesystem locks for implicit modules builds to avoid duplicating work in competing clang invocations.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.BuildingImplicitModuleUsesLock, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_fimplicit_modules_use_lock), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-local-submodule-visibility", fmodules_local_submodule_visibility, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enforce name visibility rules across submodules of the same top-level module.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesLocalVisibility, false, false || LangOpts->CPlusPlusModules, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-codegen", fmodules_codegen, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate code for uses of this module that assumes an explicit object file will be built for the module", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesCodegen, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-debuginfo", fmodules_debuginfo, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate debug info for types in an object file built from this module and do not generate them elsewhere", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ModulesDebugInfo, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodule-format=", fmodule_format_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Select the container format for clang modules and PCH. Supported options are 'raw' and 'obj'.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModuleFormat, "raw", false, "raw", normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-recovery-ast", fno_recovery_ast, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RecoveryAST, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_frecovery_ast), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frecovery-ast", frecovery_ast, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve expressions in AST rather than dropping them when encountering semantic errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RecoveryAST, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_recovery_ast), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-recovery-ast-type", fno_recovery_ast_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RecoveryASTType, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_frecovery_ast_type), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-frecovery-ast-type", frecovery_ast_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve the type for recovery expressions when possible", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->RecoveryASTType, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_recovery_ast_type), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ast-dump-decl-types", ast_dump_decl_types, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Include declaration types in AST dumps", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ASTDumpDeclTypes, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-ast-dump-lookups", ast_dump_lookups, Flag, Action_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Build ASTs and then debug dump their name lookup tables", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ASTDumpLookups, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-emit-llvm-uselists", emit_llvm_uselists, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve order of LLVM use-lists when serializing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitLLVMUseLists, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_no_emit_llvm_uselists), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-no-emit-llvm-uselists", no_emit_llvm_uselists, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't preserve order of LLVM use-lists when serializing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.EmitLLVMUseLists, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_emit_llvm_uselists), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-mt-migrate-directory", mt_migrate_directory, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Directory for temporary files produced during ARC or ObjC migration", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.MTMigrateDir, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-arcmt-action=", arcmt_action_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "The ARC migration action to take", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "check,modify,migrate", true, 0, FrontendOpts.ARCMTAction, FrontendOptions::ARCMT_None, false, FrontendOptions::ARCMT_None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 47)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-print-stats", print_stats, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Print performance metrics and statistics", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ShowStats, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-stats-file=", stats_file, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Filename to write statistics to", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.StatsFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-stats-file-append", stats_file_append, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "If stats should be appended to stats-file instead of overwriting it", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.AppendStats, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdump-record-layouts-simple", fdump_record_layouts_simple, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information in a simple form used for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DumpRecordLayoutsSimple, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdump-record-layouts-canonical", fdump_record_layouts_canonical, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information with canonical field types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DumpRecordLayoutsCanonical, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdump-record-layouts-complete", fdump_record_layouts_complete, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information for all complete types", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DumpRecordLayoutsComplete, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdump-record-layouts", fdump_record_layouts, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump record layout information", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DumpRecordLayouts, false, false || LangOpts->DumpRecordLayoutsSimple || LangOpts->DumpRecordLayoutsComplete || LangOpts->DumpRecordLayoutsCanonical, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fix-what-you-can", fix_what_you_can, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it advice even in the presence of unfixable errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.FixWhatYouCan, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fix-only-warnings", fix_only_warnings, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it advice only for warnings, not errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.FixOnlyWarnings, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fixit-recompile", fixit_recompile, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it changes and recompile", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.FixAndRecompile, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fixit-to-temporary", fixit_to_temp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply fix-it changes to temporary files", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.FixToTemporaries, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-foverride-record-layout=", foverride_record_layout_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Override record layouts with those in the given file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.OverrideRecordLayoutsFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-pch-through-header=", pch_through_header_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Stop PCH generation after including this file.  When using a PCH, skip tokens until after this file is included.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->PCHThroughHeader, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-pch-through-hdrstop-create", pch_through_hdrstop_create, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "When creating a PCH, stop PCH generation after #pragma hdrstop.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->PCHWithHdrStopCreate, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fno-pch-timestamp", fno_pch_timestamp, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable inclusion of timestamp in precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.IncludeTimestamps, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-building-pch-with-obj", building_pch_with_obj, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "This compilation is part of building a PCH with corresponding object file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BuildingPCHWithObjectFile, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-faligned-alloc-unavailable", aligned_alloc_unavailable, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Aligned allocation/deallocation functions are unavailable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->AlignedAllocation, 0, LangOpts->AlignedAllocationUnavailable, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-version", version, Flag, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption | FC1Option, 0,
       "Print the compiler version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ShowVersion, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-main-file-name", main_file_name, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "Main file name to use for debug info and source if missing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.MainFileName, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-split-dwarf-output", split_dwarf_output, Separate, INVALID, INVALID, nullptr, 0, CC1Option | CC1AsOption, 0,
       "File name to use for split dwarf debug info output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SplitDwarfOutput, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-mreassociate", mreassociate, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Allow reassociation transformations for floating-point instructions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->AllowFPReassoc, false, false || LangOpts->UnsafeFPMath, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-menable-no-nans", menable_no_nans, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Allow optimization to assume there are no NaNs.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoHonorNaNs, false, false || LangOpts->FiniteMathOnly, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-menable-no-infs", menable_no_infinities, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Allow optimization to assume there are no infinities.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoHonorInfs, false, false || LangOpts->FiniteMathOnly, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-pic-level", pic_level, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Value for __PIC__", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PICLevel, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-pic-is-pie", pic_is_pie, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "File is for a position independent executable", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->PIE, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-mframe-pointer=", mframe_pointer_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Specify which frame pointers to retain.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "all,non-leaf,reserved,none", true, 0, CodeGenOpts.FramePointer, CodeGenOptions::FramePointerKind::None, false, CodeGenOptions::FramePointerKind::None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 48)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_3, "--dependent-lib=", dependent_lib, Joined, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Add dependent library", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DependentLibraries, std::vector<std::string>({}), false, std::vector<std::string>({}), normalizeStringVector, denormalizeStringVector, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fblocks-runtime-optional", fblocks_runtime_optional, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Weakly link in the blocks runtime", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BlocksRuntimeOptional, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexternc-nounwind", fexternc_nounwind, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Assume all functions with C linkage do not unwind", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ExternCNoUnwind, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-split-dwarf-file", split_dwarf_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Name of the split dwarf debug info file to encode in the object file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SplitDwarfFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-wchar", fno_wchar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable C++ builtin type wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, LangOpts->CPlusPlus, 0, LangOpts->WChar, LangOpts->CPlusPlus, false, LangOpts->CPlusPlus, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fconstant-string-class", fconstant_string_class, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Specify the class to use for constant Objective-C string objects.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<class name>", nullptr, true, 0, LangOpts->ObjCConstantStringClass, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-arc-cxxlib=", fobjc_arc_cxxlib_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Objective-C++ Automatic Reference Counting standard library kind", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "libc++,libstdc++,none", true, 0, PreprocessorOpts->ObjCXXARCStandardLibrary, ARCXX_nolib, false, ARCXX_nolib, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 49)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fobjc-dispatch-method=", fobjc_dispatch_method_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Objective-C dispatch method to use", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "legacy,non-legacy,mixed", true, 0, CodeGenOpts.ObjCDispatchMethod, CodeGenOptions::Legacy, false, CodeGenOptions::Legacy, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 50)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-disable-objc-default-synthesize-properties", disable_objc_default_synthesize_properties, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "disable the default synthesis of Objective-C properties", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ObjCDefaultSynthProperties, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fencode-extended-block-signature", fencode_extended_block_signature, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "enable extended encoding of block type signature", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->EncodeExtendedBlockSig, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-function-alignment", function_alignment, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "default alignment for functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FunctionAlignment, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fhalf-no-semantic-interposition", fhalf_no_semantic_interposition, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Like -fno-semantic-interposition but don't use local aliases", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HalfNoSemanticInterposition, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-fno-validate-pch", fno_validate_pch, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable validation of precompiled headers", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->DisablePCHOrModuleValidation, DisableValidationForModuleKind::None, false, DisableValidationForModuleKind::None, makeFlagToValueNormalizer(DisableValidationForModuleKind::All), denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fallow-pcm-with-compiler-errors", fallow_pcm_with_errors, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Accept a PCM file that was created with compiler errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.AllowPCMWithCompilerErrors, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-fallow-pch-with-compiler-errors", fallow_pch_with_errors, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Accept a PCH file that was created with compiler errors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->AllowPCHWithCompilerErrors, false, false || FrontendOpts.AllowPCMWithCompilerErrors, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-fallow-pch-with-different-modules-cache-path", fallow_pch_with_different_modules_cache_path, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Accept a PCH file that was created with a different modules cache path", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->AllowPCHWithDifferentModulesCachePath, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef FRONTEND_OPTION_WITH_MARSHALLING
FRONTEND_OPTION_WITH_MARSHALLING(prefix_1, "-fno-modules-share-filemanager", fno_modules_share_filemanager, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable sharing the FileManager when building a module implicitly", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, FrontendOpts.ModulesShareFileManager, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // FRONTEND_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-dump-deserialized-decls", dump_deserialized_pch_decls, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Dump declarations that are deserialized from PCH, for testing", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->DumpDeserializedPCHDecls, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-static-define", static_define, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Should __STATIC__ be defined", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Static, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-stack-protector", stack_protector, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable stack protectors", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "0,1,2,3", true, 0, LangOpts->StackProtector, LangOptions::SSPOff, false, LangOptions::SSPOff, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 51)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-stack-protector-buffer-size", stack_protector_buffer_size, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Lower bound for a buffer to be considered for stack protection", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.SSPBufferSize, 8, false, 8, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ftype-visibility=", ftype_visibility, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Default type visibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "default,hidden,internal,protected", true, 0, LangOpts->TypeVisibilityMode, LangOpts->ValueVisibilityMode, false, LangOpts->ValueVisibilityMode, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 52)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fapply-global-visibility-to-externs", fapply_global_visibility_to_externs, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Apply global symbol visibility to external declarations without an explicit visibility", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SetVisibilityForExternDecls, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fbracket-depth", fbracket_depth, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Maximum nesting level for parentheses, brackets, and braces", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->BracketDepth, 256, false, 256, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fconst-strings", fconst_strings, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use a const qualified type for string literals in C and ObjC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ConstStrings, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_const_strings), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-const-strings", fno_const_strings, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't use a const qualified type for string literals in C and ObjC", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ConstStrings, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fconst_strings), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-bitfield-type-align", fno_bitfield_type_align, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Ignore bit-field types when aligning structures", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoBitFieldTypeAlign, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-ffake-address-space-map", ffake_address_space_map, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use a fake address space map; OpenCL testing purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->FakeAddressSpaceMap, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-faddress-space-map-mangling=", faddress_space_map_mangling_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set the mode for address space map based mangling; OpenCL testing purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "target,no,yes", true, 0, LangOpts->AddressSpaceMapMangling, LangOptions::ASMM_Target, false, LangOptions::ASMM_Target, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 53)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-funknown-anytype", funknown_anytype, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable parser support for the __unknown_anytype type; for testing purposes only", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->ParseUnknownAnytype, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdebugger-support", fdebugger_support, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable special debugger support behavior", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DebuggerSupport, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdebugger-cast-result-to-id", fdebugger_cast_result_to_id, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable casting unknown expression results to id", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DebuggerCastResultToId, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdebugger-objc-literal", fdebugger_objc_literal, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable special debugger support for Objective-C subscripting and literals", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->DebuggerObjCLiteral, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdeprecated-macro", fdeprecated_macro, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Defines the __DEPRECATED macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Deprecated, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_deprecated_macro), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-deprecated-macro", fno_deprecated_macro, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Undefines the __DEPRECATED macro", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->Deprecated, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdeprecated_macro), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-vtordisp-mode=", vtordisp_mode_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Control vtordisp placement on win32 targets", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->VtorDispMode, 1, false, 1, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fnative-half-type", fnative_half_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the native half type for __fp16 instead of promoting to float", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NativeHalfType, false, false || LangOpts->OpenCL || LangOpts->RenderScript, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fnative-half-arguments-and-returns", fnative_half_arguments_and_returns, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NativeHalfArgsAndReturns, false, false || LangOpts->OpenCL || LangOpts->RenderScript || LangOpts->HLSL, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fdefault-calling-conv=", fdefault_calling_conv_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set default calling convention", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "cdecl,fastcall,stdcall,vectorcall,regcall,rtdcall", true, 0, LangOpts->DefaultCallingConv, LangOptions::DCC_None, false, LangOptions::DCC_None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 54)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fhlsl-strict-availability", fhlsl_strict_availability, Flag, hlsl_Group, INVALID, nullptr, 0, CC1Option | DefaultVis, 0,
       "Enables strict availability diagnostic mode for HLSL built-in functions.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->HLSLStrictAvailability, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpreserve-vec3-type", fpreserve_vec3_type, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Preserve 3-component vector type", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PreserveVec3Type, false, false || LangOpts->HLSL, true, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fwchar-type=", fwchar_type_EQ, Joined, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Select underlying type for wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "char,short,int", true, 0, LangOpts->WCharSize, 0, false, 0, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 55)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-signed-wchar", fno_signed_wchar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use an unsigned type for wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->WCharIsSigned, true, false, true, makeBooleanOptionNormalizer(false, true, OPT_fsigned_wchar), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsigned-wchar", fsigned_wchar, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Use a signed type for wchar_t", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->WCharIsSigned, true, false, true, makeBooleanOptionNormalizer(true, false, OPT_fno_signed_wchar), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcompatibility-qualified-id-block-type-checking", fcompatibility_qualified_id_block_param_type_checking, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Allow using blocks with parameters of more specific type than the type system guarantees when a parameter is qualified id", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fpass-by-value-is-noalias", fpass_by_value_is_noalias, Flag, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Allows assuming by-value parameters do not alias any other value. Has no effect on non-trivially-copyable classes in C++.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.PassByValueIsNoAlias, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fexperimental-max-bitint-width=", fexperimental_max_bitint_width_EQ, Joined, f_Group, INVALID, nullptr, 0, CC1Option, 0,
       "Set the maximum bitwidth for _BitInt (this option is expected to be removed in the future)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), "<N>", nullptr, true, 0, LangOpts->MaxBitIntWidth, 0, false, 0, normalizeStringIntegral<unsigned>, denormalizeString<unsigned>, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-nostdsysteminc", nostdsysteminc, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable standard system #include directories", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->UseStandardSystemIncludes, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fdisable-module-hash", fdisable_module_hash, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable the module hash", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->DisableModuleHash, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-hash-content", fmodules_hash_content, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable hashing the content of a module file", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesHashContent, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef HEADER_SEARCH_OPTION_WITH_MARSHALLING
HEADER_SEARCH_OPTION_WITH_MARSHALLING(prefix_1, "-fmodules-strict-context-hash", fmodules_strict_context_hash, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Enable hashing of all compiler options that could impact the semantics of a module in an implicit build", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, HeaderSearchOpts->ModulesStrictContextHash, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // HEADER_SEARCH_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-detailed-preprocessing-record", detailed_preprocessing_record, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "include a detailed record of preprocessing actions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->DetailedRecord, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-setup-static-analyzer", setup_static_analyzer, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Set up preprocessor for static analyzer (done automatically when static analyzer is run).", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->SetUpStaticAnalyzer, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef PREPROCESSOR_OPTION_WITH_MARSHALLING
PREPROCESSOR_OPTION_WITH_MARSHALLING(prefix_1, "-disable-pragma-debug-crash", disable_pragma_debug_crash, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Disable any #pragma clang __debug that can lead to crashing behavior. This is meant for testing.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, PreprocessorOpts->DisablePragmaDebugCrash, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // PREPROCESSOR_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcuda-is-device", fcuda_is_device, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate code for CUDA device", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CUDAIsDevice, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fcuda-include-gpubinary", fcuda_include_gpubinary, Separate, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Incorporate CUDA device-side binary into host object file.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.CudaGpuBinaryFileName, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fcuda-allow-variadic-functions", fcuda_allow_variadic_functions, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Allow variadic functions in CUDA device code.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CUDAAllowVariadicFunctions, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-cuda-host-device-constexpr", fno_cuda_host_device_constexpr, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Don't treat unattributed constexpr functions as __host__ __device__.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->CUDAHostDeviceConstexpr, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsycl-is-device", fsycl_is_device, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "Generate code for SYCL device.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SYCLIsDevice, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fsycl-is-host", fsycl_is_host, Flag, INVALID, INVALID, nullptr, 0, CC1Option, 0,
       "SYCL host compilation", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->SYCLIsHost, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-sycl-std=", sycl_std_EQ, Joined, sycl_Group, INVALID, nullptr, NoArgumentUnused, DefaultVis | CC1Option | CLOption, 0,
       "SYCL language standard to compile for.", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, "2020,2017,121,1.2.1,sycl-1.2.1", LangOpts->SYCLIsDevice||LangOpts->SYCLIsHost, 0, LangOpts->SYCLVersion, LangOptions::SYCL_None, false, LangOptions::SYCL_None, normalizeSimpleEnum, denormalizeSimpleEnum, mergeForwardValue, extractForwardValue, 56)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fgpu-approx-transcendentals", fgpu_approx_transcendentals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DefaultVis, 0,
       "Use approximate transcendental functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPUDeviceApproxTranscendentals, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_gpu_approx_transcendentals), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_1, "-fno-gpu-approx-transcendentals", fno_gpu_approx_transcendentals, Flag, f_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis, 0,
       "Don't use approximate transcendental functions", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->GPUDeviceApproxTranscendentals, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fgpu_approx_transcendentals), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fdebug-pass-manager", fdebug_pass_manager, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Prints debug information for the new pass manager", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugPassManager, false, false, false, makeBooleanOptionNormalizer(true, false, OPT_fno_debug_pass_manager), makeBooleanOptionDenormalizer(true), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-fno-debug-pass-manager", fno_debug_pass_manager, Flag, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "Disables debug printing for the new pass manager", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.DebugPassManager, false, false, false, makeBooleanOptionNormalizer(false, true, OPT_fdebug_pass_manager), makeBooleanOptionDenormalizer(false), mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef CODEGEN_OPTION_WITH_MARSHALLING
CODEGEN_OPTION_WITH_MARSHALLING(prefix_1, "-opt-record-file", opt_record_file, Separate, INVALID, INVALID, nullptr, 0, CC1Option | FC1Option, 0,
       "File name to use for YAML optimization record output", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, CodeGenOpts.OptRecordFile, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // CODEGEN_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_2, "/validator-version", dxil_validator_version, Separate, dxc_Group, INVALID, nullptr, HelpHidden, DXCOption | DefaultVis | CC1Option | DXCOption, 0,
       "Override validator version for module. Format: <major.minor>;Default: DXIL.dll version or current internal version", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->DxilValidatorVersion, std::string(), false, std::string(), normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef TARGET_OPTION_WITH_MARSHALLING
TARGET_OPTION_WITH_MARSHALLING(prefix_1, "-hlsl-entry", hlsl_entrypoint, Separate, dxc_Group, INVALID, nullptr, 0, DefaultVis | CC1Option | DXCOption, 0,
       "Entry point name for hlsl", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, TargetOpts->HLSLEntry, "main", false, "main", normalizeString, denormalizeString, mergeForwardValue, extractForwardValue, -1)
#endif // TARGET_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_3, "--no-wasm-opt", no_wasm_opt, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Disable the wasm-opt optimizer", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoWasmOpt, false, false, false, normalizeSimpleFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING
#ifdef LANG_OPTION_WITH_MARSHALLING
LANG_OPTION_WITH_MARSHALLING(prefix_3, "--wasm-opt", wasm_opt, Flag, m_Group, INVALID, nullptr, 0, DefaultVis | DefaultVis | CLOption, 0,
       "Enable the wasm-opt optimizer (default)", (std::array<std::pair<std::array<unsigned, 2>, const char*>, 1>{{ std::make_pair(std::array<unsigned, 2>{{0, 0}}, nullptr) }}), nullptr, nullptr, true, 0, LangOpts->NoWasmOpt, true, false, true, normalizeSimpleNegativeFlag, denormalizeSimpleFlag, mergeForwardValue, extractForwardValue, -1)
#endif // LANG_OPTION_WITH_MARSHALLING

#ifdef SIMPLE_ENUM_VALUE_TABLE

struct SimpleEnumValue {
  const char *Name;
  unsigned Value;
};

struct SimpleEnumValueTable {
  const SimpleEnumValue *Table;
  unsigned Size;
};
static const SimpleEnumValue complex_range_EQValueTable[] = {
{"full",static_cast<unsigned>(LangOptions::CX_Full)},{"improved",static_cast<unsigned>(LangOptions::CX_Improved)},{"promoted",static_cast<unsigned>(LangOptions::CX_Promoted)},{"basic",static_cast<unsigned>(LangOptions::CX_Basic)},};
static const SimpleEnumValue fgpu_default_stream_EQValueTable[] = {
{"legacy",static_cast<unsigned>(LangOptions::GPUDefaultStreamKind::Legacy)},{"per-thread",static_cast<unsigned>(LangOptions::GPUDefaultStreamKind::PerThread)},};
static const SimpleEnumValue mprintf_kind_EQValueTable[] = {
{"hostcall",static_cast<unsigned>(TargetOptions::AMDGPUPrintfKind::Hostcall)},{"buffered",static_cast<unsigned>(TargetOptions::AMDGPUPrintfKind::Buffered)},};
static const SimpleEnumValue fstrict_flex_arrays_EQValueTable[] = {
{"0",static_cast<unsigned>(LangOptions::StrictFlexArraysLevelKind::Default)},{"1",static_cast<unsigned>(LangOptions::StrictFlexArraysLevelKind::OneZeroOrIncomplete)},{"2",static_cast<unsigned>(LangOptions::StrictFlexArraysLevelKind::ZeroOrIncomplete)},{"3",static_cast<unsigned>(LangOptions::StrictFlexArraysLevelKind::IncompleteOnly)},};
static const SimpleEnumValue fembed_bitcode_EQValueTable[] = {
{"off",static_cast<unsigned>(CodeGenOptions::Embed_Off)},{"all",static_cast<unsigned>(CodeGenOptions::Embed_All)},{"bitcode",static_cast<unsigned>(CodeGenOptions::Embed_Bitcode)},{"marker",static_cast<unsigned>(CodeGenOptions::Embed_Marker)},};
static const SimpleEnumValue fswift_async_fp_EQValueTable[] = {
{"auto",static_cast<unsigned>(CodeGenOptions::SwiftAsyncFramePointerKind::Auto)},{"always",static_cast<unsigned>(CodeGenOptions::SwiftAsyncFramePointerKind::Always)},{"never",static_cast<unsigned>(CodeGenOptions::SwiftAsyncFramePointerKind::Never)},};
static const SimpleEnumValue fcf_runtime_abi_EQValueTable[] = {
{"unspecified",static_cast<unsigned>(LangOptions::CoreFoundationABI::ObjectiveC)},{"standalone",static_cast<unsigned>(LangOptions::CoreFoundationABI::ObjectiveC)},{"objc",static_cast<unsigned>(LangOptions::CoreFoundationABI::ObjectiveC)},{"swift",static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift5_0)},{"swift-5.0",static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift5_0)},{"swift-4.2",static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift4_2)},{"swift-4.1",static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift4_1)},};
static const SimpleEnumValue exception_modelValueTable[] = {
{"dwarf",static_cast<unsigned>(LangOptions::ExceptionHandlingKind::DwarfCFI)},{"sjlj",static_cast<unsigned>(LangOptions::ExceptionHandlingKind::SjLj)},{"seh",static_cast<unsigned>(LangOptions::ExceptionHandlingKind::WinEH)},{"wasm",static_cast<unsigned>(LangOptions::ExceptionHandlingKind::Wasm)},};
static const SimpleEnumValue ffloat16_excess_precision_EQValueTable[] = {
{"standard",static_cast<unsigned>(LangOptions::FPP_Standard)},{"fast",static_cast<unsigned>(LangOptions::FPP_Fast)},{"none",static_cast<unsigned>(LangOptions::FPP_None)},};
static const SimpleEnumValue fbfloat16_excess_precision_EQValueTable[] = {
{"standard",static_cast<unsigned>(LangOptions::FPP_Standard)},{"fast",static_cast<unsigned>(LangOptions::FPP_Fast)},{"none",static_cast<unsigned>(LangOptions::FPP_None)},};
static const SimpleEnumValue ffp_eval_method_EQValueTable[] = {
{"source",static_cast<unsigned>(LangOptions::FEM_Source)},{"double",static_cast<unsigned>(LangOptions::FEM_Double)},{"extended",static_cast<unsigned>(LangOptions::FEM_Extended)},};
static const SimpleEnumValue ffp_exception_behavior_EQValueTable[] = {
{"ignore",static_cast<unsigned>(LangOptions::FPE_Ignore)},{"maytrap",static_cast<unsigned>(LangOptions::FPE_MayTrap)},{"strict",static_cast<unsigned>(LangOptions::FPE_Strict)},};
static const SimpleEnumValue fextend_args_EQValueTable[] = {
{"32",static_cast<unsigned>(LangOptions::ExtendArgsKind::ExtendTo32)},{"64",static_cast<unsigned>(LangOptions::ExtendArgsKind::ExtendTo64)},};
static const SimpleEnumValue sanitize_address_use_after_return_EQValueTable[] = {
{"never",static_cast<unsigned>(llvm::AsanDetectStackUseAfterReturnMode::Never)},{"runtime",static_cast<unsigned>(llvm::AsanDetectStackUseAfterReturnMode::Runtime)},{"always",static_cast<unsigned>(llvm::AsanDetectStackUseAfterReturnMode::Always)},};
static const SimpleEnumValue sanitize_address_destructor_EQValueTable[] = {
{"none",static_cast<unsigned>(llvm::AsanDtorKind::None)},{"global",static_cast<unsigned>(llvm::AsanDtorKind::Global)},};
static const SimpleEnumValue mfunction_return_EQValueTable[] = {
{"keep",static_cast<unsigned>(llvm::FunctionReturnThunksKind::Keep)},{"thunk-extern",static_cast<unsigned>(llvm::FunctionReturnThunksKind::Extern)},};
static const SimpleEnumValue flax_vector_conversions_EQValueTable[] = {
{"none",static_cast<unsigned>(LangOptions::LaxVectorConversionKind::None)},{"integer",static_cast<unsigned>(LangOptions::LaxVectorConversionKind::Integer)},{"all",static_cast<unsigned>(LangOptions::LaxVectorConversionKind::All)},};
static const SimpleEnumValue fms_memptr_rep_EQValueTable[] = {
{"single",static_cast<unsigned>(LangOptions::PPTMK_FullGeneralitySingleInheritance)},{"multiple",static_cast<unsigned>(LangOptions::PPTMK_FullGeneralityMultipleInheritance)},{"virtual",static_cast<unsigned>(LangOptions::PPTMK_FullGeneralityVirtualInheritance)},};
static const SimpleEnumValue fveclibValueTable[] = {
{"Accelerate",static_cast<unsigned>(llvm::driver::VectorLibrary::Accelerate)},{"libmvec",static_cast<unsigned>(llvm::driver::VectorLibrary::LIBMVEC)},{"MASSV",static_cast<unsigned>(llvm::driver::VectorLibrary::MASSV)},{"SVML",static_cast<unsigned>(llvm::driver::VectorLibrary::SVML)},{"SLEEF",static_cast<unsigned>(llvm::driver::VectorLibrary::SLEEF)},{"Darwin_libsystem_m",static_cast<unsigned>(llvm::driver::VectorLibrary::Darwin_libsystem_m)},{"ArmPL",static_cast<unsigned>(llvm::driver::VectorLibrary::ArmPL)},{"AMDLIBM",static_cast<unsigned>(llvm::driver::VectorLibrary::AMDLIBM)},{"none",static_cast<unsigned>(llvm::driver::VectorLibrary::NoLibrary)},};
static const SimpleEnumValue fshow_overloads_EQValueTable[] = {
{"best",static_cast<unsigned>(Ovl_Best)},{"all",static_cast<unsigned>(Ovl_All)},};
static const SimpleEnumValue ftrivial_auto_var_initValueTable[] = {
{"uninitialized",static_cast<unsigned>(LangOptions::TrivialAutoVarInitKind::Uninitialized)},{"zero",static_cast<unsigned>(LangOptions::TrivialAutoVarInitKind::Zero)},{"pattern",static_cast<unsigned>(LangOptions::TrivialAutoVarInitKind::Pattern)},};
static const SimpleEnumValue ftlsmodel_EQValueTable[] = {
{"global-dynamic",static_cast<unsigned>(CodeGenOptions::GeneralDynamicTLSModel)},{"local-dynamic",static_cast<unsigned>(CodeGenOptions::LocalDynamicTLSModel)},{"initial-exec",static_cast<unsigned>(CodeGenOptions::InitialExecTLSModel)},{"local-exec",static_cast<unsigned>(CodeGenOptions::LocalExecTLSModel)},};
static const SimpleEnumValue fvisibility_dllexport_EQValueTable[] = {
{"keep",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Keep)},{"hidden",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Hidden)},{"protected",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Protected)},{"default",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Default)},};
static const SimpleEnumValue fvisibility_nodllstorageclass_EQValueTable[] = {
{"keep",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Keep)},{"hidden",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Hidden)},{"protected",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Protected)},{"default",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Default)},};
static const SimpleEnumValue fvisibility_externs_dllimport_EQValueTable[] = {
{"keep",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Keep)},{"hidden",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Hidden)},{"protected",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Protected)},{"default",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Default)},};
static const SimpleEnumValue fvisibility_externs_nodllstorageclass_EQValueTable[] = {
{"keep",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Keep)},{"hidden",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Hidden)},{"protected",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Protected)},{"default",static_cast<unsigned>(LangOptions::VisibilityFromDLLStorageClassKinds::Default)},};
static const SimpleEnumValue fvisibility_EQValueTable[] = {
{"default",static_cast<unsigned>(DefaultVisibility)},{"hidden",static_cast<unsigned>(HiddenVisibility)},{"internal",static_cast<unsigned>(HiddenVisibility)},{"protected",static_cast<unsigned>(ProtectedVisibility)},};
static const SimpleEnumValue fvisibility_global_new_delete_EQValueTable[] = {
{"force-default",static_cast<unsigned>(LangOptions::VisibilityForcedKinds::ForceDefault)},{"force-protected",static_cast<unsigned>(LangOptions::VisibilityForcedKinds::ForceProtected)},{"force-hidden",static_cast<unsigned>(LangOptions::VisibilityForcedKinds::ForceHidden)},{"source",static_cast<unsigned>(LangOptions::VisibilityForcedKinds::Source)},};
static const SimpleEnumValue mdefault_visibility_export_mapping_EQValueTable[] = {
{"none",static_cast<unsigned>(LangOptions::DefaultVisiblityExportMapping::None)},{"explicit",static_cast<unsigned>(LangOptions::DefaultVisiblityExportMapping::Explicit)},{"all",static_cast<unsigned>(LangOptions::DefaultVisiblityExportMapping::All)},};
static const SimpleEnumValue fzero_call_used_regs_EQValueTable[] = {
{"skip",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip)},{"used-gpr-arg",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedGPRArg)},{"used-gpr",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedGPR)},{"used-arg",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedArg)},{"used",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Used)},{"all-gpr-arg",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::AllGPRArg)},{"all-gpr",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::AllGPR)},{"all-arg",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::AllArg)},{"all",static_cast<unsigned>(llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::All)},};
static const SimpleEnumValue femit_dwarf_unwind_EQValueTable[] = {
{"always",static_cast<unsigned>(llvm::EmitDwarfUnwindType::Always)},{"no-compact-unwind",static_cast<unsigned>(llvm::EmitDwarfUnwindType::NoCompactUnwind)},{"default",static_cast<unsigned>(llvm::EmitDwarfUnwindType::Default)},};
static const SimpleEnumValue gsrc_hash_EQValueTable[] = {
{"md5",static_cast<unsigned>(CodeGenOptions::DSH_MD5)},{"sha1",static_cast<unsigned>(CodeGenOptions::DSH_SHA1)},{"sha256",static_cast<unsigned>(CodeGenOptions::DSH_SHA256)},};
static const SimpleEnumValue inline_asm_EQValueTable[] = {
{"att",static_cast<unsigned>(CodeGenOptions::IAD_ATT)},{"intel",static_cast<unsigned>(CodeGenOptions::IAD_Intel)},};
static const SimpleEnumValue mthread_modelValueTable[] = {
{"posix",static_cast<unsigned>(LangOptions::ThreadModelKind::POSIX)},{"single",static_cast<unsigned>(LangOptions::ThreadModelKind::Single)},};
static const SimpleEnumValue meabiValueTable[] = {
{"default",static_cast<unsigned>(llvm::EABI::Default)},{"4",static_cast<unsigned>(llvm::EABI::EABI4)},{"5",static_cast<unsigned>(llvm::EABI::EABI5)},{"gnu",static_cast<unsigned>(llvm::EABI::GNU)},};
static const SimpleEnumValue mcode_object_version_EQValueTable[] = {
{"none",static_cast<unsigned>(llvm::CodeObjectVersionKind::COV_None)},{"4",static_cast<unsigned>(llvm::CodeObjectVersionKind::COV_4)},{"5",static_cast<unsigned>(llvm::CodeObjectVersionKind::COV_5)},{"6",static_cast<unsigned>(llvm::CodeObjectVersionKind::COV_6)},};
static const SimpleEnumValue altivec_src_compatValueTable[] = {
{"mixed",static_cast<unsigned>(LangOptions::AltivecSrcCompatKind::Mixed)},{"gcc",static_cast<unsigned>(LangOptions::AltivecSrcCompatKind::GCC)},{"xl",static_cast<unsigned>(LangOptions::AltivecSrcCompatKind::XL)},};
static const SimpleEnumValue analyzer_config_compatibility_modeValueTable[] = {
{"true",static_cast<unsigned>(false)},{"false",static_cast<unsigned>(true)},};
static const SimpleEnumValue mrelocation_modelValueTable[] = {
{"static",static_cast<unsigned>(llvm::Reloc::Static)},{"pic",static_cast<unsigned>(llvm::Reloc::PIC_)},{"ropi",static_cast<unsigned>(llvm::Reloc::ROPI)},{"rwpi",static_cast<unsigned>(llvm::Reloc::RWPI)},{"ropi-rwpi",static_cast<unsigned>(llvm::Reloc::ROPI_RWPI)},{"dynamic-no-pic",static_cast<unsigned>(llvm::Reloc::DynamicNoPIC)},};
static const SimpleEnumValue debugger_tuning_EQValueTable[] = {
{"gdb",static_cast<unsigned>(llvm::DebuggerKind::GDB)},{"lldb",static_cast<unsigned>(llvm::DebuggerKind::LLDB)},{"sce",static_cast<unsigned>(llvm::DebuggerKind::SCE)},{"dbx",static_cast<unsigned>(llvm::DebuggerKind::DBX)},};
static const SimpleEnumValue compress_debug_sections_EQValueTable[] = {
{"none",static_cast<unsigned>(llvm::DebugCompressionType::None)},{"zlib",static_cast<unsigned>(llvm::DebugCompressionType::Zlib)},{"zstd",static_cast<unsigned>(llvm::DebugCompressionType::Zstd)},};
static const SimpleEnumValue fprofile_instrument_EQValueTable[] = {
{"none",static_cast<unsigned>(CodeGenOptions::ProfileNone)},{"clang",static_cast<unsigned>(CodeGenOptions::ProfileClangInstr)},{"llvm",static_cast<unsigned>(CodeGenOptions::ProfileIRInstr)},{"csllvm",static_cast<unsigned>(CodeGenOptions::ProfileCSIRInstr)},};
static const SimpleEnumValue fexperimental_assignment_tracking_EQValueTable[] = {
{"disabled",static_cast<unsigned>(CodeGenOptions::AssignmentTrackingOpts::Disabled)},{"enabled",static_cast<unsigned>(CodeGenOptions::AssignmentTrackingOpts::Enabled)},{"forced",static_cast<unsigned>(CodeGenOptions::AssignmentTrackingOpts::Forced)},};
static const SimpleEnumValue header_include_format_EQValueTable[] = {
{"textual",static_cast<unsigned>(HIFMT_Textual)},{"json",static_cast<unsigned>(HIFMT_JSON)},};
static const SimpleEnumValue header_include_filtering_EQValueTable[] = {
{"none",static_cast<unsigned>(HIFIL_None)},{"only-direct-system",static_cast<unsigned>(HIFIL_Only_Direct_System)},};
static const SimpleEnumValue fdiagnostics_formatValueTable[] = {
{"clang",static_cast<unsigned>(DiagnosticOptions::Clang)},{"msvc",static_cast<unsigned>(DiagnosticOptions::MSVC)},{"vi",static_cast<unsigned>(DiagnosticOptions::Vi)},{"sarif",static_cast<unsigned>(DiagnosticOptions::SARIF)},{"SARIF",static_cast<unsigned>(DiagnosticOptions::SARIF)},};
static const SimpleEnumValue fdiagnostics_show_categoryValueTable[] = {
{"none",static_cast<unsigned>(0)},{"id",static_cast<unsigned>(1)},{"name",static_cast<unsigned>(2)},};
static const SimpleEnumValue arcmt_action_EQValueTable[] = {
{"check",static_cast<unsigned>(FrontendOptions::ARCMT_Check)},{"modify",static_cast<unsigned>(FrontendOptions::ARCMT_Modify)},{"migrate",static_cast<unsigned>(FrontendOptions::ARCMT_Migrate)},};
static const SimpleEnumValue mframe_pointer_EQValueTable[] = {
{"all",static_cast<unsigned>(CodeGenOptions::FramePointerKind::All)},{"non-leaf",static_cast<unsigned>(CodeGenOptions::FramePointerKind::NonLeaf)},{"reserved",static_cast<unsigned>(CodeGenOptions::FramePointerKind::Reserved)},{"none",static_cast<unsigned>(CodeGenOptions::FramePointerKind::None)},};
static const SimpleEnumValue fobjc_arc_cxxlib_EQValueTable[] = {
{"libc++",static_cast<unsigned>(ARCXX_libcxx)},{"libstdc++",static_cast<unsigned>(ARCXX_libstdcxx)},{"none",static_cast<unsigned>(ARCXX_nolib)},};
static const SimpleEnumValue fobjc_dispatch_method_EQValueTable[] = {
{"legacy",static_cast<unsigned>(CodeGenOptions::Legacy)},{"non-legacy",static_cast<unsigned>(CodeGenOptions::NonLegacy)},{"mixed",static_cast<unsigned>(CodeGenOptions::Mixed)},};
static const SimpleEnumValue stack_protectorValueTable[] = {
{"0",static_cast<unsigned>(LangOptions::SSPOff)},{"1",static_cast<unsigned>(LangOptions::SSPOn)},{"2",static_cast<unsigned>(LangOptions::SSPStrong)},{"3",static_cast<unsigned>(LangOptions::SSPReq)},};
static const SimpleEnumValue ftype_visibilityValueTable[] = {
{"default",static_cast<unsigned>(DefaultVisibility)},{"hidden",static_cast<unsigned>(HiddenVisibility)},{"internal",static_cast<unsigned>(HiddenVisibility)},{"protected",static_cast<unsigned>(ProtectedVisibility)},};
static const SimpleEnumValue faddress_space_map_mangling_EQValueTable[] = {
{"target",static_cast<unsigned>(LangOptions::ASMM_Target)},{"no",static_cast<unsigned>(LangOptions::ASMM_Off)},{"yes",static_cast<unsigned>(LangOptions::ASMM_On)},};
static const SimpleEnumValue fdefault_calling_conv_EQValueTable[] = {
{"cdecl",static_cast<unsigned>(LangOptions::DCC_CDecl)},{"fastcall",static_cast<unsigned>(LangOptions::DCC_FastCall)},{"stdcall",static_cast<unsigned>(LangOptions::DCC_StdCall)},{"vectorcall",static_cast<unsigned>(LangOptions::DCC_VectorCall)},{"regcall",static_cast<unsigned>(LangOptions::DCC_RegCall)},{"rtdcall",static_cast<unsigned>(LangOptions::DCC_RtdCall)},};
static const SimpleEnumValue fwchar_type_EQValueTable[] = {
{"char",static_cast<unsigned>(1)},{"short",static_cast<unsigned>(2)},{"int",static_cast<unsigned>(4)},};
static const SimpleEnumValue sycl_std_EQValueTable[] = {
{"2020",static_cast<unsigned>(LangOptions::SYCL_2020)},{"2017",static_cast<unsigned>(LangOptions::SYCL_2017)},{"121",static_cast<unsigned>(LangOptions::SYCL_2017)},{"1.2.1",static_cast<unsigned>(LangOptions::SYCL_2017)},{"sycl-1.2.1",static_cast<unsigned>(LangOptions::SYCL_2017)},};
static const SimpleEnumValueTable SimpleEnumValueTables[] = {{complex_range_EQValueTable, std::size(complex_range_EQValueTable)},
{fgpu_default_stream_EQValueTable, std::size(fgpu_default_stream_EQValueTable)},
{mprintf_kind_EQValueTable, std::size(mprintf_kind_EQValueTable)},
{fstrict_flex_arrays_EQValueTable, std::size(fstrict_flex_arrays_EQValueTable)},
{fembed_bitcode_EQValueTable, std::size(fembed_bitcode_EQValueTable)},
{fswift_async_fp_EQValueTable, std::size(fswift_async_fp_EQValueTable)},
{fcf_runtime_abi_EQValueTable, std::size(fcf_runtime_abi_EQValueTable)},
{exception_modelValueTable, std::size(exception_modelValueTable)},
{ffloat16_excess_precision_EQValueTable, std::size(ffloat16_excess_precision_EQValueTable)},
{fbfloat16_excess_precision_EQValueTable, std::size(fbfloat16_excess_precision_EQValueTable)},
{ffp_eval_method_EQValueTable, std::size(ffp_eval_method_EQValueTable)},
{ffp_exception_behavior_EQValueTable, std::size(ffp_exception_behavior_EQValueTable)},
{fextend_args_EQValueTable, std::size(fextend_args_EQValueTable)},
{sanitize_address_use_after_return_EQValueTable, std::size(sanitize_address_use_after_return_EQValueTable)},
{sanitize_address_destructor_EQValueTable, std::size(sanitize_address_destructor_EQValueTable)},
{mfunction_return_EQValueTable, std::size(mfunction_return_EQValueTable)},
{flax_vector_conversions_EQValueTable, std::size(flax_vector_conversions_EQValueTable)},
{fms_memptr_rep_EQValueTable, std::size(fms_memptr_rep_EQValueTable)},
{fveclibValueTable, std::size(fveclibValueTable)},
{fshow_overloads_EQValueTable, std::size(fshow_overloads_EQValueTable)},
{ftrivial_auto_var_initValueTable, std::size(ftrivial_auto_var_initValueTable)},
{ftlsmodel_EQValueTable, std::size(ftlsmodel_EQValueTable)},
{fvisibility_dllexport_EQValueTable, std::size(fvisibility_dllexport_EQValueTable)},
{fvisibility_nodllstorageclass_EQValueTable, std::size(fvisibility_nodllstorageclass_EQValueTable)},
{fvisibility_externs_dllimport_EQValueTable, std::size(fvisibility_externs_dllimport_EQValueTable)},
{fvisibility_externs_nodllstorageclass_EQValueTable, std::size(fvisibility_externs_nodllstorageclass_EQValueTable)},
{fvisibility_EQValueTable, std::size(fvisibility_EQValueTable)},
{fvisibility_global_new_delete_EQValueTable, std::size(fvisibility_global_new_delete_EQValueTable)},
{mdefault_visibility_export_mapping_EQValueTable, std::size(mdefault_visibility_export_mapping_EQValueTable)},
{fzero_call_used_regs_EQValueTable, std::size(fzero_call_used_regs_EQValueTable)},
{femit_dwarf_unwind_EQValueTable, std::size(femit_dwarf_unwind_EQValueTable)},
{gsrc_hash_EQValueTable, std::size(gsrc_hash_EQValueTable)},
{inline_asm_EQValueTable, std::size(inline_asm_EQValueTable)},
{mthread_modelValueTable, std::size(mthread_modelValueTable)},
{meabiValueTable, std::size(meabiValueTable)},
{mcode_object_version_EQValueTable, std::size(mcode_object_version_EQValueTable)},
{altivec_src_compatValueTable, std::size(altivec_src_compatValueTable)},
{analyzer_config_compatibility_modeValueTable, std::size(analyzer_config_compatibility_modeValueTable)},
{mrelocation_modelValueTable, std::size(mrelocation_modelValueTable)},
{debugger_tuning_EQValueTable, std::size(debugger_tuning_EQValueTable)},
{compress_debug_sections_EQValueTable, std::size(compress_debug_sections_EQValueTable)},
{fprofile_instrument_EQValueTable, std::size(fprofile_instrument_EQValueTable)},
{fexperimental_assignment_tracking_EQValueTable, std::size(fexperimental_assignment_tracking_EQValueTable)},
{header_include_format_EQValueTable, std::size(header_include_format_EQValueTable)},
{header_include_filtering_EQValueTable, std::size(header_include_filtering_EQValueTable)},
{fdiagnostics_formatValueTable, std::size(fdiagnostics_formatValueTable)},
{fdiagnostics_show_categoryValueTable, std::size(fdiagnostics_show_categoryValueTable)},
{arcmt_action_EQValueTable, std::size(arcmt_action_EQValueTable)},
{mframe_pointer_EQValueTable, std::size(mframe_pointer_EQValueTable)},
{fobjc_arc_cxxlib_EQValueTable, std::size(fobjc_arc_cxxlib_EQValueTable)},
{fobjc_dispatch_method_EQValueTable, std::size(fobjc_dispatch_method_EQValueTable)},
{stack_protectorValueTable, std::size(stack_protectorValueTable)},
{ftype_visibilityValueTable, std::size(ftype_visibilityValueTable)},
{faddress_space_map_mangling_EQValueTable, std::size(faddress_space_map_mangling_EQValueTable)},
{fdefault_calling_conv_EQValueTable, std::size(fdefault_calling_conv_EQValueTable)},
{fwchar_type_EQValueTable, std::size(fwchar_type_EQValueTable)},
{sycl_std_EQValueTable, std::size(sycl_std_EQValueTable)},
};
static const unsigned SimpleEnumValueTablesSize = std::size(SimpleEnumValueTables);
#endif // SIMPLE_ENUM_VALUE_TABLE


