dang created this revision.
dang added a reviewer: Bigcheese.
Herald added subscribers: cfe-commits, dexonsmith.
Herald added a project: clang.
Depends on D83698 <https://reviews.llvm.org/D83698>
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D83892
Files:
clang/include/clang/Driver/Options.td
clang/lib/Frontend/CompilerInvocation.cpp
Index: clang/lib/Frontend/CompilerInvocation.cpp
===================================================================
--- clang/lib/Frontend/CompilerInvocation.cpp
+++ clang/lib/Frontend/CompilerInvocation.cpp
@@ -293,6 +293,7 @@
CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
+ CodeGenOpts.DisableFree = FrontendOpts.DisableFree;
FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex;
llvm::sys::Process::UseANSIEscapeCodes(DiagOpts.UseANSIEscapeCodes);
@@ -830,10 +831,6 @@
}
}
- Opts.DebugPassManager =
- Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
- /* Default */ false);
-
if (Arg *A = Args.getLastArg(OPT_fveclib)) {
StringRef Name = A->getValue();
if (Name == "Accelerate")
@@ -876,23 +873,9 @@
Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
}
Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
- Opts.DebugColumnInfo = !Args.hasArg(OPT_gno_column_info);
- Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
- Opts.CodeViewGHash = Args.hasArg(OPT_gcodeview_ghash);
- Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro);
- Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
- Opts.VirtualFunctionElimination =
- Args.hasArg(OPT_fvirtual_function_elimination);
- Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
Opts.SplitDwarfFile = std::string(Args.getLastArgValue(OPT_split_dwarf_file));
Opts.SplitDwarfOutput =
std::string(Args.getLastArgValue(OPT_split_dwarf_output));
- Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
- Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
- Opts.DebugExplicitImport = Args.hasArg(OPT_dwarf_explicit_import);
- Opts.DebugFwdTemplateParams = Args.hasArg(OPT_debug_forward_template_params);
- Opts.EmbedSource = Args.hasArg(OPT_gembed_source);
- Opts.ForceDwarfFrameSection = Args.hasArg(OPT_fforce_dwarf_frame);
for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
auto Split = StringRef(Arg).split('=');
@@ -900,16 +883,9 @@
{std::string(Split.first), std::string(Split.second)});
}
- if (const Arg *A =
- Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
- Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
-
- Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
- Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
-
const llvm::Triple::ArchType DebugEntryValueArchs[] = {
- llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
- llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
+ llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
+ llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
llvm::Triple T(TargetOpts.Triple);
@@ -917,27 +893,12 @@
llvm::is_contained(DebugEntryValueArchs, T.getArch()))
Opts.EmitCallSiteInfo = true;
- Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
- Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
- Opts.IndirectTlsSegRefs = Args.hasArg(OPT_mno_tls_direct_seg_refs);
- Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
- Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
- OPT_fuse_register_sized_bitfield_access);
- Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
- Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
Args.hasArg(OPT_new_struct_path_tbaa);
- Opts.FineGrainedBitfieldAccesses =
- Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
- OPT_fno_fine_grained_bitfield_accesses, false);
Opts.DwarfDebugFlags =
std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
Opts.RecordCommandLine =
std::string(Args.getLastArgValue(OPT_record_command_line));
- Opts.MergeAllConstants = Args.hasArg(OPT_fmerge_all_constants);
- Opts.NoCommon = !Args.hasArg(OPT_fcommon);
- Opts.NoInlineLineTables = Args.hasArg(OPT_gno_inline_line_tables);
- Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
Opts.OptimizeSize = getOptimizationLevelSize(Args);
Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
Args.hasArg(OPT_ffreestanding));
@@ -946,21 +907,15 @@
Opts.UnrollLoops =
Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
(Opts.OptimizationLevel > 1));
- Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
- Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
- Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
Opts.SampleProfileFile =
std::string(Args.getLastArgValue(OPT_fprofile_sample_use_EQ));
- Opts.DebugInfoForProfiling = Args.hasFlag(
- OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
Opts.DebugNameTable = static_cast<unsigned>(
Args.hasArg(OPT_ggnu_pubnames)
? llvm::DICompileUnit::DebugNameTableKind::GNU
: Args.hasArg(OPT_gpubnames)
? llvm::DICompileUnit::DebugNameTableKind::Default
: llvm::DICompileUnit::DebugNameTableKind::None);
- Opts.DebugRangesBaseAddress = Args.hasArg(OPT_fdebug_ranges_base_address);
setPGOInstrumentor(Opts, Args, Diags);
Opts.InstrProfileOutput =
@@ -977,17 +932,6 @@
<< "-fexperimental-new-pass-manager";
}
- Opts.CoverageMapping =
- Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
- Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
- Opts.AsmVerbose = !Args.hasArg(OPT_fno_verbose_asm);
- Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
- Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
- Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
- Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
- Opts.RegisterGlobalDtorsWithAtExit =
- Args.hasArg(OPT_fregister_global_dtors_with_atexit);
- Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
Opts.CodeModel = TargetOpts.CodeModel;
Opts.DebugPass = std::string(Args.getLastArgValue(OPT_mdebug_pass));
@@ -1011,40 +955,14 @@
Opts.setFramePointer(FP);
}
- Opts.DisableFree = Args.hasArg(OPT_disable_free);
- Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
- Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
- Opts.NoEscapingBlockTailCalls =
- Args.hasArg(OPT_fno_escaping_block_tail_calls);
Opts.FloatABI = std::string(Args.getLastArgValue(OPT_mfloat_abi));
Opts.LimitFloatPrecision =
std::string(Args.getLastArgValue(OPT_mlimit_float_precision));
Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
- Opts.StrictFloatCastOverflow =
- !Args.hasArg(OPT_fno_strict_float_cast_overflow);
- Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_fno_zero_initialized_in_bss);
Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
- Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
Opts.SmallDataLimit =
getLastArgIntValue(Args, OPT_msmall_data_limit, 0, Diags);
- Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
- Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
- Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
- Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
- Opts.IncrementalLinkerCompatible =
- Args.hasArg(OPT_mincremental_linker_compatible);
- Opts.PIECopyRelocations =
- Args.hasArg(OPT_mpie_copy_relocations);
- Opts.NoPLT = Args.hasArg(OPT_fno_plt);
- Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
- Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
- Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
- Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
- Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
- Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
- Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
- Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
Opts.ThreadModel =
std::string(Args.getLastArgValue(OPT_mthread_model, "posix"));
if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
@@ -1052,7 +970,6 @@
<< Args.getLastArg(OPT_mthread_model)->getAsString(Args)
<< Opts.ThreadModel;
Opts.TrapFuncName = std::string(Args.getLastArgValue(OPT_ftrap_function_EQ));
- Opts.UseInitArray = !Args.hasArg(OPT_fno_use_init_array);
Opts.BBSections =
std::string(Args.getLastArgValue(OPT_fbasic_block_sections_EQ, "none"));
@@ -1062,22 +979,6 @@
Args.hasArg(OPT_ffunction_sections) ||
(Opts.BBSections != "none" && Opts.BBSections != "labels");
- Opts.DataSections = Args.hasArg(OPT_fdata_sections);
- Opts.StackSizeSection = Args.hasArg(OPT_fstack_size_section);
- Opts.UniqueSectionNames = !Args.hasArg(OPT_fno_unique_section_names);
- Opts.UniqueBasicBlockSectionNames =
- Args.hasArg(OPT_funique_basic_block_section_names);
- Opts.UniqueInternalLinkageNames =
- Args.hasArg(OPT_funique_internal_linkage_names);
-
- Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
-
- Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
-
- Opts.NullPointerIsValid = Args.hasArg(OPT_fno_delete_null_pointer_checks);
-
- Opts.ProfileSampleAccurate = Args.hasArg(OPT_fprofile_sample_accurate);
-
Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
Opts.PrepareForThinLTO = false;
if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
@@ -1087,8 +988,6 @@
else if (S != "full")
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
}
- Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
- Opts.EnableSplitLTOUnit = Args.hasArg(OPT_fsplit_lto_unit);
if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
if (IK.getLanguage() != Language::LLVM_IR)
Diags.Report(diag::err_drv_argument_only_allowed_with)
@@ -1105,23 +1004,11 @@
Opts.ThinLinkBitcodeFile =
std::string(Args.getLastArgValue(OPT_fthin_link_bitcode_EQ));
- Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
-
- Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
- Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
-
Opts.PreferVectorWidth =
std::string(Args.getLastArgValue(OPT_mprefer_vector_width_EQ));
Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
- Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
-
- Opts.ControlFlowGuardNoChecks = Args.hasArg(OPT_cfguard_no_checks);
- Opts.ControlFlowGuard = Args.hasArg(OPT_cfguard);
- Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
- Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
- Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
Opts.CoverageDataFile =
std::string(Args.getLastArgValue(OPT_coverage_data_file));
@@ -1182,13 +1069,6 @@
}
}
- Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
- Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
- Opts.InstrumentFunctionsAfterInlining =
- Args.hasArg(OPT_finstrument_functions_after_inlining);
- Opts.InstrumentFunctionEntryBare =
- Args.hasArg(OPT_finstrument_function_entry_bare);
-
Opts.XRayInstructionThreshold =
getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
@@ -1205,12 +1085,6 @@
getLastArgIntValue(Args, OPT_fpatchable_function_entry_EQ, 0, Diags);
Opts.PatchableFunctionEntryOffset = getLastArgIntValue(
Args, OPT_fpatchable_function_entry_offset_EQ, 0, Diags);
- Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
- Opts.CallFEntry = Args.hasArg(OPT_mfentry);
- Opts.MNopMCount = Args.hasArg(OPT_mnop_mcount);
- Opts.RecordMCount = Args.hasArg(OPT_mrecord_mcount);
- Opts.PackedStack = Args.hasArg(OPT_mpacked_stack);
- Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
StringRef Name = A->getValue();
@@ -1242,7 +1116,6 @@
}
}
- Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
Opts.DebugCompilationDir =
std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir));
for (auto *A :
@@ -1260,64 +1133,14 @@
}
Opts.SanitizeCoverageType =
getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
- Opts.SanitizeCoverageIndirectCalls =
- Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
- Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
- Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
- Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
- Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
- Opts.SanitizeCoverage8bitCounters =
- Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
- Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
- Opts.SanitizeCoverageTracePCGuard =
- Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
- Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
- Opts.SanitizeCoverageInline8bitCounters =
- Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
- Opts.SanitizeCoverageInlineBoolFlag =
- Args.hasArg(OPT_fsanitize_coverage_inline_bool_flag);
- Opts.SanitizeCoveragePCTable = Args.hasArg(OPT_fsanitize_coverage_pc_table);
- Opts.SanitizeCoverageStackDepth =
- Args.hasArg(OPT_fsanitize_coverage_stack_depth);
Opts.SanitizeCoverageAllowlistFiles =
Args.getAllArgValues(OPT_fsanitize_coverage_allowlist);
Opts.SanitizeCoverageBlocklistFiles =
Args.getAllArgValues(OPT_fsanitize_coverage_blocklist);
Opts.SanitizeMemoryTrackOrigins =
getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
- Opts.SanitizeMemoryUseAfterDtor =
- Args.hasFlag(OPT_fsanitize_memory_use_after_dtor,
- OPT_fno_sanitize_memory_use_after_dtor,
- false);
- Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime);
- Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
- Opts.SanitizeCfiICallGeneralizePointers =
- Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers);
- Opts.SanitizeCfiCanonicalJumpTables =
- Args.hasArg(OPT_fsanitize_cfi_canonical_jump_tables);
- Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
- if (Arg *A = Args.getLastArg(
- OPT_fsanitize_address_poison_custom_array_cookie,
- OPT_fno_sanitize_address_poison_custom_array_cookie)) {
- Opts.SanitizeAddressPoisonCustomArrayCookie =
- A->getOption().getID() ==
- OPT_fsanitize_address_poison_custom_array_cookie;
- }
- if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
- OPT_fno_sanitize_address_use_after_scope)) {
- Opts.SanitizeAddressUseAfterScope =
- A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
- }
- Opts.SanitizeAddressGlobalsDeadStripping =
- Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
- if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_odr_indicator,
- OPT_fno_sanitize_address_use_odr_indicator)) {
- Opts.SanitizeAddressUseOdrIndicator =
- A->getOption().getID() == OPT_fsanitize_address_use_odr_indicator;
- }
Opts.SSPBufferSize =
getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
- Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
StringRef Val = A->getValue();
unsigned StackAlignment = Opts.StackAlignment;
@@ -1332,10 +1155,6 @@
Opts.StackProbeSize = StackProbeSize;
}
- Opts.NoStackArgProbe = Args.hasArg(OPT_mno_stack_arg_probe);
-
- Opts.StackClashProtector = Args.hasArg(OPT_fstack_clash_protection);
-
if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
StringRef Name = A->getValue();
unsigned Method = llvm::StringSwitch<unsigned>(Name)
@@ -1352,10 +1171,6 @@
}
}
-
- if (Args.hasArg(OPT_fno_objc_convert_messages_to_runtime_calls))
- Opts.ObjCConvertMessagesToRuntimeCalls = 0;
-
if (Args.getLastArg(OPT_femulated_tls) ||
Args.getLastArg(OPT_fno_emulated_tls)) {
Opts.ExplicitEmulatedTLS = true;
@@ -1453,8 +1268,6 @@
NeedLocTracking = true;
}
- Opts.DiagnosticsWithHotness =
- Args.hasArg(options::OPT_fdiagnostics_show_hotness);
bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
bool UsingProfile = UsingSampleProfile ||
(Opts.getProfileUse() != CodeGenOptions::ProfileNone);
@@ -1496,19 +1309,9 @@
Opts.CudaGpuBinaryFileName =
std::string(Args.getLastArgValue(OPT_fcuda_include_gpubinary));
- Opts.Backchain = Args.hasArg(OPT_mbackchain);
-
Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
- Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
-
- Opts.Addrsig = Args.hasArg(OPT_faddrsig);
-
- Opts.KeepStaticConsts = Args.hasArg(OPT_fkeep_static_consts);
-
- Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening);
-
Opts.DefaultFunctionAttrs = Args.getAllArgValues(OPT_default_function_attr);
Opts.PassPlugins = Args.getAllArgValues(OPT_fpass_plugin_EQ);
@@ -1516,7 +1319,6 @@
Opts.SymbolPartition =
std::string(Args.getLastArgValue(OPT_fsymbol_partition_EQ));
- Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad);
return Success;
}
Index: clang/include/clang/Driver/Options.td
===================================================================
--- clang/include/clang/Driver/Options.td
+++ clang/include/clang/Driver/Options.td
@@ -577,6 +577,469 @@
} // Flags = [CC1Option, CC1AsOption, NoDriverOption]
+// CodeGen Options
+
+def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>,
+ HelpText<"Do not emit metadata containing compiler name and version">;
+def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>,
+ HelpText<"Emit metadata containing compiler name and version">,
+ MarshallingInfoBooleanFlag<"CodeGenOpts.EmitVersionIdentMetadata", "true", Qn>;
+def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>,
+ MarshallingInfoString<"CodeGenOpts.OptimizationLevel", "llvm::CodeGenOpt::Default">,
+ AlwaysEmit, Denormalizer<"denormalizeOptimizationLevel">;
+def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_Group>, Flags<[CC1Option]>,
+ HelpText<"OpenCL only. Generate kernel argument metadata.">,
+ MarshallingInfoFlag<"CodeGenOpts.EmitOpenCLArgMetadata", "false">;
+def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC1Option]>,
+ HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">,
+ MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD", "false">;
+def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
+ HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">,
+ MarshallingInfoFlag<"CodeGenOpts.CorrectlyRoundedDivSqrt", "false">;
+def cl_uniform_work_group_size : Flag<["-"], "cl-uniform-work-group-size">, Group<opencl_Group>, Flags<[CC1Option]>,
+ HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">,
+ MarshallingInfoFlag<"CodeGenOpts.UniformWGSize", "false">;
+
+def fautolink : Flag<["-"], "fautolink">, Group<f_Group>;
+def fno_autolink : Flag<["-"], "fno-autolink">, Flags<[CC1Option]>, Group<f_Group>,
+ HelpText<"Disable generation of linker directives for automatic library linking">,
+ MarshallingInfoFlag<"CodeGenOpts.Autolink", "true">, IsNegative;
+def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">,
+ Group<f_Group>, Flags<[DriverOption, CC1Option]>,
+ HelpText<"Specifies that the sample profile is accurate">,
+ DocBrief<[{Specifies that the sample profile is accurate. If the sample
+ profile is accurate, callsites without profile samples are marked
+ as cold. Otherwise, treat callsites without profile samples as if
+ we have no profile}]>,
+ MarshallingInfoFlag<"CodeGenOpts.ProfileSampleAccurate", "false">;
+defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling",
+ "Emit extra debug info to make sample profile more accurate", "", "", [], "CodeGenOpts.DebugInfoForProfiling">;
+defm coverage_mapping : OptInFFlag<"coverage-mapping",
+ "Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "",
+ [CoreOption], "CodeGenOpts.CoverageMapping">;
+defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption], "CodeGenOpts.Addrsig">;
+def fcommon : Flag<["-"], "fcommon">, Group<f_Group>,
+ Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">,
+ MarshallingInfoFlag<"CodeGenOpts.NoCommon", "true">, IsNegative;
+defm diagnostics_show_hotness : OptInFFlag<"diagnostics-show-hotness",
+ "Enable profile hotness information in diagnostic line", "", "", [], "CodeGenOpts.DiagnosticsWithHotness">;
+defm dwarf_directory_asm : OptOutFFlag<"dwarf-directory-asm", "", "", "", [], "CodeGenOpts.NoDwarfDirectoryAsm">;
+defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused",
+ [DriverOption], "CodeGenOpts.KeepStaticConsts">;
+defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches", [], "CodeGenOpts.NoUseJumpTables">;
+
+let Flags = [CC1Option, CoreOption] in {
+
+defm sanitize_memory_use_after_dtor : BooleanMarshalledFFlag<"sanitize-memory-use-after-dtor", "CodeGenOpts.SanitizeMemoryUseAfterDtor", "false",
+ "Enable use-after-destroy detection in MemorySanitizer", "Disable use-after-destroy detection in MemorySanitizer">,
+ Group<f_clang_Group>;
+def fno_sanitize_address_use_after_scope : Flag<["-"], "fno-sanitize-address-use-after-scope">,
+ Group<f_clang_Group>, Flags<[CoreOption, DriverOption]>,
+ HelpText<"Disable use-after-scope detection in AddressSanitizer">;
+def fsanitize_address_use_after_scope : Flag<["-"], "fsanitize-address-use-after-scope">,
+ Group<f_clang_Group>, HelpText<"Enable use-after-scope detection in AddressSanitizer">,
+ MarshallingInfoBooleanFlag<"CodeGenOpts.SanitizeAddressUseAfterScope", "false", fno_sanitize_address_use_after_scope>;
+defm sanitize_address_poison_custom_array_cookie : BooleanMarshalledFFlag<"sanitize-address-poison-custom-array-cookie",
+ "CodeGenOpts.SanitizeAddressPoisonCustomArrayCookie", "false",
+ "Enable poisoning array cookies when using custom operator new[] in AddressSanitizer",
+ "Disable poisoning array cookies when using custom operator new[] in AddressSanitizer">,
+ Group<f_clang_Group>;
+def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">,
+ Group<f_clang_Group>, HelpText<"Enable linker dead stripping of globals in AddressSanitizer">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeAddressGlobalsDeadStripping", "false">;
+defm sanitize_address_use_odr_indicator: BooleanMarshalledFFlag<"sanitize-address-use-odr-indicator",
+ "CodeGenOpts.SanitizeAddressUseOdrIndicator", "false",
+ "Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size",
+ "Disable ODR indicator globals">,
+ Group<f_clang_Group>;
+def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">,
+ Group<f_clang_Group>, MarshallingInfoFlag<"CodeGenOpts.SanitizeMinimalRuntime", "false">;
+def fsanitize_cfi_cross_dso : Flag<["-"], "fsanitize-cfi-cross-dso">,
+ Group<f_clang_Group>,
+ HelpText<"Enable control flow integrity (CFI) checks for cross-DSO calls.">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCrossDso", "false">;
+def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">,
+ Group<f_clang_Group>, HelpText<"Generalize pointers in CFI indirect call type signature checks">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiICallGeneralizePointers", "false">;
+def fsanitize_cfi_canonical_jump_tables : Flag<["-"], "fsanitize-cfi-canonical-jump-tables">,
+ Group<f_clang_Group>, HelpText<"Make the jump table addresses canonical in the symbol table">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCfiCanonicalJumpTables", "false">;
+def fsanitize_stats : Flag<["-"], "fsanitize-stats">,
+ Group<f_clang_Group>, HelpText<"Enable sanitizer statistics gathering.">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeStats", "false">;
+
+} // Flags = [CC1Option, CoreOption]
+
+def fstrict_float_cast_overflow : Flag<["-"], "fstrict-float-cast-overflow">, Group<f_Group>,
+ HelpText<"Assume that overflowing float-to-int casts are undefined (default)">;
+def fno_strict_float_cast_overflow : Flag<["-"], "fno-strict-float-cast-overflow">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions">,
+ MarshallingInfoFlag<"CodeGenOpts.StrictFloatCastOverflow", "true">, IsNegative;
+defm delete_null_pointer_checks : OptOutFFlag<"delete-null-pointer-checks",
+ "Treat usage of null pointers as undefined behavior (default)",
+ "Do not treat usage of null pointers as undefined behavior", "", [], "CodeGenOpts.NullPointerIsValid">;
+defm experimental_new_pass_manager : BooleanMarshalledFFlag<"experimental-new-pass-manager", "CodeGenOpts.ExperimentalNewPassManager",
+ "static_cast<unsigned>(ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER)", "Enables an experimental new pass manager in LLVM.",
+ "Disables an experimental new pass manager in LLVM.">, Group<f_clang_Group>, Flags<[CC1Option]>;
+def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Generate calls to instrument function entry and exit">,
+ MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctions", "false">;
+def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Like -finstrument-functions, but insert the calls after inlining">,
+ MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionsAfterInlining", "false">;
+def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">,
+ MarshallingInfoFlag<"CodeGenOpts.InstrumentFunctionEntryBare", "false">;
+defm xray_ignore_loops : OptInFFlag<"xray-ignore-loops",
+ "Don't instrument functions with loops unless they also meet the minimum function size", "", "", [], "CodeGenOpts.XRayIgnoreLoops">;
+defm xray_function_index : OptOutFFlag<"xray-function-index", "",
+ "Omit function index section at the expense of single-function patching performance", "", [], "CodeGenOpts.XRayOmitFunctionIndex">;
+defm fine_grained_bitfield_accesses : BooleanMarshalledFFlag<"fine-grained-bitfield-accesses",
+ "CodeGenOpts.FineGrainedBitfieldAccesses", "false",
+ "Use separate accesses for consecutive bitfield runs with legal widths and alignments.",
+ "Use large-integer access for consecutive bitfield runs.">, Group<f_clang_Group>, Flags<[CC1Option]>;
+def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>,
+ Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">,
+ MarshallingInfoFlag<"CodeGenOpts.MergeAllConstants", "false">;
+def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
+ HelpText<"Disallow merging of constants">;
+def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.MSVolatile", "false">;
+def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>,
+ HelpText<"Don't assume that C++'s global operator new can't alias any pointer">,
+ Flags<[CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.AssumeSaneOperatorNew", "true">, IsNegative;
+def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
+def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Don't use __cxa_atexit for calling destructors">,
+ MarshallingInfoFlag<"CodeGenOpts.CXAAtExit", "true">, IsNegative;
+defm register_global_dtors_with_atexit : OptInFFlag<"register-global-dtors-with-atexit", "Use", "Don't use",
+ " atexit or __cxa_atexit to register global destructors", [], "CodeGenOpts.RegisterGlobalDtorsWithAtExit">;
+def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.AsmVerbose", "true">, IsNegative;
+def fobjc_convert_messages_to_runtime_calls :
+ Flag<["-"], "fobjc-convert-messages-to-runtime-calls">, Group<f_Group>;
+def fno_objc_convert_messages_to_runtime_calls :
+ Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.ObjCConvertMessagesToRuntimeCalls", "true">, IsNegative;
+defm objc_arc_exceptions : OptInFFlag<"objc-arc-exceptions",
+ "Use EH-safe code when synthesizing retains and releases in -fobjc-arc",
+ "", "", [], "CodeGenOpts.ObjCAutoRefCountExceptions">;
+defm escaping_block_tail_calls : OptOutFFlag<"escaping-block-tail-calls", "", "", "", [], "CodeGenOpts.NoEscapingBlockTailCalls">;
+defm plt : OptOutFFlag<"plt", "",
+ "Use GOT indirection instead of PLT to make external function calls (x86 only)", "", [], "CodeGenOpts.NoPLT">;
+def fpreserve_as_comments : Flag<["-"], "fpreserve-as-comments">, Group<f_Group>;
+def fno_preserve_as_comments : Flag<["-"], "fno-preserve-as-comments">, Flags<[CC1Option]>, Group<f_Group>,
+ HelpText<"Do not preserve comments in inline assembly">,
+ MarshallingInfoFlag<"CodeGenOpts.PreserveAsmComments", "true">, IsNegative;
+def fstack_clash_protection : Flag<["-"], "fstack-clash-protection">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Enable stack clash protection">,
+ MarshallingInfoFlag<"CodeGenOpts.StackClashProtector", "false">;
+def fnostack_clash_protection : Flag<["-"], "fnostack-clash-protection">, Group<f_Group>,
+ HelpText<"Disable stack clash protection">;
+def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Enable optimizations based on the strict definition of an enum's "
+ "value range">,
+ MarshallingInfoFlag<"CodeGenOpts.StrictEnums", "false">;
+defm strict_vtable_pointers : OptInFFlag<"strict-vtable-pointers",
+ "Enable optimizations based on the strict rules for overwriting polymorphic C++ objects",
+ "", "", [], "CodeGenOpts.StrictVTablePointers">;
+defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller", "", "", [], "CodeGenOpts.RerollLoops">;
+def fuse_init_array : Flag<["-"], "fuse-init-array">, Group<f_Group>;
+def fno_use_init_array : Flag<["-"], "fno-use-init-array">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Use .ctors/.dtors instead of .init_array/.fini_array">,
+ MarshallingInfoFlag<"CodeGenOpts.UseInitArray", "true">, IsNegative;
+defm whole_program_vtables : OptInFFlag<"whole-program-vtables",
+ "Enables whole-program vtable optimization. Requires -flto", "", "", [CoreOption], "CodeGenOpts.WholeProgramVTables">;
+defm split_lto_unit : OptInFFlag<"split-lto-unit",
+ "Enables splitting of the LTO unit", "", "", [CoreOption], "CodeGenOpts.EnableSplitLTOUnit">;
+defm force_emit_vtables : OptInFFlag<"force-emit-vtables",
+ "Emits more virtual tables to improve devirtualization", "", "", [CoreOption], "CodeGenOpts.ForceEmitVTables">;
+defm virtual_function_elimination : OptInFFlag<"virtual-function-elimination",
+ "Enables dead virtual function elimination optimization. Requires -flto=full", "", "", [CoreOption], "CodeGenOpts.VirtualFunctionElimination">;
+defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS",
+ "", [], "CodeGenOpts.NoZeroInitializedInBSS">;
+defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section", "", "", [], "CodeGenOpts.DataSections">;
+defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes",
+ "", "", [], "CodeGenOpts.StackSizeSection">;
+defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names",
+ "Use unique names for basic block sections (ELF Only)", "", "", [], "CodeGenOpts.UniqueBasicBlockSectionNames">;
+defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names",
+ "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path", "", "", [], "CodeGenOpts.UniqueInternalLinkageNames">;
+def funique_section_names : Flag<["-"], "funique-section-names">, Group<f_Group>;
+def fno_unique_section_names : Flag<["-"], "fno-unique-section-names">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Don't use unique names for text and data sections">,
+ MarshallingInfoFlag<"CodeGenOpts.UniqueSectionNames", "true">, IsNegative;
+def fstrict_return : Flag<["-"], "fstrict-return">, Group<f_Group>;
+def fno_strict_return : Flag<["-"], "fno-strict-return">, Group<f_Group>, Flags<[CC1Option]>,
+ HelpText<"Don't treat control flow paths that fall off the end of a non-void function as unreachable">,
+ MarshallingInfoFlag<"CodeGenOpts.StrictReturn", "true">, IsNegative;
+defm debug_ranges_base_address : OptInFFlag<"debug-ranges-base-address",
+ "Use DWARF base address selection entries in .debug_ranges", "", "", [], "CodeGenOpts.DebugRangesBaseAddress">;
+def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, Group<f_Group>,
+ HelpText<"Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF">;
+def fno_split_dwarf_inlining: Flag<["-"], "fno-split-dwarf-inlining">, Group<f_Group>,
+ Flags<[CC1Option]>, MarshallingInfoFlag<"CodeGenOpts.SplitDwarfInlining", "true">, IsNegative;
+defm force_dwarf_frame : OptInFFlag<"force-dwarf-frame", "Always emit a debug frame section", "", "", [], "CodeGenOpts.ForceDwarfFrameSection">;
+def gcodeview : Flag<["-"], "gcodeview">,
+ HelpText<"Generate CodeView debug information">,
+ Flags<[CC1Option, CC1AsOption, CoreOption]>,
+ MarshallingInfoFlag<"CodeGenOpts.EmitCodeView", "false">;
+def gcodeview_ghash : Flag<["-"], "gcodeview-ghash">,
+ HelpText<"Emit type record hashes in a .debug$H section">,
+ Flags<[CC1Option, CoreOption]>,
+ MarshallingInfoFlag<"CodeGenOpts.CodeViewGHash", "false">;
+def gno_inline_line_tables : Flag<["-"], "gno-inline-line-tables">,
+ Flags<[CC1Option, CoreOption]>, HelpText<"Don't emit inline line tables">,
+ MarshallingInfoFlag<"CodeGenOpts.NoInlineLineTables", "false">;
+def gno_column_info : Flag<["-"], "gno-column-info">, Group<g_flags_Group>, Flags<[CoreOption, CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.DebugColumnInfo", "true">, IsNegative;
+def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>, Flags<[CC1Option]>,
+ HelpText<"Embed source text in DWARF debug sections">,
+ MarshallingInfoFlag<"CodeGenOpts.EmbedSource", "false">;
+def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>,
+ HelpText<"Force realign the stack at entry to every function">,
+ MarshallingInfoFlag<"CodeGenOpts.StackRealignment", "false">;
+def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>,
+ HelpText<"Disable stack probes which are enabled by default">,
+ MarshallingInfoFlag<"CodeGenOpts.NoStackArgProbe", "false">;
+def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group<m_Group>, Flags<[CC1Option]>,
+ HelpText<"Disable direct TLS access through segment registers">,
+ MarshallingInfoFlag<"CodeGenOpts.IndirectTlsSegRefs", "false">;
+def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">,
+ Group<m_Group>, Flags<[CoreOption,CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.SpeculativeLoadHardening", "false">;
+def ForceAAPCSBitfieldLoad : Flag<["-"], "fAAPCSBitfieldLoad">, Group<m_arm_Features_Group>,
+ Flags<[DriverOption,CC1Option]>,
+ HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">,
+ MarshallingInfoFlag<"CodeGenOpts.ForceAAPCSBitfieldLoad", "false">;
+def mbackchain : Flag<["-"], "mbackchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
+ HelpText<"Link stack frames through backchain on System Z">,
+ MarshallingInfoFlag<"CodeGenOpts.Backchain", "false">;
+def mno_backchain : Flag<["-"], "mno-backchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>;
+def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>,
+ HelpText<"(integrated-as) Relax all machine instructions">,
+ MarshallingInfoFlag<"CodeGenOpts.RelaxAll", "false">;
+def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group<m_Group>,
+ Flags<[CC1Option,CC1AsOption]>,
+ HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">,
+ MarshallingInfoFlag<"CodeGenOpts.IncrementalLinkerCompatible", "false">;
+def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>,
+ HelpText<"Use software floating point">,
+ MarshallingInfoFlag<"CodeGenOpts.SoftFloat", "false">;
+def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>,
+ Flags<[CC1Option]>,
+ HelpText<"Use copy relocations support for PIE builds">,
+ MarshallingInfoFlag<"CodeGenOpts.PIECopyRelocations", "false">;
+def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86/SystemZ only)">,
+ Flags<[CC1Option]>, Group<m_Group>,
+ MarshallingInfoFlag<"CodeGenOpts.CallFEntry", "false">;
+def mnop_mcount : Flag<["-"], "mnop-mcount">, HelpText<"Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.">,
+ Flags<[CC1Option]>, Group<m_Group>,
+ MarshallingInfoFlag<"CodeGenOpts.MNopMCount", "false">;
+def mrecord_mcount : Flag<["-"], "mrecord-mcount">, HelpText<"Generate a __mcount_loc section entry for each __fentry__ call.">,
+ Flags<[CC1Option]>, Group<m_Group>,
+ MarshallingInfoFlag<"CodeGenOpts.RecordMCount", "false">;
+def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">,
+ Flags<[CC1Option]>, Group<m_Group>,
+ MarshallingInfoFlag<"CodeGenOpts.PackedStack", "false">;
+def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"CodeGenOpts.InstrumentForProfiling", "false">;
+defm integrated_as : OptOutFFlag<"integrated-as", "Enable", "Disable", " the integrated assembler", [], "CodeGenOpts.DisableIntegratedAS">;
+
+let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
+
+def debug_info_macro : Flag<["-"], "debug-info-macro">,
+ HelpText<"Emit macro debug information">,
+ MarshallingInfoFlag<"CodeGenOpts.MacroDebugInfo", "false">;
+def mno_exec_stack : Flag<["-"], "mnoexecstack">,
+ HelpText<"Mark the file as not needing an executable stack">,
+ MarshallingInfoFlag<"CodeGenOpts.NoExecStack", "false">;
+def massembler_no_warn : Flag<["-"], "massembler-no-warn">,
+ HelpText<"Make assembler not emit warnings">,
+ MarshallingInfoFlag<"CodeGenOpts.NoWarn", "false">;
+def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
+ HelpText<"Make assembler warnings fatal">,
+ MarshallingInfoFlag<"CodeGenOpts.FatalWarnings", "false">;
+def mrelax_relocations : Flag<["--"], "mrelax-relocations">,
+ HelpText<"Use relaxable elf relocations">,
+ MarshallingInfoFlag<"CodeGenOpts.RelaxELFRelocations", "false">;
+def msave_temp_labels : Flag<["-"], "msave-temp-labels">,
+ HelpText<"Save temporary labels in the symbol table. "
+ "Note this may change .s semantics and shouldn't generally be used "
+ "on compiler-generated code.">,
+ MarshallingInfoFlag<"CodeGenOpts.SaveTempLabels", "false">;
+def mrelocation_model : Separate<["-"], "mrelocation-model">,
+ HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
+ NormalizedValuesScope<"llvm::Reloc">,
+ NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
+ MarshallingInfoString<"CodeGenOpts.RelocationModel", "PIC_">,
+ AutoNormalizeEnum;
+
+} // Flags = [CC1Option, CC1AsOption, NoDriverOption]
+
+let Flags = [CC1Option, NoDriverOption] in {
+
+def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">,
+ HelpText<"Don't run the LLVM IR verifier pass">,
+ MarshallingInfoFlag<"CodeGenOpts.VerifyModule", "true">, IsNegative;
+def disable_llvm_passes : Flag<["-"], "disable-llvm-passes">,
+ HelpText<"Use together with -emit-llvm to get pristine LLVM IR from the "
+ "frontend by not running any LLVM passes at all">,
+ MarshallingInfoFlag<"CodeGenOpts.DisableLLVMPasses", "false">;
+def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">,
+ Alias<disable_llvm_passes>;
+def disable_lifetimemarkers : Flag<["-"], "disable-lifetime-markers">,
+ HelpText<"Disable lifetime-markers emission even when optimizations are "
+ "enabled">,
+ MarshallingInfoFlag<"CodeGenOpts.DisableLifetimeMarkers", "false">;
+def disable_O0_optnone : Flag<["-"], "disable-O0-optnone">,
+ HelpText<"Disable adding the optnone attribute to functions at O0">,
+ MarshallingInfoFlag<"CodeGenOpts.DisableO0ImplyOptNone", "false">;
+def disable_red_zone : Flag<["-"], "disable-red-zone">,
+ HelpText<"Do not emit code that uses the red zone.">,
+ MarshallingInfoFlag<"CodeGenOpts.DisableRedZone", "false">;
+def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">,
+ HelpText<"Generate debug info with external references to clang modules"
+ " or precompiled headers">,
+ MarshallingInfoFlag<"CodeGenOpts.DebugTypeExtRefs", "false">;
+def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">,
+ HelpText<"Generate explicit import from anonymous namespace to containing"
+ " scope">,
+ MarshallingInfoFlag<"CodeGenOpts.DebugExplicitImport", "false">;
+def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">,
+ HelpText<"Emit complete descriptions of template parameters in forward"
+ " declarations">,
+ MarshallingInfoFlag<"CodeGenOpts.DebugFwdTemplateParams", "false">;
+def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">,
+ HelpText<"Emit an error if a C++ static local initializer would need a guard variable">,
+ MarshallingInfoFlag<"CodeGenOpts.ForbidGuardVariables", "false">;
+def no_implicit_float : Flag<["-"], "no-implicit-float">,
+ HelpText<"Don't generate implicit floating point instructions">,
+ MarshallingInfoFlag<"CodeGenOpts.NoImplicitFloat", "false">;
+def fmerge_functions : Flag<["-"], "fmerge-functions">,
+ HelpText<"Permit merging of identical functions when optimizing.">,
+ MarshallingInfoFlag<"CodeGenOpts.MergeFunctions", "false">;
+def femit_coverage_notes : Flag<["-"], "femit-coverage-notes">,
+ HelpText<"Emit a gcov coverage notes file when compiling.">,
+ MarshallingInfoFlag<"CodeGenOpts.EmitGcovNotes", "false">;
+def femit_coverage_data: Flag<["-"], "femit-coverage-data">,
+ HelpText<"Instrument the program to emit gcov coverage data when run.">,
+ MarshallingInfoFlag<"CodeGenOpts.EmitGcovArcs", "false">;
+def test_coverage : Flag<["-"], "test-coverage">,
+ HelpText<"Do not generate coverage files or remove coverage changes from IR">,
+ MarshallingInfoFlag<"CodeGenOpts.DisableGCov", "false">;
+def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">,
+ HelpText<"Dump the coverage mapping records, for testing">,
+ MarshallingInfoFlag<"CodeGenOpts.DumpCoverageMapping", "false">;
+def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">,
+ HelpText<"Use register sized accesses to bit-fields, when possible.">,
+ MarshallingInfoFlag<"CodeGenOpts.UseRegisterSizedBitfieldAccess", "false">;
+def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">,
+ HelpText<"Turn off Type Based Alias Analysis">,
+ MarshallingInfoFlag<"CodeGenOpts.RelaxedAliasing", "false">;
+def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">,
+ HelpText<"Turn off struct-path aware Type Based Alias Analysis">,
+ MarshallingInfoFlag<"CodeGenOpts.StructPathTBAA", "true">, IsNegative;
+def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">,
+ HelpText<"Disable tail call optimization, keeping the call stack accurate">,
+ MarshallingInfoFlag<"CodeGenOpts.DisableTailCalls", "false">;
+def split_stacks : Flag<["-"], "split-stacks">,
+ HelpText<"Try to use a split stack if possible.">,
+ MarshallingInfoFlag<"CodeGenOpts.EnableSegmentedStacks", "false">;
+def munwind_tables : Flag<["-"], "munwind-tables">,
+ HelpText<"Generate unwinding tables for all functions">,
+ MarshallingInfoFlag<"CodeGenOpts.UnwindTables", "false">;
+def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">,
+ HelpText<"Emit complete constructors and destructors as aliases when possible">,
+ MarshallingInfoFlag<"CodeGenOpts.CXXCtorDtorAliases", "false">;
+def vectorize_loops : Flag<["-"], "vectorize-loops">,
+ HelpText<"Run the Loop vectorization passes">,
+ MarshallingInfoFlag<"CodeGenOpts.VectorizeLoop", "false">;
+def vectorize_slp : Flag<["-"], "vectorize-slp">,
+ HelpText<"Run the SLP vectorization passes">,
+ MarshallingInfoFlag<"CodeGenOpts.VectorizeSLP", "false">;
+def fsanitize_coverage_indirect_calls
+ : Flag<["-"], "fsanitize-coverage-indirect-calls">,
+ HelpText<"Enable sanitizer coverage for indirect calls">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageIndirectCalls", "false">;
+def fsanitize_coverage_trace_bb
+ : Flag<["-"], "fsanitize-coverage-trace-bb">,
+ HelpText<"Enable basic block tracing in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceBB", "false">;
+def fsanitize_coverage_trace_cmp
+ : Flag<["-"], "fsanitize-coverage-trace-cmp">,
+ HelpText<"Enable cmp instruction tracing in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceCmp", "false">;
+def fsanitize_coverage_trace_div
+ : Flag<["-"], "fsanitize-coverage-trace-div">,
+ HelpText<"Enable div instruction tracing in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceDiv", "false">;
+def fsanitize_coverage_trace_gep
+ : Flag<["-"], "fsanitize-coverage-trace-gep">,
+ HelpText<"Enable gep instruction tracing in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTraceGep", "false">;
+def fsanitize_coverage_8bit_counters
+ : Flag<["-"], "fsanitize-coverage-8bit-counters">,
+ HelpText<"Enable frequency counters in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverage8bitCounters", "false">;
+def fsanitize_coverage_inline_8bit_counters
+ : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">,
+ HelpText<"Enable inline 8-bit counters in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInline8bitCounters", "false">;
+def fsanitize_coverage_inline_bool_flag
+ : Flag<["-"], "fsanitize-coverage-inline-bool-flag">,
+ HelpText<"Enable inline bool flag in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageInlineBoolFlag", "false">;
+def fsanitize_coverage_pc_table
+ : Flag<["-"], "fsanitize-coverage-pc-table">,
+ HelpText<"Create a table of coverage-instrumented PCs">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoveragePCTable", "false">;
+def fsanitize_coverage_trace_pc
+ : Flag<["-"], "fsanitize-coverage-trace-pc">,
+ HelpText<"Enable PC tracing in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePC", "false">;
+def fsanitize_coverage_trace_pc_guard
+ : Flag<["-"], "fsanitize-coverage-trace-pc-guard">,
+ HelpText<"Enable PC tracing with guard in sanitizer coverage">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageTracePCGuard", "false">;
+def fsanitize_coverage_no_prune
+ : Flag<["-"], "fsanitize-coverage-no-prune">,
+ HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageNoPrune", "false">;
+def fsanitize_coverage_stack_depth
+ : Flag<["-"], "fsanitize-coverage-stack-depth">,
+ HelpText<"Enable max stack depth tracing">,
+ MarshallingInfoFlag<"CodeGenOpts.SanitizeCoverageStackDepth", "false">;
+def flto_visibility_public_std:
+ Flag<["-"], "flto-visibility-public-std">,
+ HelpText<"Use public LTO visibility for classes in std and stdext namespaces">,
+ MarshallingInfoFlag<"CodeGenOpts.LTOVisibilityPublicStd", "false">;
+defm lto_unit : BooleanMarshalledFFlag<"lto-unit", "CodeGenOpts.LTOUnit", "false",
+ "Emit IR to support LTO unit features (CFI, whole program vtable opt)">;
+defm debug_pass_manager : BooleanMarshalledFFlag<"debug-pass-manager", "CodeGenOpts.DebugPassManager",
+ "false", "Prints debug information for the new pass manager",
+ "Disables debug information for the new pass manager">;
+def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">,
+ HelpText<"Emit Windows Control Flow Guard tables only (no checks)">,
+ MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks", "false">;
+def cfguard : Flag<["-"], "cfguard">,
+ HelpText<"Emit Windows Control Flow Guard tables and checks">,
+ MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuard", "false">;
+def discard_value_names : Flag<["-"], "discard-value-names">,
+ HelpText<"Discard value names in LLVM IR">,
+ MarshallingInfoFlag<"CodeGenOpts.DiscardValueNames", "false">;
+def no_emit_llvm_uselists : Flag<["-"], "no-emit-llvm-uselists">,
+ HelpText<"Don't preserve order of LLVM use-lists when serializing">;
+def emit_llvm_uselists : Flag<["-"], "emit-llvm-uselists">,
+ HelpText<"Preserve order of LLVM use-lists when serializing">,
+ MarshallingInfoBooleanFlag<"CodeGenOpts.EmitLLVMUseLists", "false", no_emit_llvm_uselists>;
+def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">,
+ HelpText<"Preserve 3-component vector type">,
+ MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type", "false">;
+
+} // Flags = [CC1Option, NoDriverOption]
+
// Standard Options
def _HASH_HASH_HASH : Flag<["-"], "###">, Flags<[DriverOption, CoreOption]>,
@@ -633,17 +1096,10 @@
HelpText<"Treat source input files as Objective-C++ inputs">;
def ObjC : Flag<["-"], "ObjC">, Flags<[DriverOption]>,
HelpText<"Treat source input files as Objective-C inputs">;
-def O : Joined<["-"], "O">, Group<O_Group>, Flags<[CC1Option]>,
- MarshallingInfoString<"CodeGenOpts.OptimizationLevel", "llvm::CodeGenOpt::Default">,
- AlwaysEmit, Denormalizer<"denormalizeOptimizationLevel">;
def O_flag : Flag<["-"], "O">, Flags<[CC1Option]>, Alias<O>, AliasArgs<["1"]>;
def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, Flags<[CC1Option]>;
def P : Flag<["-"], "P">, Flags<[CC1Option]>, Group<Preprocessor_Group>,
HelpText<"Disable linemarker output in -E mode">;
-def Qy : Flag<["-"], "Qy">, Flags<[CC1Option]>,
- HelpText<"Emit metadata containing compiler name and version">;
-def Qn : Flag<["-"], "Qn">, Flags<[CC1Option]>,
- HelpText<"Do not emit metadata containing compiler name and version">;
def : Flag<["-"], "fident">, Group<f_Group>, Alias<Qy>, Flags<[CC1Option]>;
def : Flag<["-"], "fno-ident">, Group<f_Group>, Alias<Qn>, Flags<[CC1Option]>;
def Qunused_arguments : Flag<["-"], "Qunused-arguments">, Flags<[DriverOption, CoreOption]>,
@@ -758,29 +1214,17 @@
MarshallingInfoFlag<"LangOpts->SinglePrecisionConstants", "false">;
def cl_finite_math_only : Flag<["-"], "cl-finite-math-only">, Group<opencl_Group>,
HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">;
-def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Generate kernel argument metadata.">,
- MarshallingInfoFlag<"CodeGenOpts.EmitOpenCLArgMetadata", "false">;
def cl_unsafe_math_optimizations : Flag<["-"], "cl-unsafe-math-optimizations">, Group<opencl_Group>,
HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.">;
def cl_fast_relaxed_math : Flag<["-"], "cl-fast-relaxed-math">, Group<opencl_Group>, Flags<[CC1Option]>,
HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.">,
MarshallingInfoFlag<"LangOpts->FastRelaxedMath", "false">;
-def cl_mad_enable : Flag<["-"], "cl-mad-enable">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">,
- MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD", "false">;
def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>,
HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">;
def cl_std_EQ : Joined<["-"], "cl-std=">, Group<opencl_Group>, Flags<[CC1Option]>,
HelpText<"OpenCL language standard to compile for.">, Values<"cl,CL,cl1.1,CL1.1,cl1.2,CL1.2,cl2.0,CL2.0,clc++,CLC++">;
def cl_denorms_are_zero : Flag<["-"], "cl-denorms-are-zero">, Group<opencl_Group>,
HelpText<"OpenCL only. Allow denormals to be flushed to zero.">;
-def cl_fp32_correctly_rounded_divide_sqrt : Flag<["-"], "cl-fp32-correctly-rounded-divide-sqrt">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">,
- MarshallingInfoFlag<"CodeGenOpts.CorrectlyRoundedDivSqrt", "false">;
-def cl_uniform_work_group_size : Flag<["-"], "cl-uniform-work-group-size">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">,
- MarshallingInfoFlag<"CodeGenOpts.UniformWGSize", "false">;
def client__name : JoinedOrSeparate<["-"], "client_name">;
def combine : Flag<["-", "--"], "combine">, Flags<[DriverOption, Unsupported]>;
def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
@@ -943,7 +1387,6 @@
Group<f_Group>, Flags<[DriverOption, CC1Option]>,
HelpText<"Disable '[[]]' attributes in all C and C++ language modes">;
-defm autolink : OptOutFFlag<"autolink", "", "Disable generation of linker directives for automatic library linking">;
// C++ Coroutines TS
defm coroutines_ts : OptInFFlag<"coroutines-ts", "Enable support for the C++ Coroutines TS">;
@@ -966,13 +1409,6 @@
def fprofile_sample_use_EQ : Joined<["-"], "fprofile-sample-use=">,
Group<f_Group>, Flags<[DriverOption, CC1Option]>,
HelpText<"Enable sample-based profile guided optimizations">;
-def fprofile_sample_accurate : Flag<["-"], "fprofile-sample-accurate">,
- Group<f_Group>, Flags<[DriverOption, CC1Option]>,
- HelpText<"Specifies that the sample profile is accurate">,
- DocBrief<[{Specifies that the sample profile is accurate. If the sample
- profile is accurate, callsites without profile samples are marked
- as cold. Otherwise, treat callsites without profile samples as if
- we have no profile}]>;
def fno_profile_sample_accurate : Flag<["-"], "fno-profile-sample-accurate">,
Group<f_Group>, Flags<[DriverOption]>;
def fauto_profile : Flag<["-"], "fauto-profile">, Group<f_Group>,
@@ -991,8 +1427,6 @@
def fdebug_compilation_dir_EQ : Joined<["-"], "fdebug-compilation-dir=">,
Group<f_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
Alias<fdebug_compilation_dir>;
-defm debug_info_for_profiling : OptInFFlag<"debug-info-for-profiling",
- "Emit extra debug info to make sample profile more accurate">;
def fprofile_instr_generate : Flag<["-"], "fprofile-instr-generate">,
Group<f_Group>, Flags<[CoreOption]>,
HelpText<"Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
@@ -1009,9 +1443,6 @@
HelpText<"Use the remappings described in <file> to match the profile data against names in the program">;
def fprofile_remapping_file : Separate<["-"], "fprofile-remapping-file">,
Group<f_Group>, Flags<[CoreOption]>, Alias<fprofile_remapping_file_EQ>;
-defm coverage_mapping : OptInFFlag<"coverage-mapping",
- "Generate coverage mapping to enable code coverage analysis", "Disable code coverage analysis", "",
- [CoreOption]>;
def fprofile_generate : Flag<["-"], "fprofile-generate">,
Group<f_Group>, Flags<[CoreOption]>,
HelpText<"Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)">;
@@ -1050,7 +1481,6 @@
Group<f_Group>, Flags<[CC1Option, CoreOption]>,
HelpText<"Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)">;
-defm addrsig : OptInFFlag<"addrsig", "Emit", "Don't emit", " an address-significance table", [CoreOption]>;
defm blocks : OptInFFlag<"blocks", "Enable the 'blocks' language feature", "", "", [CoreOption]>;
def fbootclasspath_EQ : Joined<["-"], "fbootclasspath=">, Group<f_Group>;
def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>,
@@ -1076,8 +1506,6 @@
Group<f_clang_Group>;
def : Flag<["-"], "frecord-gcc-switches">, Alias<frecord_command_line>;
def : Flag<["-"], "fno-record-gcc-switches">, Alias<fno_record_command_line>;
-def fcommon : Flag<["-"], "fcommon">, Group<f_Group>,
- Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">;
def fcompile_resource_EQ : Joined<["-"], "fcompile-resource=">, Group<f_Group>;
def fcomplete_member_pointers : Flag<["-"], "fcomplete-member-pointers">, Group<f_clang_Group>,
Flags<[CoreOption, CC1Option]>,
@@ -1107,8 +1535,6 @@
def fdepfile_entry : Joined<["-"], "fdepfile-entry=">,
Group<f_clang_Group>, Flags<[CC1Option]>;
def fdiagnostics_fixit_info : Flag<["-"], "fdiagnostics-fixit-info">, Group<f_clang_Group>;
-def fdiagnostics_show_hotness : Flag<["-"], "fdiagnostics-show-hotness">, Group<f_Group>,
- Flags<[CC1Option]>, HelpText<"Enable profile hotness information in diagnostic line">;
def fdiagnostics_hotness_threshold_EQ : Joined<["-"], "fdiagnostics-hotness-threshold=">,
Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<number>">,
HelpText<"Prevent optimization remarks from being output if they do not have at least this profile count">;
@@ -1128,7 +1554,6 @@
HelpText<"Allow '$' in identifiers">, Flags<[CC1Option]>;
def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>;
-defm dwarf_directory_asm : OptOutFFlag<"dwarf-directory-asm", "", "">;
def felide_constructors : Flag<["-"], "felide-constructors">, Group<f_Group>;
def feliminate_unused_debug_symbols : Flag<["-"], "feliminate-unused-debug-symbols">, Group<f_Group>;
def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
@@ -1169,8 +1594,6 @@
def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>, Flags<[CoreOption]>;
def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>;
def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>;
-defm jump_tables : OptOutFFlag<"jump-tables", "Use", "Do not use", " jump tables for lowering switches">;
-defm keep_static_consts : OptInFFlag<"keep-static-consts", "Keep", "Don't keep", " static const variables if unused", [DriverOption]>;
defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">;
defm cxx_static_destructors : OptOutFFlag<"c++-static-destructors", "",
"Disable C++ static destructor registration">;
@@ -1227,41 +1650,9 @@
Group<f_clang_Group>,
Flags<[CoreOption, DriverOption]>,
HelpText<"Disable origins tracking in MemorySanitizer">;
-def fsanitize_memory_use_after_dtor : Flag<["-"], "fsanitize-memory-use-after-dtor">,
- Group<f_clang_Group>,
- HelpText<"Enable use-after-destroy detection in MemorySanitizer">;
-def fno_sanitize_memory_use_after_dtor : Flag<["-"], "fno-sanitize-memory-use-after-dtor">,
- Group<f_clang_Group>,
- HelpText<"Disable use-after-destroy detection in MemorySanitizer">;
def fsanitize_address_field_padding : Joined<["-"], "fsanitize-address-field-padding=">,
Group<f_clang_Group>,
HelpText<"Level of field padding for AddressSanitizer">;
-def fsanitize_address_use_after_scope : Flag<["-"], "fsanitize-address-use-after-scope">,
- Group<f_clang_Group>,
- HelpText<"Enable use-after-scope detection in AddressSanitizer">;
-def fno_sanitize_address_use_after_scope : Flag<["-"], "fno-sanitize-address-use-after-scope">,
- Group<f_clang_Group>,
- Flags<[CoreOption, DriverOption]>,
- HelpText<"Disable use-after-scope detection in AddressSanitizer">;
-def fsanitize_address_poison_custom_array_cookie
- : Flag<[ "-" ], "fsanitize-address-poison-custom-array-cookie">,
- Group<f_clang_Group>,
- HelpText<"Enable poisoning array cookies when using custom operator new[] in AddressSanitizer">;
-def fno_sanitize_address_poison_custom_array_cookie
- : Flag<[ "-" ], "fno-sanitize-address-poison-custom-array-cookie">,
- Group<f_clang_Group>,
- HelpText<"Disable poisoning array cookies when using custom operator new[] in AddressSanitizer">;
-def fsanitize_address_globals_dead_stripping : Flag<["-"], "fsanitize-address-globals-dead-stripping">,
- Group<f_clang_Group>,
- HelpText<"Enable linker dead stripping of globals in AddressSanitizer">;
-def fsanitize_address_use_odr_indicator
- : Flag<["-"], "fsanitize-address-use-odr-indicator">,
- Group<f_clang_Group>,
- HelpText<"Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size">;
-def fno_sanitize_address_use_odr_indicator
- : Flag<["-"], "fno-sanitize-address-use-odr-indicator">,
- Group<f_clang_Group>,
- HelpText<"Disable ODR indicator globals">;
// Note: This flag was introduced when it was necessary to distinguish between
// ABI for correct codegen. This is no longer needed, but the flag is
// not removed since targeting either ABI will behave the same.
@@ -1301,8 +1692,6 @@
def fno_sanitize_undefined_trap_on_error
: Flag<["-"], "fno-sanitize-undefined-trap-on-error">, Group<f_clang_Group>,
Alias<fno_sanitize_trap_EQ>, AliasArgs<["undefined"]>;
-def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">,
- Group<f_clang_Group>;
def fno_sanitize_minimal_runtime : Flag<["-"], "fno-sanitize-minimal-runtime">,
Group<f_clang_Group>;
def fsanitize_link_runtime : Flag<["-"], "fsanitize-link-runtime">,
@@ -1313,26 +1702,14 @@
Group<f_clang_Group>;
def fno_sanitize_link_cxx_runtime : Flag<["-"], "fno-sanitize-link-c++-runtime">,
Group<f_clang_Group>;
-def fsanitize_cfi_cross_dso : Flag<["-"], "fsanitize-cfi-cross-dso">,
- Group<f_clang_Group>,
- HelpText<"Enable control flow integrity (CFI) checks for cross-DSO calls.">;
def fno_sanitize_cfi_cross_dso : Flag<["-"], "fno-sanitize-cfi-cross-dso">,
Flags<[CoreOption, DriverOption]>,
Group<f_clang_Group>,
HelpText<"Disable control flow integrity (CFI) checks for cross-DSO calls.">;
-def fsanitize_cfi_icall_generalize_pointers : Flag<["-"], "fsanitize-cfi-icall-generalize-pointers">,
- Group<f_clang_Group>,
- HelpText<"Generalize pointers in CFI indirect call type signature checks">;
-def fsanitize_cfi_canonical_jump_tables : Flag<["-"], "fsanitize-cfi-canonical-jump-tables">,
- Group<f_clang_Group>,
- HelpText<"Make the jump table addresses canonical in the symbol table">;
def fno_sanitize_cfi_canonical_jump_tables : Flag<["-"], "fno-sanitize-cfi-canonical-jump-tables">,
Group<f_clang_Group>,
Flags<[CoreOption, DriverOption]>,
HelpText<"Do not make the jump table addresses canonical in the symbol table">;
-def fsanitize_stats : Flag<["-"], "fsanitize-stats">,
- Group<f_clang_Group>,
- HelpText<"Enable sanitizer statistics gathering.">;
def fno_sanitize_stats : Flag<["-"], "fno-sanitize-stats">,
Group<f_clang_Group>,
Flags<[CoreOption, DriverOption]>,
@@ -1392,20 +1769,12 @@
" | on (according to FP_CONTRACT pragma) | off (never fuse). Default"
" is 'fast' for CUDA/HIP and 'on' otherwise.">, Values<"fast,on,off">;
-defm strict_float_cast_overflow : OptOutFFlag<"strict-float-cast-overflow",
- "Assume that overflowing float-to-int casts are undefined (default)",
- "Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions">;
-
def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>;
def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>;
defm rewrite_imports : OptInFFlag<"rewrite-imports", "">;
defm rewrite_includes : OptInFFlag<"rewrite-includes", "">;
-defm delete_null_pointer_checks : OptOutFFlag<"delete-null-pointer-checks",
- "Treat usage of null pointers as undefined behavior (default)",
- "Do not treat usage of null pointers as undefined behavior">;
-
def frewrite_map_file : Separate<["-"], "frewrite-map-file">,
Group<f_Group>,
Flags<[ DriverOption, CC1Option ]>;
@@ -1438,20 +1807,11 @@
HelpText<"Enables the global instruction selector">;
def fexperimental_isel : Flag<["-"], "fexperimental-isel">, Group<f_clang_Group>,
Alias<fglobal_isel>;
-defm experimental_new_pass_manager : BooleanMarshalledFFlag<"experimental-new-pass-manager", "CodeGenOpts.ExperimentalNewPassManager",
- "static_cast<unsigned>(ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER)", "Enables an experimental new pass manager in LLVM.",
- "Disables an experimental new pass manager in LLVM.">, Group<f_clang_Group>, Flags<[CC1Option]>;
def fexperimental_strict_floating_point : Flag<["-"], "fexperimental-strict-floating-point">,
Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Enables experimental strict floating point in LLVM.">;
def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
-def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Generate calls to instrument function entry and exit">;
-def finstrument_functions_after_inlining : Flag<["-"], "finstrument-functions-after-inlining">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Like -finstrument-functions, but insert the calls after inlining">;
-def finstrument_function_entry_bare : Flag<["-"], "finstrument-function-entry-bare">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Instrument function entry only, after inlining, without arguments to the instrumentation call">;
def fcf_protection_EQ : Joined<["-"], "fcf-protection=">, Flags<[CoreOption, CC1Option]>, Group<f_Group>,
HelpText<"Instrument control-flow architecture protection. Options: return, branch, full, none.">, Values<"return,branch,full,none">;
def fcf_protection : Flag<["-"], "fcf-protection">, Group<f_Group>, Flags<[CoreOption, CC1Option]>,
@@ -1491,11 +1851,6 @@
defm xray_always_emit_typedevents : OptInFFlag<"xray-always-emit-typedevents",
"Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented", "", "", [], "LangOpts->XRayAlwaysEmitTypedEvents">;
-defm xray_ignore_loops : OptInFFlag<"xray-ignore-loops",
- "Don't instrument functions with loops unless they also meet the minimum function size", "", "", [], "CodeGenOpts.XRayIgnoreLoops">;
-defm xray_function_index : OptOutFFlag<"xray-function-index", "",
- "Omit function index section at the expense of single-function patching performance", "", [], "CodeGenOpts.XRayOmitFunctionIndex">;
-
def fxray_link_deps : Flag<["-"], "fxray-link-deps">, Group<f_Group>,
Flags<[CC1Option]>,
HelpText<"Tells clang to add the link dependencies for XRay.">;
@@ -1507,13 +1862,6 @@
Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Select which XRay instrumentation points to emit. Options: all, none, function-entry, function-exit, function, custom. Default is 'all'. 'function' includes both 'function-entry' and 'function-exit'.">;
-def ffine_grained_bitfield_accesses : Flag<["-"],
- "ffine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
- HelpText<"Use separate accesses for consecutive bitfield runs with legal widths and alignments.">;
-def fno_fine_grained_bitfield_accesses : Flag<["-"],
- "fno-fine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
- HelpText<"Use large-integer access for consecutive bitfield runs.">;
-
def fexperimental_relative_cxx_abi_vtables : Flag<["-"], "fexperimental-relative-c++-abi-vtables">,
Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Use the experimental C++ class ABI for classes with virtual tables">;
@@ -1548,15 +1896,12 @@
HelpText<"Write minimized bitcode to <file> for the ThinLTO thin link only">;
def fmacro_backtrace_limit_EQ : Joined<["-"], "fmacro-backtrace-limit=">,
Group<f_Group>, Flags<[DriverOption, CoreOption]>;
-def fmerge_all_constants : Flag<["-"], "fmerge-all-constants">, Group<f_Group>,
- Flags<[CC1Option, CoreOption]>, HelpText<"Allow merging of constants">;
def fmessage_length_EQ : Joined<["-"], "fmessage-length=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Format message diagnostics so that they fit within N columns">;
def fms_extensions : Flag<["-"], "fms-extensions">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
HelpText<"Accept some non-standard constructs supported by the Microsoft compiler">;
def fms_compatibility : Flag<["-"], "fms-compatibility">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
HelpText<"Enable full Microsoft Visual C++ compatibility">;
-def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>;
def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[DriverOption, CoreOption]>,
HelpText<"Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))">;
def fms_compatibility_version
@@ -1678,9 +2023,6 @@
def fno_apple_pragma_pack : Flag<["-"], "fno-apple-pragma-pack">, Group<f_Group>;
def fno_asm : Flag<["-"], "fno-asm">, Group<f_Group>;
def fno_asynchronous_unwind_tables : Flag<["-"], "fno-asynchronous-unwind-tables">, Group<f_Group>;
-def fno_assume_sane_operator_new : Flag<["-"], "fno-assume-sane-operator-new">, Group<f_Group>,
- HelpText<"Don't assume that C++'s global operator new can't alias any pointer">,
- Flags<[CC1Option]>;
def fno_borland_extensions : Flag<["-"], "fno-borland-extensions">, Group<f_Group>;
def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
HelpText<"Disable implicit builtin knowledge of functions">;
@@ -1697,7 +2039,6 @@
Flags<[DriverOption]>;
def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>,
Flags<[CC1Option]>, HelpText<"Do not include fixit information in diagnostics">;
-def fno_diagnostics_show_hotness : Flag<["-"], "fno-diagnostics-show-hotness">, Group<f_Group>;
def fno_diagnostics_show_option : Flag<["-"], "fno-diagnostics-show-option">, Group<f_Group>, Flags<[CC1Option]>;
def fno_diagnostics_show_note_include_stack : Flag<["-"], "fno-diagnostics-show-note-include-stack">,
Flags<[CC1Option]>, Group<f_Group>;
@@ -1723,8 +2064,6 @@
HelpText<"Use the given vector functions library">, Values<"Accelerate,MASSV,SVML,none">;
def fno_lax_vector_conversions : Flag<["-"], "fno-lax-vector-conversions">, Group<f_Group>,
Alias<flax_vector_conversions_EQ>, AliasArgs<["none"]>;
-def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
- HelpText<"Disallow merging of constants">;
def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
Flags<[DriverOption]>;
def fno_implicit_module_maps : Flag <["-"], "fno-implicit-module-maps">, Group<f_Group>,
@@ -1767,30 +2106,16 @@
def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>;
def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>;
def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>;
-def fno_strict_vtable_pointers: Flag<["-"], "fno-strict-vtable-pointers">,
- Group<f_Group>;
def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>;
def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>,
Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">;
-def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Don't use __cxa_atexit for calling destructors">;
-def fno_register_global_dtors_with_atexit : Flag<["-"], "fno-register-global-dtors-with-atexit">, Group<f_Group>,
- HelpText<"Don't use atexit or __cxa_atexit to register global destructors">;
def fno_unit_at_a_time : Flag<["-"], "fno-unit-at-a-time">, Group<f_Group>;
def fno_unwind_tables : Flag<["-"], "fno-unwind-tables">, Group<f_Group>;
-def fno_verbose_asm : Flag<["-"], "fno-verbose-asm">, Group<f_Group>, Flags<[CC1Option]>;
def fno_working_directory : Flag<["-"], "fno-working-directory">, Group<f_Group>;
def fno_wrapv : Flag<["-"], "fno-wrapv">, Group<f_Group>;
def fobjc_arc : Flag<["-"], "fobjc-arc">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Synthesize retain and release calls for Objective-C pointers">;
def fno_objc_arc : Flag<["-"], "fno-objc-arc">, Group<f_Group>;
-def fobjc_convert_messages_to_runtime_calls :
- Flag<["-"], "fobjc-convert-messages-to-runtime-calls">, Group<f_Group>;
-def fno_objc_convert_messages_to_runtime_calls :
- Flag<["-"], "fno-objc-convert-messages-to-runtime-calls">, Group<f_Group>, Flags<[CC1Option]>;
-def fobjc_arc_exceptions : Flag<["-"], "fobjc-arc-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Use EH-safe code when synthesizing retains and releases in -fobjc-arc">;
-def fno_objc_arc_exceptions : Flag<["-"], "fno-objc-arc-exceptions">, Group<f_Group>;
def fobjc_atdefs : Flag<["-"], "fobjc-atdefs">, Group<clang_ignored_f_Group>;
def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
def fobjc_exceptions: Flag<["-"], "fobjc-exceptions">, Group<f_Group>,
@@ -1891,8 +2216,6 @@
HelpText<"Use the static host OpenMP runtime while linking.">;
def fno_optimize_sibling_calls : Flag<["-"], "fno-optimize-sibling-calls">, Group<f_Group>;
def foptimize_sibling_calls : Flag<["-"], "foptimize-sibling-calls">, Group<f_Group>;
-def fno_escaping_block_tail_calls : Flag<["-"], "fno-escaping-block-tail-calls">, Group<f_Group>, Flags<[CC1Option]>;
-def fescaping_block_tail_calls : Flag<["-"], "fescaping-block-tail-calls">, Group<f_Group>;
def force__cpusubtype__ALL : Flag<["-"], "force_cpusubtype_ALL">;
def force__flat__namespace : Flag<["-"], "force_flat_namespace">;
def force__load : Separate<["-"], "force_load">;
@@ -1916,8 +2239,6 @@
def fno_pic : Flag<["-"], "fno-pic">, Group<f_Group>;
def fpie : Flag<["-"], "fpie">, Group<f_Group>;
def fno_pie : Flag<["-"], "fno-pie">, Group<f_Group>;
-defm plt : OptOutFFlag<"plt", "",
- "Use GOT indirection instead of PLT to make external function calls (x86 only)">;
defm ropi : OptInFFlag<"ropi", "Generate read-only position independent code (ARM only)">;
defm rwpi : OptInFFlag<"rwpi", "Generate read-write position independent code (ARM only)">;
def fplugin_EQ : Joined<["-"], "fplugin=">, Group<f_Group>, Flags<[DriverOption]>, MetaVarName<"<dsopath>">,
@@ -1925,8 +2246,6 @@
def fpass_plugin_EQ : Joined<["-"], "fpass-plugin=">,
Group<f_Group>, Flags<[CC1Option]>, MetaVarName<"<dsopath>">,
HelpText<"Load pass plugin from a dynamic shared object file (only with new pass manager).">;
-defm preserve_as_comments : OptOutFFlag<"preserve-as-comments", "",
- "Do not preserve comments in inline assembly">;
def fprofile_arcs : Flag<["-"], "fprofile-arcs">, Group<f_Group>;
def fno_profile_arcs : Flag<["-"], "fno-profile-arcs">, Group<f_Group>;
def framework : Separate<["-"], "framework">, Flags<[LinkerInput]>;
@@ -1958,10 +2277,6 @@
def fsplit_stack : Flag<["-"], "fsplit-stack">, Group<f_Group>;
def fstack_protector_all : Flag<["-"], "fstack-protector-all">, Group<f_Group>,
HelpText<"Enable stack protectors for all functions">;
-def fstack_clash_protection : Flag<["-"], "fstack-clash-protection">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Enable stack clash protection">;
-def fnostack_clash_protection : Flag<["-"], "fnostack-clash-protection">, Group<f_Group>,
- HelpText<"Disable stack clash protection">;
def fstack_protector_strong : Flag<["-"], "fstack-protector-strong">, Group<f_Group>,
HelpText<"Enable stack protectors for some functions vulnerable to stack smashing. "
"Compared to -fstack-protector, this uses a stronger heuristic "
@@ -1993,13 +2308,6 @@
HelpText<"Do not emit macro debug information">;
def fstrict_aliasing : Flag<["-"], "fstrict-aliasing">, Group<f_Group>,
Flags<[DriverOption, CoreOption]>;
-def fstrict_enums : Flag<["-"], "fstrict-enums">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Enable optimizations based on the strict definition of an enum's "
- "value range">;
-def fstrict_vtable_pointers: Flag<["-"], "fstrict-vtable-pointers">,
- Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Enable optimizations based on the strict rules for overwriting "
- "polymorphic C++ objects">;
def fstrict_overflow : Flag<["-"], "fstrict-overflow">, Group<f_Group>;
def fsyntax_only : Flag<["-"], "fsyntax-only">,
Flags<[DriverOption,CoreOption,CC1Option]>, Group<Action_Group>;
@@ -2069,7 +2377,6 @@
HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;
def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
HelpText<"Turn off loop unroller">, Flags<[CC1Option]>;
-defm reroll_loops : OptInFFlag<"reroll-loops", "Turn on loop reroller">;
def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
@@ -2078,10 +2385,6 @@
def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>;
def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">;
def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>;
-def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
-def fregister_global_dtors_with_atexit : Flag<["-"], "fregister-global-dtors-with-atexit">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Use atexit or __cxa_atexit to register global destructors">;
-defm use_init_array : OptOutFFlag<"use-init-array", "", "Use .ctors/.dtors instead of .init_array/.fini_array">;
def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>,
HelpText<"Generate verbose assembly output">;
@@ -2096,38 +2399,17 @@
"variables 'hidden' visibility by default">;
def fvisibility_global_new_delete_hidden : Flag<["-"], "fvisibility-global-new-delete-hidden">, Group<f_Group>,
HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>;
-defm whole_program_vtables : OptInFFlag<"whole-program-vtables",
- "Enables whole-program vtable optimization. Requires -flto", "", "", [CoreOption]>;
-defm split_lto_unit : OptInFFlag<"split-lto-unit",
- "Enables splitting of the LTO unit", "", "", [CoreOption]>;
-defm force_emit_vtables : OptInFFlag<"force-emit-vtables",
- "Emits more virtual tables to improve devirtualization", "", "", [CoreOption]>;
-defm virtual_function_elimination : OptInFFlag<"virtual-function-elimination",
- "Enables dead virtual function elimination optimization. Requires -flto=full", "", "", [CoreOption]>;
def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Treat signed integer overflow as two's complement">;
def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Store string literals as writable data">;
-defm zero_initialized_in_bss : OptOutFFlag<"zero-initialized-in-bss", "", "Don't place zero initialized data in BSS">;
defm function_sections : OptInFFlag<"function-sections", "Place each function in its own section">;
def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>,
Flags<[CC1Option, CC1AsOption]>,
HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">,
DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>,
Values<"all,labels,none,list=">;
-defm data_sections : OptInFFlag<"data-sections", "Place each data in its own section">;
-defm stack_size_section : OptInFFlag<"stack-size-section", "Emit section containing metadata on function stack sizes">;
-
-defm unique_basic_block_section_names : OptInFFlag<"unique-basic-block-section-names",
- "Use unique names for basic block sections (ELF Only)">;
-defm unique_internal_linkage_names : OptInFFlag<"unique-internal-linkage-names",
- "Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path">;
-defm unique_section_names : OptOutFFlag<"unique-section-names",
- "", "Don't use unique names for text and data sections">;
-
-defm strict_return : OptOutFFlag<"strict-return", "",
- "Don't treat control flow paths that fall off the end of a non-void function as unreachable">;
def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_Group>,
Flags<[CC1Option]>,
@@ -2137,12 +2419,6 @@
def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
HelpText<"Place debug types in their own section (ELF Only)">;
def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>;
-defm debug_ranges_base_address : OptInFFlag<"debug-ranges-base-address",
- "Use DWARF base address selection entries in .debug_ranges">;
-def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, Group<f_Group>,
- HelpText<"Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF">;
-def fno_split_dwarf_inlining: Flag<["-"], "fno-split-dwarf-inlining">, Group<f_Group>,
- Flags<[CC1Option]>;
def fdebug_default_version: Joined<["-"], "fdebug-default-version=">, Group<f_Group>,
HelpText<"Default DWARF version to use, if a -g option caused DWARF debug info to be produced">;
def fdebug_prefix_map_EQ
@@ -2155,7 +2431,6 @@
def fmacro_prefix_map_EQ
: Joined<["-"], "fmacro-prefix-map=">, Group<Preprocessor_Group>, Flags<[CC1Option]>,
HelpText<"remap file source paths in predefined preprocessor macros">;
-defm force_dwarf_frame : OptInFFlag<"force-dwarf-frame", "Always emit a debug frame section">;
def g_Flag : Flag<["-"], "g">, Group<g_Group>,
HelpText<"Generate source-level debug information">;
def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
@@ -2187,16 +2462,8 @@
def gdwarf_5 : Flag<["-"], "gdwarf-5">, Group<g_Group>,
HelpText<"Generate source-level debug information with dwarf version 5">;
-def gcodeview : Flag<["-"], "gcodeview">,
- HelpText<"Generate CodeView debug information">,
- Flags<[CC1Option, CC1AsOption, CoreOption]>;
-def gcodeview_ghash : Flag<["-"], "gcodeview-ghash">,
- HelpText<"Emit type record hashes in a .debug$H section">,
- Flags<[CC1Option, CoreOption]>;
def gno_codeview_ghash : Flag<["-"], "gno-codeview-ghash">, Flags<[CoreOption]>;
def ginline_line_tables : Flag<["-"], "ginline-line-tables">, Flags<[CoreOption]>;
-def gno_inline_line_tables : Flag<["-"], "gno-inline-line-tables">,
- Flags<[CC1Option, CoreOption]>, HelpText<"Don't emit inline line tables">;
def gfull : Flag<["-"], "gfull">, Group<g_Group>;
def gused : Flag<["-"], "gused">, Group<g_Group>;
@@ -2214,7 +2481,6 @@
def gstrict_dwarf : Flag<["-"], "gstrict-dwarf">, Group<g_flags_Group>;
def gno_strict_dwarf : Flag<["-"], "gno-strict-dwarf">, Group<g_flags_Group>;
def gcolumn_info : Flag<["-"], "gcolumn-info">, Group<g_flags_Group>, Flags<[CoreOption]>;
-def gno_column_info : Flag<["-"], "gno-column-info">, Group<g_flags_Group>, Flags<[CoreOption, CC1Option]>;
def gsplit_dwarf : Flag<["-"], "gsplit-dwarf">, Group<g_flags_Group>;
def gsplit_dwarf_EQ : Joined<["-"], "gsplit-dwarf=">, Group<g_flags_Group>,
HelpText<"Set DWARF fission mode to either 'split' or 'single'">,
@@ -2231,8 +2497,6 @@
HelpText<"DWARF debug sections compression type">;
def gz_EQ : Joined<["-"], "gz=">, Group<g_flags_Group>,
HelpText<"DWARF debug sections compression type">;
-def gembed_source : Flag<["-"], "gembed-source">, Group<g_flags_Group>, Flags<[CC1Option]>,
- HelpText<"Embed source text in DWARF debug sections">;
def gno_embed_source : Flag<["-"], "gno-embed-source">, Group<g_flags_Group>,
Flags<[DriverOption]>,
HelpText<"Restore the default behavior of not embedding source text in DWARF debug sections">;
@@ -2402,16 +2666,12 @@
HelpText<"Disable function outlining (AArch64 only)">;
def mno_ms_bitfields : Flag<["-"], "mno-ms-bitfields">, Group<m_Group>,
HelpText<"Do not set the default structure layout to be compatible with the Microsoft compiler standard">;
-def mstackrealign : Flag<["-"], "mstackrealign">, Group<m_Group>, Flags<[CC1Option]>,
- HelpText<"Force realign the stack at entry to every function">;
def mstack_alignment : Joined<["-"], "mstack-alignment=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Set the stack alignment">;
def mstack_probe_size : Joined<["-"], "mstack-probe-size=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Set the stack probe size">;
def mstack_arg_probe : Flag<["-"], "mstack-arg-probe">, Group<m_Group>,
HelpText<"Enable stack probes">;
-def mno_stack_arg_probe : Flag<["-"], "mno-stack-arg-probe">, Group<m_Group>, Flags<[CC1Option]>,
- HelpText<"Disable stack probes which are enabled by default">;
def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"The thread model to use, e.g. posix, single (posix by default)">, Values<"posix,single">;
def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>,
@@ -2423,8 +2683,6 @@
def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">,
Alias<fno_pascal_strings>;
def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>;
-def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group<m_Group>, Flags<[CC1Option]>,
- HelpText<"Disable direct TLS access through segment registers">;
def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>;
def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>;
def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>;
@@ -2432,8 +2690,6 @@
def mretpoline : Flag<["-"], "mretpoline">, Group<m_Group>, Flags<[CoreOption,DriverOption]>;
def mno_retpoline : Flag<["-"], "mno-retpoline">, Group<m_Group>, Flags<[CoreOption,DriverOption]>;
-def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">,
- Group<m_Group>, Flags<[CoreOption,CC1Option]>;
def mno_speculative_load_hardening : Flag<["-"], "mno-speculative-load-hardening">,
Group<m_Group>, Flags<[CoreOption]>;
def mlvi_hardening : Flag<["-"], "mlvi-hardening">, Group<m_Group>, Flags<[CoreOption,DriverOption]>,
@@ -2495,9 +2751,6 @@
def mcmse : Flag<["-"], "mcmse">, Group<m_arm_Features_Group>,
Flags<[DriverOption,CC1Option]>,
HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">;
-def ForceAAPCSBitfieldLoad : Flag<["-"], "fAAPCSBitfieldLoad">, Group<m_arm_Features_Group>,
- Flags<[DriverOption,CC1Option]>,
- HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">;
def mgeneral_regs_only : Flag<["-"], "mgeneral-regs-only">, Group<m_aarch64_Features_Group>,
HelpText<"Generate code which only uses the general purpose registers (AArch64 only)">;
@@ -2655,10 +2908,6 @@
def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>;
def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>;
-def mbackchain : Flag<["-"], "mbackchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>,
- HelpText<"Link stack frames through backchain on System Z">;
-def mno_backchain : Flag<["-"], "mno-backchain">, Group<m_Group>, Flags<[DriverOption,CC1Option]>;
-
def mno_warn_nonportable_cfstrings : Flag<["-"], "mno-warn-nonportable-cfstrings">, Group<m_Group>;
def mno_omit_leaf_frame_pointer : Flag<["-"], "mno-omit-leaf-frame-pointer">, Group<m_Group>;
def momit_leaf_frame_pointer : Flag<["-"], "momit-leaf-frame-pointer">, Group<m_Group>,
@@ -2669,19 +2918,12 @@
def mtls_direct_seg_refs : Flag<["-"], "mtls-direct-seg-refs">, Group<m_Group>,
HelpText<"Enable direct TLS access through segment registers (default)">;
def mregparm_EQ : Joined<["-"], "mregparm=">, Group<m_Group>;
-def mrelax_all : Flag<["-"], "mrelax-all">, Group<m_Group>, Flags<[CC1Option,CC1AsOption]>,
- HelpText<"(integrated-as) Relax all machine instructions">;
-def mincremental_linker_compatible : Flag<["-"], "mincremental-linker-compatible">, Group<m_Group>,
- Flags<[CC1Option,CC1AsOption]>,
- HelpText<"(integrated-as) Emit an object file which can be used with an incremental linker">;
def mno_incremental_linker_compatible : Flag<["-"], "mno-incremental-linker-compatible">, Group<m_Group>,
HelpText<"(integrated-as) Emit an object file which cannot be used with an incremental linker">;
def mrtd : Flag<["-"], "mrtd">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Make StdCall calling convention the default">;
def msmall_data_threshold_EQ : Joined <["-"], "msmall-data-threshold=">,
Group<m_Group>, Alias<G>;
-def msoft_float : Flag<["-"], "msoft-float">, Group<m_Group>, Flags<[CC1Option]>,
- HelpText<"Use software floating point">;
def mno_implicit_float : Flag<["-"], "mno-implicit-float">, Group<m_Group>,
HelpText<"Don't generate implicit floating point instructions">;
def mimplicit_float : Flag<["-"], "mimplicit-float">, Group<m_Group>;
@@ -2689,18 +2931,7 @@
def mrecip_EQ : CommaJoined<["-"], "mrecip=">, Group<m_Group>, Flags<[CC1Option]>;
def mprefer_vector_width_EQ : Joined<["-"], "mprefer-vector-width=">, Group<m_Group>, Flags<[CC1Option]>,
HelpText<"Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.">;
-def mpie_copy_relocations : Flag<["-"], "mpie-copy-relocations">, Group<m_Group>,
- Flags<[CC1Option]>,
- HelpText<"Use copy relocations support for PIE builds">;
def mno_pie_copy_relocations : Flag<["-"], "mno-pie-copy-relocations">, Group<m_Group>;
-def mfentry : Flag<["-"], "mfentry">, HelpText<"Insert calls to fentry at function entry (x86/SystemZ only)">,
- Flags<[CC1Option]>, Group<m_Group>;
-def mnop_mcount : Flag<["-"], "mnop-mcount">, HelpText<"Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.">,
- Flags<[CC1Option]>, Group<m_Group>;
-def mrecord_mcount : Flag<["-"], "mrecord-mcount">, HelpText<"Generate a __mcount_loc section entry for each __fentry__ call.">,
- Flags<[CC1Option]>, Group<m_Group>;
-def mpacked_stack : Flag<["-"], "mpacked-stack">, HelpText<"Use packed stack layout (SystemZ only).">,
- Flags<[CC1Option]>, Group<m_Group>;
def mno_packed_stack : Flag<["-"], "mno-packed-stack">, Flags<[CC1Option]>, Group<m_Group>;
def mips16 : Flag<["-"], "mips16">, Group<m_mips_Features_Group>;
def mno_mips16 : Flag<["-"], "mno-mips16">, Group<m_mips_Features_Group>;
@@ -2892,7 +3123,6 @@
HelpText<"Write output to <file>">, MetaVarName<"<file>">;
def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
-def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
def pipe : Flag<["-", "--"], "pipe">,
HelpText<"Use pipes between commands, when possible">;
def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
@@ -3052,8 +3282,6 @@
MetaVarName<"<language>">;
def y : Joined<["-"], "y">;
-defm integrated_as : OptOutFFlag<"integrated-as", "Enable the integrated assembler", "Disable the integrated assembler">;
-
def fintegrated_cc1 : Flag<["-"], "fintegrated-cc1">,
Flags<[CoreOption, DriverOption]>, Group<f_Group>,
HelpText<"Run cc1 in-process">;
@@ -3804,8 +4032,6 @@
let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">;
-def debug_info_macro : Flag<["-"], "debug-info-macro">,
- HelpText<"Emit macro debug information">;
def default_function_attr : Separate<["-"], "default-function-attr">,
HelpText<"Apply given attribute to all functions">;
def dwarf_version_EQ : Joined<["-"], "dwarf-version=">;
@@ -3818,63 +4044,12 @@
HelpText<"DWARF debug sections compression">;
def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">,
HelpText<"DWARF debug sections compression type">;
-def mno_exec_stack : Flag<["-"], "mnoexecstack">,
- HelpText<"Mark the file as not needing an executable stack">;
-def massembler_no_warn : Flag<["-"], "massembler-no-warn">,
- HelpText<"Make assembler not emit warnings">;
-def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
- HelpText<"Make assembler warnings fatal">;
-def mrelax_relocations : Flag<["--"], "mrelax-relocations">,
- HelpText<"Use relaxable elf relocations">;
-def msave_temp_labels : Flag<["-"], "msave-temp-labels">,
- HelpText<"Save temporary labels in the symbol table. "
- "Note this may change .s semantics and shouldn't generally be used "
- "on compiler-generated code.">;
-def mrelocation_model : Separate<["-"], "mrelocation-model">,
- HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
- NormalizedValuesScope<"llvm::Reloc">,
- NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
- MarshallingInfoString<"CodeGenOpts.RelocationModel", "PIC_">,
- AutoNormalizeEnum;
def fno_math_builtin : Flag<["-"], "fno-math-builtin">,
HelpText<"Disable implicit builtin knowledge of math functions">;
}
-def disable_llvm_verifier : Flag<["-"], "disable-llvm-verifier">,
- HelpText<"Don't run the LLVM IR verifier pass">;
-def disable_llvm_passes : Flag<["-"], "disable-llvm-passes">,
- HelpText<"Use together with -emit-llvm to get pristine LLVM IR from the "
- "frontend by not running any LLVM passes at all">;
-def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">,
- Alias<disable_llvm_passes>;
-def disable_lifetimemarkers : Flag<["-"], "disable-lifetime-markers">,
- HelpText<"Disable lifetime-markers emission even when optimizations are "
- "enabled">;
-def disable_O0_optnone : Flag<["-"], "disable-O0-optnone">,
- HelpText<"Disable adding the optnone attribute to functions at O0">;
-def disable_red_zone : Flag<["-"], "disable-red-zone">,
- HelpText<"Do not emit code that uses the red zone.">;
-def dwarf_ext_refs : Flag<["-"], "dwarf-ext-refs">,
- HelpText<"Generate debug info with external references to clang modules"
- " or precompiled headers">;
-def dwarf_explicit_import : Flag<["-"], "dwarf-explicit-import">,
- HelpText<"Generate explicit import from anonymous namespace to containing"
- " scope">;
-def debug_forward_template_params : Flag<["-"], "debug-forward-template-params">,
- HelpText<"Emit complete descriptions of template parameters in forward"
- " declarations">;
-def fforbid_guard_variables : Flag<["-"], "fforbid-guard-variables">,
- HelpText<"Emit an error if a C++ static local initializer would need a guard variable">;
-def no_implicit_float : Flag<["-"], "no-implicit-float">,
- HelpText<"Don't generate implicit floating point instructions">;
def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">,
HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">;
-def fmerge_functions : Flag<["-"], "fmerge-functions">,
- HelpText<"Permit merging of identical functions when optimizing.">;
-def femit_coverage_notes : Flag<["-"], "femit-coverage-notes">,
- HelpText<"Emit a gcov coverage notes file when compiling.">;
-def femit_coverage_data: Flag<["-"], "femit-coverage-data">,
- HelpText<"Instrument the program to emit gcov coverage data when run.">;
def coverage_data_file : Separate<["-"], "coverage-data-file">,
HelpText<"Emit coverage data to this filename.">;
def coverage_data_file_EQ : Joined<["-"], "coverage-data-file=">,
@@ -3885,24 +4060,12 @@
Alias<coverage_notes_file>;
def coverage_version_EQ : Joined<["-"], "coverage-version=">,
HelpText<"Four-byte version string for gcov files.">;
-def test_coverage : Flag<["-"], "test-coverage">,
- HelpText<"Do not generate coverage files or remove coverage changes from IR">;
-def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">,
- HelpText<"Dump the coverage mapping records, for testing">;
-def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">,
- HelpText<"Use register sized accesses to bit-fields, when possible.">;
-def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">,
- HelpText<"Turn off Type Based Alias Analysis">;
-def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">,
- HelpText<"Turn off struct-path aware Type Based Alias Analysis">;
def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">,
HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">;
def mdebug_pass : Separate<["-"], "mdebug-pass">,
HelpText<"Enable additional debug output">;
def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">,
HelpText<"Specify which frame pointers to retain (all, non-leaf, none).">, Values<"all,non-leaf,none">;
-def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">,
- HelpText<"Disable tail call optimization, keeping the call stack accurate">;
def menable_no_infinities : Flag<["-"], "menable-no-infs">,
HelpText<"Allow optimization to assume there are no infinities.">,
MarshallingInfoFlag<"LangOpts->NoHonorInfs", "false">;
@@ -3924,16 +4087,10 @@
HelpText<"Mode for reading thread pointer">;
def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">,
HelpText<"Limit float precision to the given value">;
-def split_stacks : Flag<["-"], "split-stacks">,
- HelpText<"Try to use a split stack if possible.">;
def mregparm : Separate<["-"], "mregparm">,
HelpText<"Limit the number of registers available for integer arguments">;
def msmall_data_limit : Separate<["-"], "msmall-data-limit">,
HelpText<"Put global and static data smaller than the limit into a special section">;
-def munwind_tables : Flag<["-"], "munwind-tables">,
- HelpText<"Generate unwinding tables for all functions">;
-def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">,
- HelpText<"Emit complete constructors and destructors as aliases when possible">;
def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">,
HelpText<"Link the given bitcode file before performing optimizations.">;
def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">,
@@ -3941,55 +4098,12 @@
"before performing optimizations.">;
def mlink_cuda_bitcode : Separate<["-"], "mlink-cuda-bitcode">,
Alias<mlink_builtin_bitcode>;
-def vectorize_loops : Flag<["-"], "vectorize-loops">,
- HelpText<"Run the Loop vectorization passes">;
-def vectorize_slp : Flag<["-"], "vectorize-slp">,
- HelpText<"Run the SLP vectorization passes">;
def dependent_lib : Joined<["--"], "dependent-lib=">,
HelpText<"Add dependent library">;
def linker_option : Joined<["--"], "linker-option=">,
HelpText<"Add linker option">;
def fsanitize_coverage_type : Joined<["-"], "fsanitize-coverage-type=">,
HelpText<"Sanitizer coverage type">;
-def fsanitize_coverage_indirect_calls
- : Flag<["-"], "fsanitize-coverage-indirect-calls">,
- HelpText<"Enable sanitizer coverage for indirect calls">;
-def fsanitize_coverage_trace_bb
- : Flag<["-"], "fsanitize-coverage-trace-bb">,
- HelpText<"Enable basic block tracing in sanitizer coverage">;
-def fsanitize_coverage_trace_cmp
- : Flag<["-"], "fsanitize-coverage-trace-cmp">,
- HelpText<"Enable cmp instruction tracing in sanitizer coverage">;
-def fsanitize_coverage_trace_div
- : Flag<["-"], "fsanitize-coverage-trace-div">,
- HelpText<"Enable div instruction tracing in sanitizer coverage">;
-def fsanitize_coverage_trace_gep
- : Flag<["-"], "fsanitize-coverage-trace-gep">,
- HelpText<"Enable gep instruction tracing in sanitizer coverage">;
-def fsanitize_coverage_8bit_counters
- : Flag<["-"], "fsanitize-coverage-8bit-counters">,
- HelpText<"Enable frequency counters in sanitizer coverage">;
-def fsanitize_coverage_inline_8bit_counters
- : Flag<["-"], "fsanitize-coverage-inline-8bit-counters">,
- HelpText<"Enable inline 8-bit counters in sanitizer coverage">;
-def fsanitize_coverage_inline_bool_flag
- : Flag<["-"], "fsanitize-coverage-inline-bool-flag">,
- HelpText<"Enable inline bool flag in sanitizer coverage">;
-def fsanitize_coverage_pc_table
- : Flag<["-"], "fsanitize-coverage-pc-table">,
- HelpText<"Create a table of coverage-instrumented PCs">;
-def fsanitize_coverage_trace_pc
- : Flag<["-"], "fsanitize-coverage-trace-pc">,
- HelpText<"Enable PC tracing in sanitizer coverage">;
-def fsanitize_coverage_trace_pc_guard
- : Flag<["-"], "fsanitize-coverage-trace-pc-guard">,
- HelpText<"Enable PC tracing with guard in sanitizer coverage">;
-def fsanitize_coverage_no_prune
- : Flag<["-"], "fsanitize-coverage-no-prune">,
- HelpText<"Disable coverage pruning (i.e. instrument all blocks/edges)">;
-def fsanitize_coverage_stack_depth
- : Flag<["-"], "fsanitize-coverage-stack-depth">,
- HelpText<"Enable max stack depth tracing">;
def fpatchable_function_entry_offset_EQ
: Joined<["-"], "fpatchable-function-entry-offset=">, MetaVarName<"<M>">,
HelpText<"Generate M NOPs before function entry">;
@@ -4002,16 +4116,6 @@
def fprofile_instrument_use_path_EQ :
Joined<["-"], "fprofile-instrument-use-path=">,
HelpText<"Specify the profile path in PGO use compilation">;
-def flto_visibility_public_std:
- Flag<["-"], "flto-visibility-public-std">,
- HelpText<"Use public LTO visibility for classes in std and stdext namespaces">;
-def flto_unit: Flag<["-"], "flto-unit">,
- HelpText<"Emit IR to support LTO unit features (CFI, whole program vtable opt)">;
-def fno_lto_unit: Flag<["-"], "fno-lto-unit">;
-def fdebug_pass_manager : Flag<["-"], "fdebug-pass-manager">,
- HelpText<"Prints debug information for the new pass manager">;
-def fno_debug_pass_manager : Flag<["-"], "fno-debug-pass-manager">,
- HelpText<"Disables debug printing for the new pass manager">;
// The driver option takes the key as a parameter to the -msign-return-address=
// and -mbranch-protection= options, but CC1 has a separate option so we
// don't have to parse the parameter twice.
@@ -4019,10 +4123,6 @@
Values<"a_key,b_key">;
def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">;
def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">;
-def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">,
- HelpText<"Emit Windows Control Flow Guard tables only (no checks)">;
-def cfguard : Flag<["-"], "cfguard">,
- HelpText<"Emit Windows Control Flow Guard tables and checks">;
def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">,
Group<f_Group>;
@@ -4102,8 +4202,6 @@
HelpText<"Replace the contents of the <from> file with the contents of the <to> file">;
def code_completion_at_EQ : Joined<["-"], "code-completion-at=">,
Alias<code_completion_at>;
-def discard_value_names : Flag<["-"], "discard-value-names">,
- HelpText<"Discard value names in LLVM IR">;
def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">,
HelpText<"Load the named plugin (dynamic shared object)">;
def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">,
@@ -4232,11 +4330,6 @@
HelpText<"Print the output of the dependency directives source minimizer">;
}
-def emit_llvm_uselists : Flag<["-"], "emit-llvm-uselists">,
- HelpText<"Preserve order of LLVM use-lists when serializing">;
-def no_emit_llvm_uselists : Flag<["-"], "no-emit-llvm-uselists">,
- HelpText<"Don't preserve order of LLVM use-lists when serializing">;
-
def mt_migrate_directory : Separate<["-"], "mt-migrate-directory">,
HelpText<"Directory for temporary files produced during ARC or ObjC migration">;
@@ -4379,8 +4472,6 @@
HelpText<"Include default header file for OpenCL">;
def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">,
HelpText<"Add OpenCL builtin function declarations (experimental)">;
-def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">,
- HelpText<"Preserve 3-component vector type">;
def fwchar_type_EQ : Joined<["-"], "fwchar-type=">,
HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">;
def fsigned_wchar : Flag<["-"], "fsigned-wchar">,
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
