jansvoboda11 updated this revision to Diff 311542.
jansvoboda11 added a comment.
Revert exceptions flags
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D83979/new/
https://reviews.llvm.org/D83979
Files:
clang/include/clang/Basic/LangOptions.h
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
@@ -290,7 +290,7 @@
template <typename T, typename U>
static T mergeForwardValue(T KeyPath, U Value) {
- return Value;
+ return static_cast<T>(Value);
}
template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
@@ -306,7 +306,8 @@
return KeyPath & Value;
}
-static void FixupInvocation(CompilerInvocation &Invocation) {
+static void FixupInvocation(CompilerInvocation &Invocation,
+ DiagnosticsEngine &Diags) {
LangOptions &LangOpts = *Invocation.getLangOpts();
DiagnosticOptions &DiagOpts = Invocation.getDiagnosticOpts();
CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts();
@@ -317,7 +318,13 @@
CodeGenOpts.DisableFree = FrontendOpts.DisableFree;
FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex;
+ LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
+ LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
+
llvm::sys::Process::UseANSIEscapeCodes(DiagOpts.UseANSIEscapeCodes);
+
+ if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
+ Diags.Report(diag::warn_c_kext);
}
//===----------------------------------------------------------------------===//
@@ -2419,9 +2426,6 @@
}
}
- if (Args.hasArg(OPT_fno_dllexport_inlines))
- Opts.DllExportInlines = false;
-
if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
StringRef Name = A->getValue();
if (Name == "full" || Name == "branch") {
@@ -2450,7 +2454,6 @@
LangStd = OpenCLLangStd;
}
- Opts.SYCL = Args.hasArg(options::OPT_fsycl);
Opts.SYCLIsDevice = Opts.SYCL && Args.hasArg(options::OPT_fsycl_is_device);
if (Opts.SYCL) {
// -sycl-std applies to any SYCL source, not only those containing kernels,
@@ -2468,9 +2471,6 @@
}
}
- Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
- Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
-
llvm::Triple T(TargetOpts.Triple);
CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
@@ -2497,25 +2497,9 @@
if (Args.hasArg(OPT_fno_operator_names))
Opts.CXXOperatorNames = 0;
- if (Args.hasArg(OPT_fcuda_is_device))
- Opts.CUDAIsDevice = 1;
-
- if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
- Opts.CUDAAllowVariadicFunctions = 1;
-
- if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
- Opts.CUDAHostDeviceConstexpr = 0;
-
- if (Args.hasArg(OPT_fgpu_exclude_wrong_side_overloads))
- Opts.GPUExcludeWrongSideOverloads = 1;
-
- if (Args.hasArg(OPT_fgpu_defer_diag))
- Opts.GPUDeferDiag = 1;
-
if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
Opts.CUDADeviceApproxTranscendentals = 1;
- Opts.GPURelocatableDeviceCode = Args.hasArg(OPT_fgpu_rdc);
if (Args.hasArg(OPT_fgpu_allow_device_init)) {
if (Opts.HIP)
Opts.GPUAllowDeviceInit = 1;
@@ -2523,7 +2507,6 @@
Diags.Report(diag::warn_ignored_hip_only_option)
<< Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
}
- Opts.HIPUseNewLaunchAPI = Args.hasArg(OPT_fhip_new_launch_api);
if (Opts.HIP)
Opts.GPUMaxThreadsPerBlock = getLastArgIntValue(
Args, OPT_gpu_max_threads_per_block_EQ, Opts.GPUMaxThreadsPerBlock);
@@ -2543,7 +2526,6 @@
else if (Args.hasArg(OPT_fobjc_gc))
Opts.setGC(LangOptions::HybridGC);
else if (Args.hasArg(OPT_fobjc_arc)) {
- Opts.ObjCAutoRefCount = 1;
if (!Opts.ObjCRuntime.allowsARC())
Diags.Report(diag::err_arc_unsupported_on_runtime);
}
@@ -2573,9 +2555,6 @@
Opts.ObjCWeak = Opts.ObjCWeakRuntime;
}
- if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
- Opts.ObjCInferRelatedResultType = 0;
-
if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
Opts.ObjCSubscriptingLegacyRuntime =
(Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX);
@@ -2604,18 +2583,6 @@
Opts.GNUInline = 1;
}
- if (Args.hasArg(OPT_fapple_kext)) {
- if (!Opts.CPlusPlus)
- Diags.Report(diag::warn_c_kext);
- else
- Opts.AppleKext = 1;
- }
-
- if (Args.hasArg(OPT_print_ivar_layout))
- Opts.ObjCGCBitmapPrint = 1;
-
- if (Args.hasArg(OPT_fno_constant_cfstrings))
- Opts.NoConstantCFStrings = 1;
if (const auto *A = Args.getLastArg(OPT_fcf_runtime_abi_EQ))
Opts.CFRuntime =
llvm::StringSwitch<LangOptions::CoreFoundationABI>(A->getValue())
@@ -2627,12 +2594,6 @@
.Case("swift-4.1", LangOptions::CoreFoundationABI::Swift4_1)
.Default(LangOptions::CoreFoundationABI::ObjectiveC);
- if (Args.hasArg(OPT_fzvector))
- Opts.ZVector = 1;
-
- if (Args.hasArg(OPT_pthread))
- Opts.POSIXThreads = 1;
-
// The value-visibility mode defaults to "default".
if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
@@ -2647,18 +2608,6 @@
Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
}
- if (Args.hasArg(OPT_fvisibility_inlines_hidden))
- Opts.InlineVisibilityHidden = 1;
-
- if (Args.hasArg(OPT_fvisibility_inlines_hidden_static_local_var))
- Opts.VisibilityInlinesHiddenStaticLocalVar = 1;
-
- if (Args.hasArg(OPT_fvisibility_global_new_delete_hidden))
- Opts.GlobalAllocationFunctionVisibilityHidden = 1;
-
- if (Args.hasArg(OPT_fapply_global_visibility_to_externs))
- Opts.SetVisibilityForExternDecls = 1;
-
if (Args.hasArg(OPT_fvisibility_from_dllstorageclass)) {
Opts.VisibilityFromDLLStorageClass = 1;
@@ -2700,7 +2649,6 @@
else if (Args.hasArg(OPT_fwrapv))
Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
- Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
Opts.MSCompatibilityVersion = 0;
@@ -2726,13 +2674,8 @@
Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
OPT_fno_dollars_in_identifiers,
Opts.DollarIdents);
- Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
Opts.setVtorDispMode(
MSVtorDispMode(getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags)));
- Opts.Borland = Args.hasArg(OPT_fborland_extensions);
- Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
- Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
- Opts.ConstStrings);
if (Arg *A = Args.getLastArg(OPT_flax_vector_conversions_EQ)) {
using LaxKind = LangOptions::LaxVectorConversionKind;
if (auto Kind = llvm::StringSwitch<Optional<LaxKind>>(A->getValue())
@@ -2745,12 +2688,6 @@
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue();
}
- if (Args.hasArg(OPT_fno_threadsafe_statics))
- Opts.ThreadsafeStatics = 0;
- Opts.Exceptions = Args.hasArg(OPT_fexceptions);
- Opts.IgnoreExceptions = Args.hasArg(OPT_fignore_exceptions);
- Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
- Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
// -ffixed-point
Opts.FixedPoint =
@@ -2779,14 +2716,10 @@
Opts.WasmExceptions = Opt.matches(options::OPT_fwasm_exceptions);
}
- Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
- Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
-
Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
&& Opts.OpenCLVersion == 200);
- Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
Opts.Coroutines = Opts.CPlusPlus20 || Args.hasArg(OPT_fcoroutines_ts);
Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
@@ -2799,10 +2732,8 @@
Opts.DoubleSquareBracketAttributes);
Opts.CPlusPlusModules = Opts.CPlusPlus20;
- Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
Opts.Modules =
Args.hasArg(OPT_fmodules) || Opts.ModulesTS || Opts.CPlusPlusModules;
- Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
Opts.ModulesDeclUse =
Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
// FIXME: We only need this in C++ modules / Modules TS if we might textually
@@ -2810,13 +2741,9 @@
Opts.ModulesLocalVisibility =
Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS ||
Opts.CPlusPlusModules;
- Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
- Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
Opts.ModulesSearchAll = Opts.Modules &&
!Args.hasArg(OPT_fno_modules_search_all) &&
Args.hasArg(OPT_fmodules_search_all);
- Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
- Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus20);
@@ -2829,16 +2756,9 @@
if (Opts.WCharSize == 0)
Diags.Report(diag::err_fe_invalid_wchar_type) << A->getValue();
}
- Opts.WCharIsSigned = Args.hasFlag(OPT_fsigned_wchar, OPT_fno_signed_wchar, true);
- Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
- Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
if (!Opts.NoBuiltin)
getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
- Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
- Opts.RelaxedTemplateTemplateArgs =
- Args.hasArg(OPT_frelaxed_template_template_args);
- Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
Opts.AlignedAllocation =
Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
Opts.AlignedAllocation);
@@ -2852,16 +2772,8 @@
<< A->getValue();
Opts.NewAlignOverride = 0;
}
- Opts.ConceptSatisfactionCaching =
- !Args.hasArg(OPT_fno_concept_satisfaction_caching);
if (Args.hasArg(OPT_fconcepts_ts))
Diags.Report(diag::warn_fe_concepts_ts_flag);
- Opts.RecoveryAST = Args.hasFlag(OPT_frecovery_ast, OPT_fno_recovery_ast);
- Opts.RecoveryASTType =
- Args.hasFlag(OPT_frecovery_ast_type, OPT_fno_recovery_ast_type);
- Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
- Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
- Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
Opts.InstantiationDepth =
getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
@@ -2871,52 +2783,25 @@
getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
Opts.ConstexprStepLimit =
getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
- Opts.EnableNewConstInterp =
- Args.hasArg(OPT_fexperimental_new_constant_interpreter);
Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
- Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
Opts.NumLargeByValueCopy =
getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
- Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
Opts.ObjCConstantStringClass =
std::string(Args.getLastArgValue(OPT_fconstant_string_class));
- Opts.ObjCDefaultSynthProperties =
- !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
- Opts.EncodeExtendedBlockSig =
- Args.hasArg(OPT_fencode_extended_block_signature);
- Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
- Opts.AlignDouble = Args.hasArg(OPT_malign_double);
Opts.DoubleSize = getLastArgIntValue(Args, OPT_mdouble_EQ, 0, Diags);
Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128)
? 128
: Args.hasArg(OPT_mlong_double_64) ? 64 : 0;
- Opts.PPCIEEELongDouble = Args.hasArg(OPT_mabi_EQ_ieeelongdouble);
Opts.EnableAIXExtendedAltivecABI = Args.hasArg(OPT_mabi_EQ_vec_extabi);
Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
- Opts.ROPI = Args.hasArg(OPT_fropi);
- Opts.RWPI = Args.hasArg(OPT_frwpi);
- Opts.PIE = Args.hasArg(OPT_pic_is_pie);
- Opts.Static = Args.hasArg(OPT_static_define);
- Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
|| Args.hasArg(OPT_fdump_record_layouts);
- Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
- Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
- Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
if (Opts.FastRelaxedMath)
Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
- Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
- Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
- Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
- Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
- Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
- Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
- Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
Opts.ModuleName = std::string(Args.getLastArgValue(OPT_fmodule_name_EQ));
Opts.CurrentModule = Opts.ModuleName;
- Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
llvm::sort(Opts.ModuleFeatures);
Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
@@ -2925,8 +2810,6 @@
// is enabled.
Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
| Opts.NativeHalfArgsAndReturns;
- Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
- Opts.Cmse = Args.hasArg(OPT_mcmse); // Armv8-M Security Extensions
Opts.ArmSveVectorBits =
getLastArgIntValue(Args, options::OPT_msve_vector_bits_EQ, 0, Diags);
@@ -3012,11 +2895,6 @@
Opts.setDefaultCallingConv(DefaultCC);
}
- Opts.SemanticInterposition = Args.hasArg(OPT_fsemantic_interposition);
- // An explicit -fno-semantic-interposition infers dso_local.
- Opts.ExplicitNoSemanticInterposition =
- Args.hasArg(OPT_fno_semantic_interposition);
-
// -mrtd option
if (Arg *A = Args.getLastArg(OPT_mrtd)) {
if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
@@ -3032,8 +2910,6 @@
}
}
- // Check if -fopenmp is specified and set default version to 5.0.
- Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 50 : 0;
// Check if -fopenmp-simd is specified.
bool IsSimdSpecified =
Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
@@ -3088,11 +2964,6 @@
Opts.OpenMPCUDAReductionBufNum, Diags);
}
- // Prevent auto-widening the representation of loop counters during an
- // OpenMP collapse clause.
- Opts.OpenMPOptimisticCollapse =
- Args.hasArg(options::OPT_fopenmp_optimistic_collapse) ? 1 : 0;
-
// Get the OpenMP target triples if any.
if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
@@ -3186,12 +3057,6 @@
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
}
- auto FPRM = llvm::RoundingMode::NearestTiesToEven;
- if (Args.hasArg(OPT_frounding_math)) {
- FPRM = llvm::RoundingMode::Dynamic;
- }
- Opts.setFPRoundingMode(FPRM);
-
if (Args.hasArg(OPT_ftrapping_math)) {
Opts.setFPExceptionMode(LangOptions::FPE_Strict);
}
@@ -3214,9 +3079,6 @@
}
Opts.setFPExceptionMode(FPEB);
- Opts.RetainCommentsFromSystemHeaders =
- Args.hasArg(OPT_fretain_comments_from_system_headers);
-
unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
switch (SSP) {
default:
@@ -3267,14 +3129,6 @@
Args.getAllArgValues(OPT_fxray_never_instrument);
Opts.XRayAttrListFiles = Args.getAllArgValues(OPT_fxray_attr_list);
- // -fforce-emit-vtables
- Opts.ForceEmitVTables = Args.hasArg(OPT_fforce_emit_vtables);
-
- // -fallow-editor-placeholders
- Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);
-
- Opts.RegisterStaticDestructors = !Args.hasArg(OPT_fno_cxx_static_destructors);
-
if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
Opts.setClangABICompat(LangOptions::ClangABI::Latest);
@@ -3310,12 +3164,6 @@
}
}
- Opts.CompleteMemberPointers = Args.hasArg(OPT_fcomplete_member_pointers);
- Opts.BuildingPCHWithObjectFile = Args.hasArg(OPT_building_pch_with_obj);
- Opts.PCHInstantiateTemplates = Args.hasArg(OPT_fpch_instantiate_templates);
-
- Opts.MatrixTypes = Args.hasArg(OPT_fenable_matrix);
-
Opts.MaxTokens = getLastArgIntValue(Args, OPT_fmax_tokens_EQ, 0, Diags);
if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
@@ -3350,17 +3198,6 @@
}
}
- Opts.BranchTargetEnforcement = Args.hasArg(OPT_mbranch_target_enforce);
- Opts.SpeculativeLoadHardening = Args.hasArg(OPT_mspeculative_load_hardening);
-
- Opts.CompatibilityQualifiedIdBlockParamTypeChecking =
- Args.hasArg(OPT_fcompatibility_qualified_id_block_param_type_checking);
-
- Opts.RelativeCXXABIVTables =
- Args.hasFlag(OPT_fexperimental_relative_cxx_abi_vtables,
- OPT_fno_experimental_relative_cxx_abi_vtables,
- /*default=*/false);
-
std::string ThreadModel =
std::string(Args.getLastArgValue(OPT_mthread_model, "posix"));
if (ThreadModel != "posix" && ThreadModel != "single")
@@ -3630,7 +3467,6 @@
}
Success &= Res.parseSimpleArgs(Args, Diags);
- FixupInvocation(Res);
Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args);
@@ -3654,15 +3490,9 @@
llvm::Triple T(Res.getTargetOpts().Triple);
if (DashX.getFormat() == InputKind::Precompiled ||
DashX.getLanguage() == Language::LLVM_IR) {
- // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
- // PassManager in BackendUtil.cpp. They need to be initializd no matter
- // what the input type is.
- if (Args.hasArg(OPT_fobjc_arc))
- LangOpts.ObjCAutoRefCount = 1;
// PIClevel and PIELevel are needed during code generation and this should be
// set regardless of the input type.
LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
- LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
Diags, LangOpts.Sanitize);
} else {
@@ -3723,6 +3553,8 @@
Res.getCodeGenOpts().Argv0 = Argv0;
Res.getCodeGenOpts().CommandLineArgs = CommandLineArgs;
+ FixupInvocation(Res, Diags);
+
return Success;
}
@@ -3850,8 +3682,10 @@
TABLE_INDEX) \
if ((FLAGS)&options::CC1Option) { \
[&](const auto &Extracted) { \
- if (ALWAYS_EMIT || (Extracted != ((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
- : (DEFAULT_VALUE)))) \
+ if (ALWAYS_EMIT || \
+ (Extracted != \
+ static_cast<decltype(this->KEYPATH)>( \
+ (IMPLIED_CHECK) ? (IMPLIED_VALUE) : (DEFAULT_VALUE)))) \
DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, Extracted); \
}(EXTRACTOR(this->KEYPATH)); \
}
Index: clang/include/clang/Driver/Options.td
===================================================================
--- clang/include/clang/Driver/Options.td
+++ clang/include/clang/Driver/Options.td
@@ -905,8 +905,10 @@
def fno_cuda_flush_denormals_to_zero : Flag<["-"], "fno-cuda-flush-denormals-to-zero">;
defm cuda_approx_transcendentals : OptInFFlag<"cuda-approx-transcendentals", "Use", "Don't use",
" approximate transcendental functions">;
-defm gpu_rdc : OptInFFlag<"gpu-rdc",
- "Generate relocatable device code, also known as separate compilation mode", "", "">;
+defm gpu_rdc : BoolFOption<"gpu-rdc",
+ "LangOpts->GPURelocatableDeviceCode", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Generate relocatable device code, also known as separate compilation mode">,
+ ResetBy<NegFlag>>;
def : Flag<["-"], "fcuda-rdc">, Alias<fgpu_rdc>;
def : Flag<["-"], "fno-cuda-rdc">, Alias<fno_gpu_rdc>;
defm cuda_short_ptr : OptInFFlag<"cuda-short-ptr",
@@ -923,16 +925,21 @@
HelpText<"HIP version in the format of major.minor.patch">;
def fhip_dump_offload_linker_script : Flag<["-"], "fhip-dump-offload-linker-script">,
Group<f_Group>, Flags<[NoArgumentUnused, HelpHidden]>;
-defm hip_new_launch_api : OptInFFlag<"hip-new-launch-api",
- "Use", "Don't use", " new kernel launching API for HIP">;
+defm hip_new_launch_api : BoolFOption<"hip-new-launch-api",
+ "LangOpts->HIPUseNewLaunchAPI", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Don't use">,
+ BothFlags<[], " new kernel launching API for HIP">>;
defm gpu_allow_device_init : OptInFFlag<"gpu-allow-device-init",
"Allow", "Don't allow", " device side init function in HIP">;
-defm gpu_defer_diag : OptInFFlag<"gpu-defer-diag",
- "Defer", "Don't defer", " host/device related diagnostic messages"
- " for CUDA/HIP">;
-defm gpu_exclude_wrong_side_overloads : OptInFFlag<"gpu-exclude-wrong-side-overloads",
- "Always exclude wrong side overloads", "Exclude wrong side overloads only if there are same side overloads",
- " in overloading resolution for CUDA/HIP", [HelpHidden]>;
+defm gpu_defer_diag : BoolFOption<"gpu-defer-diag",
+ "LangOpts->GPUDeferDiag", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Defer">, ResetBy<NegFlag, [], "Don't defer">,
+ BothFlags<[], " host/device related diagnostic messages for CUDA/HIP">>;
+defm gpu_exclude_wrong_side_overloads : BoolFOption<"gpu-exclude-wrong-side-overloads",
+ "LangOpts->GPUExcludeWrongSideOverloads", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Always exclude wrong side overloads">,
+ ResetBy<NegFlag, [], "Exclude wrong side overloads only if there are same side overloads">,
+ BothFlags<[HelpHidden], " in overloading resolution for CUDA/HIP">>;
def gpu_max_threads_per_block_EQ : Joined<["--"], "gpu-max-threads-per-block=">,
Flags<[CC1Option]>,
HelpText<"Default max threads per block for kernel launch bounds for HIP">;
@@ -985,16 +992,25 @@
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 access_control : OptOutFFlag<"access-control", "", "Disable C++ access control">;
+defm access_control : BoolFOption<"access-control",
+ "LangOpts->AccessControl", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Disable C++ access control">,
+ ResetBy<PosFlag>>;
def falign_functions : Flag<["-"], "falign-functions">, Group<f_Group>;
def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<f_Group>;
def fno_align_functions: Flag<["-"], "fno-align-functions">, Group<f_Group>;
-defm allow_editor_placeholders : OptInFFlag<"allow-editor-placeholders", "Treat editor placeholders as valid source code">;
+defm allow_editor_placeholders : BoolFOption<"allow-editor-placeholders",
+ "LangOpts->AllowEditorPlaceholders", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Treat editor placeholders as valid source code">,
+ ResetBy<NegFlag>>;
def fallow_unsupported : Flag<["-"], "fallow-unsupported">, Group<f_Group>;
def fapple_kext : Flag<["-"], "fapple-kext">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Use Apple's kernel extensions ABI">;
-def fapple_pragma_pack : Flag<["-"], "fapple-pragma-pack">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Enable Apple gcc-compatible #pragma pack handling">;
+ HelpText<"Use Apple's kernel extensions ABI">,
+ MarshallingInfoFlag<"LangOpts->AppleKext">;
+defm apple_pragma_pack : BoolFOption<"apple-pragma-pack",
+ "LangOpts->ApplePragmaPack", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable Apple gcc-compatible #pragma pack handling">,
+ ResetBy<NegFlag>>;
def shared_libsan : Flag<["-"], "shared-libsan">,
HelpText<"Dynamically link the sanitizer runtime">;
def static_libsan : Flag<["-"], "static-libsan">,
@@ -1034,7 +1050,9 @@
def fembed_bitcode_marker : Flag<["-"], "fembed-bitcode-marker">,
Alias<fembed_bitcode_EQ>, AliasArgs<["marker"]>,
HelpText<"Embed placeholder LLVM IR data as a marker">;
-defm gnu_inline_asm : OptOutFFlag<"gnu-inline-asm", "", "Disable GNU style inline asm">;
+defm gnu_inline_asm : BoolFOption<"gnu-inline-asm",
+ "LangOpts->GNUAsm", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Disable GNU style inline asm">, ResetBy<PosFlag>>;
def fprofile_sample_use : Flag<["-"], "fprofile-sample-use">, Group<f_Group>,
Flags<[CoreOption]>;
@@ -1145,8 +1163,10 @@
BothFlags<[CoreOption], " an address-significance table">>;
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]>,
- HelpText<"Accept non-standard constructs supported by the Borland compiler">;
+defm borland_extensions : BoolFOption<"borland-extensions",
+ "LangOpts->Borland", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Accept non-standard constructs supported by the Borland compiler">,
+ ResetBy<NegFlag>>;
def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>, Flags<[CoreOption]>;
def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>,
Flags<[NoXarchOption]>, HelpText<"Load the clang builtins module map file.">;
@@ -1178,27 +1198,33 @@
Flags<[CoreOption, CC1Option]>, HelpText<"Place uninitialized global variables in a common block">,
MarshallingInfoFlag<"CodeGenOpts.NoCommon", "true">, IsNegative;
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]>,
- HelpText<"Require member pointer base types to be complete if they would be significant under the Microsoft ABI">;
-def fno_complete_member_pointers : Flag<["-"], "fno-complete-member-pointers">, Group<f_clang_Group>,
- Flags<[CoreOption]>,
- HelpText<"Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI">;
+defm complete_member_pointers : BoolOption<"complete-member-pointers",
+ "LangOpts->CompleteMemberPointers", DefaultsToFalse,
+ ChangedBy<PosFlag, [CC1Option], "Require">, ResetBy<NegFlag, [], "Do not require">,
+ BothFlags<[CoreOption], " member pointer base types to be complete if they"
+ " would be significant under the Microsoft ABI">, "f">,
+ Group<f_clang_Group>;
def fcf_runtime_abi_EQ : Joined<["-"], "fcf-runtime-abi=">, Group<f_Group>,
Flags<[CC1Option]>;
-def fconstant_cfstrings : Flag<["-"], "fconstant-cfstrings">, Group<f_Group>;
+defm constant_cfstrings : BoolFOption<"constant-cfstrings",
+ "LangOpts->NoConstantCFStrings", DefaultsToFalse,
+ ChangedBy<NegFlag, [], "Disable creation of CodeFoundation-type constant strings">,
+ ResetBy<PosFlag>>;
def fconstant_string_class_EQ : Joined<["-"], "fconstant-string-class=">, Group<f_Group>;
def fconstexpr_depth_EQ : Joined<["-"], "fconstexpr-depth=">, Group<f_Group>;
def fconstexpr_steps_EQ : Joined<["-"], "fconstexpr-steps=">, Group<f_Group>;
def fexperimental_new_constant_interpreter : Flag<["-"], "fexperimental-new-constant-interpreter">, Group<f_Group>,
- HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>;
+ HelpText<"Enable the experimental new constant interpreter">, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->EnableNewConstInterp">;
def fconstexpr_backtrace_limit_EQ : Joined<["-"], "fconstexpr-backtrace-limit=">,
Group<f_Group>;
def fno_crash_diagnostics : Flag<["-"], "fno-crash-diagnostics">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>,
HelpText<"Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash">;
def fcrash_diagnostics_dir : Joined<["-"], "fcrash-diagnostics-dir=">, Group<f_clang_Group>, Flags<[NoArgumentUnused, CoreOption]>;
def fcreate_profile : Flag<["-"], "fcreate-profile">, Group<f_Group>;
-defm cxx_exceptions: OptInFFlag<"cxx-exceptions", "Enable C++ exceptions">;
+defm cxx_exceptions: BoolFOption<"cxx-exceptions",
+ "LangOpts->CXXExceptions", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable C++ exceptions">, ResetBy<NegFlag>>;
def fcxx_modules : Flag <["-"], "fcxx-modules">, Group<f_Group>,
Flags<[NoXarchOption]>;
def fdebug_pass_arguments : Flag<["-"], "fdebug-pass-arguments">, Group<f_Group>;
@@ -1241,7 +1267,10 @@
defm dwarf_directory_asm : BoolFOption<"dwarf-directory-asm",
"CodeGenOpts.NoDwarfDirectoryAsm", DefaultsToFalse,
ChangedBy<NegFlag>, ResetBy<PosFlag>>;
-def felide_constructors : Flag<["-"], "felide-constructors">, Group<f_Group>;
+defm elide_constructors : BoolFOption<"elide-constructors",
+ "LangOpts->ElideConstructors", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Disable C++ copy constructor elision">,
+ ResetBy<PosFlag>>;
def fno_elide_type : Flag<["-"], "fno-elide-type">, Group<f_Group>,
Flags<[CC1Option]>,
HelpText<"Do not elide types when printing diagnostics">;
@@ -1249,13 +1278,17 @@
defm eliminate_unused_debug_types : OptOutFFlag<"eliminate-unused-debug-types",
"Do not emit ", "Emit ", " debug info for defined but unused types">;
def femit_all_decls : Flag<["-"], "femit-all-decls">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Emit all declarations, even if unused">;
+ HelpText<"Emit all declarations, even if unused">,
+ MarshallingInfoFlag<"LangOpts->EmitAllDecls">;
def femulated_tls : Flag<["-"], "femulated-tls">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Use emutls functions to access thread_local variables">;
def fno_emulated_tls : Flag<["-"], "fno-emulated-tls">, Group<f_Group>, Flags<[CC1Option]>;
def fencoding_EQ : Joined<["-"], "fencoding=">, Group<f_Group>;
def ferror_limit_EQ : Joined<["-"], "ferror-limit=">, Group<f_Group>, Flags<[CoreOption]>;
-defm exceptions : OptInFFlag<"exceptions", "Enable", "Disable", " support for exception handling">;
+defm exceptions : BoolFOption<"exceptions",
+ "LangOpts->Exceptions", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable">, ResetBy<NegFlag, [], "Disable">,
+ BothFlags<[], " support for exception handling">>;
def fdwarf_exceptions : Flag<["-"], "fdwarf-exceptions">, Group<f_Group>,
Flags<[CC1Option]>, HelpText<"Use DWARF style exceptions">;
def fsjlj_exceptions : Flag<["-"], "fsjlj-exceptions">, Group<f_Group>,
@@ -1265,7 +1298,8 @@
def fwasm_exceptions : Flag<["-"], "fwasm-exceptions">, Group<f_Group>,
Flags<[CC1Option]>, HelpText<"Use WebAssembly style exceptions">;
def fignore_exceptions : Flag<["-"], "fignore-exceptions">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Enable support for ignoring exception handling constructs">;
+ HelpText<"Enable support for ignoring exception handling constructs">,
+ MarshallingInfoFlag<"LangOpts->IgnoreExceptions">;
def fexcess_precision_EQ : Joined<["-"], "fexcess-precision=">,
Group<clang_ignored_gcc_optimization_f_Group>;
def : Flag<["-"], "fexpensive-optimizations">, Group<clang_ignored_gcc_optimization_f_Group>;
@@ -1301,8 +1335,10 @@
ChangedBy<PosFlag, [], "Keep">, ResetBy<NegFlag, [], "Don't keep">,
BothFlags<[NoXarchOption], " static const variables if unused">>;
defm fixed_point : OptInFFlag<"fixed-point", "Enable", "Disable", " fixed point types">;
-defm cxx_static_destructors : OptOutFFlag<"c++-static-destructors", "",
- "Disable C++ static destructor registration">;
+defm cxx_static_destructors : BoolFOption<"c++-static-destructors",
+ "LangOpts->RegisterStaticDestructors", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Disable C++ static destructor registration">,
+ ResetBy<PosFlag>>;
def fsymbol_partition_EQ : Joined<["-"], "fsymbol-partition=">, Group<f_Group>,
Flags<[CC1Option]>;
@@ -1510,7 +1546,9 @@
// This option was originally misspelt "infinites" [sic].
def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
-def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>;
+def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->FPRoundingMode", "llvm::RoundingMode::NearestTiesToEven">,
+ Normalizer<"makeFlagToValueNormalizer(llvm::RoundingMode::Dynamic)">;
def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>;
def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>, Flags<[CC1Option]>;
def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>, Flags<[CC1Option]>;
@@ -1551,7 +1589,8 @@
defm use_line_directives : OptInFFlag<"use-line-directives", "Use #line in preprocessed output">;
def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Assert that the compilation takes place in a freestanding environment">;
+ HelpText<"Assert that the compilation takes place in a freestanding environment">,
+ MarshallingInfoFlag<"LangOpts->Freestanding">;
def fgnuc_version_EQ : Joined<["-"], "fgnuc-version=">, Group<f_Group>,
HelpText<"Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)">,
Flags<[CC1Option, CoreOption]>;
@@ -1560,7 +1599,8 @@
defm gnu89_inline : OptInFFlag<"gnu89-inline", "Use the gnu89 inline semantics">;
def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>,
HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;
-def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>;
+def fheinous_gnu_extensions : Flag<["-"], "fheinous-gnu-extensions">, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->HeinousExtensions">;
def filelist : Separate<["-"], "filelist">, Flags<[LinkerInput]>,
Group<Link_Group>;
def : Flag<["-"], "findirect-virtual-calls">, Alias<fapple_kext>;
@@ -1670,12 +1710,10 @@
BothFlags<[CC1Option]>, "f">,
Group<f_clang_Group>;
-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">;
-def fno_experimental_relative_cxx_abi_vtables : Flag<["-"], "fno-experimental-relative-c++-abi-vtables">,
- Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Do not use the experimental C++ class ABI for classes with virtual tables">;
+defm experimental_relative_cxx_abi_vtables : BoolFOption<"experimental-relative-c++-abi-vtables",
+ "LangOpts->RelativeCXXABIVTables", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Do not use">,
+ BothFlags<[CC1Option], " the experimental C++ class ABI for classes with virtual tables">>;
def flat__namespace : Flag<["-"], "flat_namespace">;
def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Group<f_Group>,
@@ -1713,7 +1751,8 @@
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">;
+ HelpText<"Enable full Microsoft Visual C++ compatibility">,
+ MarshallingInfoFlag<"LangOpts->MSVCCompat">;
def fms_volatile : Flag<["-"], "fms-volatile">, Group<f_Group>, Flags<[CC1Option]>,
MarshallingInfoFlag<"CodeGenOpts.MSVolatile">;
def fmsc_version : Joined<["-"], "fmsc-version=">, Group<f_Group>, Flags<[NoXarchOption, CoreOption]>,
@@ -1725,9 +1764,11 @@
HelpText<"Dot-separated value representing the Microsoft compiler "
"version number to report in _MSC_VER (0 = don't define it "
"(default))">;
-def fdelayed_template_parsing : Flag<["-"], "fdelayed-template-parsing">, Group<f_Group>,
- HelpText<"Parse templated function definitions at the end of the "
- "translation unit">, Flags<[CC1Option, CoreOption]>;
+defm delayed_template_parsing : BoolFOption<"delayed-template-parsing",
+ "LangOpts->DelayedTemplateParsing", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Parse templated function definitions at the end of the translation unit">,
+ ResetBy<NegFlag, [NoXarchOption], "Disable delayed template parsing">,
+ BothFlags<[CoreOption]>>;
def fms_memptr_rep_EQ : Joined<["-"], "fms-memptr-rep=">, Group<f_Group>, Flags<[CC1Option]>;
def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
Flags<[NoXarchOption, CC1Option]>, MetaVarName<"<directory>">,
@@ -1791,13 +1832,10 @@
def fno_pch_validate_input_files_content:
Flag <["-"], "fno_pch-validate-input-files-content">,
Group<f_Group>, Flags<[NoXarchOption]>;
-def fpch_instantiate_templates:
- Flag <["-"], "fpch-instantiate-templates">,
- Group<f_Group>, Flags<[CC1Option, CoreOption]>,
- HelpText<"Instantiate templates already while building a PCH">;
-def fno_pch_instantiate_templates:
- Flag <["-"], "fno-pch-instantiate-templates">,
- Group<f_Group>, Flags<[CC1Option, CoreOption]>;
+defm pch_instantiate_templates : BoolFOption<"pch-instantiate-templates",
+ "LangOpts->PCHInstantiateTemplates", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Instantiate templates already while building a PCH">,
+ ResetBy<NegFlag>, BothFlags<[CC1Option, CoreOption]>>;
defm pch_codegen: OptInFFlag<"pch-codegen", "Generate ", "Do not generate ",
"code for uses of this PCH that assumes an explicit object file will be built for the PCH">;
defm pch_debuginfo: OptInFFlag<"pch-debuginfo", "Generate ", "Do not generate ",
@@ -1811,7 +1849,8 @@
HelpText<"Implicitly search the file system for module map files.">,
MarshallingInfoFlag<"HeaderSearchOpts->ImplicitModuleMaps">;
def fmodules_ts : Flag <["-"], "fmodules-ts">, Group<f_Group>,
- Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">;
+ Flags<[CC1Option]>, HelpText<"Enable support for the C++ Modules TS">,
+ MarshallingInfoFlag<"LangOpts->ModulesTS">;
def fmodule_maps : Flag <["-"], "fmodule-maps">, Alias<fimplicit_module_maps>;
def fmodule_name_EQ : Joined<["-"], "fmodule-name=">, Group<f_Group>,
Flags<[NoXarchOption,CC1Option]>, MetaVarName<"<name>">,
@@ -1835,25 +1874,25 @@
HelpText<"Require declaration of modules used within a module">;
def fmodules_strict_decluse : Flag <["-"], "fmodules-strict-decluse">, Group<f_Group>,
Flags<[NoXarchOption,CC1Option]>,
- HelpText<"Like -fmodules-decluse but requires all headers to be in modules">;
+ HelpText<"Like -fmodules-decluse but requires all headers to be in modules">,
+ MarshallingInfoFlag<"LangOpts->ModulesStrictDeclUse">;
def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>,
Flags<[NoXarchOption, CC1Option]>;
-def fno_implicit_modules :
- Flag <["-"], "fno-implicit-modules">,
- Group<f_Group>, Flags<[NoXarchOption, CC1Option]>;
-def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>;
+defm implicit_modules : BoolFOption<"implicit-modules",
+ "LangOpts->ImplicitModules", DefaultsToTrue,
+ ChangedBy<NegFlag>, ResetBy<PosFlag>, BothFlags<[NoXarchOption]>>;
+def fretain_comments_from_system_headers : Flag<["-"], "fretain-comments-from-system-headers">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->RetainCommentsFromSystemHeaders">;
def fmudflapth : Flag<["-"], "fmudflapth">, Group<f_Group>;
def fmudflap : Flag<["-"], "fmudflap">, Group<f_Group>;
def fnested_functions : Flag<["-"], "fnested-functions">, Group<f_Group>;
def fnext_runtime : Flag<["-"], "fnext-runtime">, Group<f_Group>;
-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]>, MarshallingInfoFlag<"CodeGenOpts.AssumeSaneOperatorNew", "true">, IsNegative;
-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">;
def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<f_Group>, Flags<[CC1Option, CoreOption]>,
@@ -1862,9 +1901,6 @@
Flags<[CoreOption, NoXarchOption]>;
def fno_common : Flag<["-"], "fno-common">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Compile common globals like normal definitions">;
-def fno_constant_cfstrings : Flag<["-"], "fno-constant-cfstrings">, Group<f_Group>,
- Flags<[CC1Option]>,
- HelpText<"Disable creation of CodeFoundation-type constant strings">;
def fno_cxx_modules : Flag <["-"], "fno-cxx-modules">, Group<f_Group>,
Flags<[NoXarchOption]>;
def fno_diagnostics_fixit_info : Flag<["-"], "fno-diagnostics-fixit-info">, Group<f_Group>,
@@ -1880,8 +1916,6 @@
HelpText<"Disallow __declspec as a keyword">, Flags<[CC1Option]>;
def fno_dollars_in_identifiers : Flag<["-"], "fno-dollars-in-identifiers">, Group<f_Group>,
HelpText<"Disallow '$' in identifiers">, Flags<[CC1Option]>;
-def fno_elide_constructors : Flag<["-"], "fno-elide-constructors">, Group<f_Group>,
- HelpText<"Disable C++ copy constructor elision">, Flags<[CC1Option]>;
def fno_eliminate_unused_debug_symbols : Flag<["-"], "fno-eliminate-unused-debug-symbols">, Group<f_Group>;
def fno_gnu_keywords : Flag<["-"], "fno-gnu-keywords">, Group<f_Group>, Flags<[CC1Option]>;
def fno_inline_functions : Flag<["-"], "fno-inline-functions">, Group<f_clang_Group>, Flags<[CC1Option]>;
@@ -1903,8 +1937,6 @@
Flags<[NoXarchOption]>;
def fno_modules_strict_decluse : Flag <["-"], "fno-strict-modules-decluse">, Group<f_Group>,
Flags<[NoXarchOption]>;
-def fimplicit_modules : Flag <["-"], "fimplicit-modules">, Group<f_Group>,
- Flags<[NoXarchOption]>;
def fmodule_file_deps : Flag <["-"], "fmodule-file-deps">, Group<f_Group>,
Flags<[NoXarchOption]>;
def fno_module_file_deps : Flag <["-"], "fno-module-file-deps">, Group<f_Group>,
@@ -1913,24 +1945,16 @@
Flags<[CoreOption]>;
def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>,
Flags<[CoreOption]>;
-def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>,
- HelpText<"Disable delayed template parsing">,
- Flags<[NoXarchOption, CoreOption]>;
-def fno_objc_exceptions: Flag<["-"], "fno-objc-exceptions">, Group<f_Group>;
def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>;
def fno_objc_weak : Flag<["-"], "fno-objc-weak">, Group<f_Group>, Flags<[CC1Option]>;
def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>,
HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,
Flags<[CC1Option]>;
-def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>;
-def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>;
def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>,
Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;
def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">;
-def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
- Flags<[CC1Option]>, HelpText<"Disable spell-checking">;
def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
HelpText<"Disable the use of stack protectors">;
def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>,
@@ -1943,8 +1967,6 @@
Flags<[CC1Option, CoreOption]>, HelpText<
"Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes">,
MarshallingInfoFlag<"FrontendOpts.UseTemporary", "true">, IsNegative;
-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">;
defm use_cxa_atexit : BoolFOption<"use-cxa-atexit",
"CodeGenOpts.CXAAtExit", DefaultsToTrue,
ChangedBy<NegFlag, [], "Don't use __cxa_atexit for calling destructors">,
@@ -1955,9 +1977,10 @@
MarshallingInfoFlag<"CodeGenOpts.AsmVerbose", "true">, IsNegative;
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>;
+defm objc_arc : BoolFOption<"objc-arc",
+ "LangOpts->ObjCAutoRefCount", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Synthesize retain and release calls for Objective-C pointers">,
+ ResetBy<NegFlag>>;
defm objc_convert_messages_to_runtime_calls : BoolFOption<"objc-convert-messages-to-runtime-calls",
"CodeGenOpts.ObjCConvertMessagesToRuntimeCalls", DefaultsToTrue,
ChangedBy<NegFlag>, ResetBy<PosFlag>>;
@@ -1966,21 +1989,21 @@
"", "", [], "CodeGenOpts.ObjCAutoRefCountExceptions">;
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>,
- HelpText<"Enable Objective-C exceptions">, Flags<[CC1Option]>;
-def fapplication_extension : Flag<["-"], "fapplication-extension">,
- Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Restrict code to those available for App Extensions">;
-def fno_application_extension : Flag<["-"], "fno-application-extension">,
- Group<f_Group>;
-def frelaxed_template_template_args : Flag<["-"], "frelaxed-template-template-args">,
- Flags<[CC1Option]>, HelpText<"Enable C++17 relaxed template template argument matching">,
- Group<f_Group>;
-def fno_relaxed_template_template_args : Flag<["-"], "fno-relaxed-template-template-args">,
- Group<f_Group>;
-def fsized_deallocation : Flag<["-"], "fsized-deallocation">, Flags<[CC1Option]>,
- HelpText<"Enable C++14 sized global deallocation functions">, Group<f_Group>;
-def fno_sized_deallocation: Flag<["-"], "fno-sized-deallocation">, Group<f_Group>;
+defm objc_exceptions : BoolFOption<"objc-exceptions",
+ "LangOpts->ObjCExceptions", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable Objective-C exceptions">, ResetBy<NegFlag>>;
+defm application_extension : BoolFOption<"application-extension",
+ "LangOpts->AppExt", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Restrict code to those available for App Extensions">,
+ ResetBy<NegFlag>>;
+defm relaxed_template_template_args : BoolFOption<"relaxed-template-template-args",
+ "LangOpts->RelaxedTemplateTemplateArgs", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable C++17 relaxed template template argument matching">,
+ ResetBy<NegFlag>>;
+defm sized_deallocation : BoolFOption<"sized-deallocation",
+ "LangOpts->SizedDeallocation", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable C++14 sized global deallocation functions">,
+ ResetBy<NegFlag>>;
def faligned_allocation : Flag<["-"], "faligned-allocation">, Flags<[CC1Option]>,
HelpText<"Enable C++17 aligned allocation functions">, Group<f_Group>;
def fno_aligned_allocation: Flag<["-"], "fno-aligned-allocation">,
@@ -1995,13 +2018,10 @@
def fobjc_legacy_dispatch : Flag<["-"], "fobjc-legacy-dispatch">, Group<f_Group>;
def fobjc_new_property : Flag<["-"], "fobjc-new-property">, Group<clang_ignored_f_Group>;
-def fobjc_infer_related_result_type : Flag<["-"], "fobjc-infer-related-result-type">,
- Group<f_Group>;
-def fno_objc_infer_related_result_type : Flag<["-"],
- "fno-objc-infer-related-result-type">, Group<f_Group>,
- HelpText<
- "do not infer Objective-C related result type based on method family">,
- Flags<[CC1Option]>;
+defm objc_infer_related_result_type : BoolFOption<"objc-infer-related-result-type",
+ "LangOpts->ObjCInferRelatedResultType", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "do not infer Objective-C related result type based on method family">,
+ ResetBy<PosFlag>>;
def fobjc_link_runtime: Flag<["-"], "fobjc-link-runtime">, Group<f_Group>;
def fobjc_weak : Flag<["-"], "fobjc-weak">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Enable ARC-style weak references in Objective-C">;
@@ -2017,7 +2037,8 @@
def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
- HelpText<"Parse OpenMP pragmas and generate parallel code.">;
+ HelpText<"Parse OpenMP pragmas and generate parallel code.">,
+ MarshallingInfoFlag<"LangOpts->OpenMP", "0u">, Normalizer<"makeFlagToValueNormalizer(50u)">;
def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;
@@ -2050,10 +2071,9 @@
Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
def fopenmp_cuda_teams_reduction_recs_num_EQ : Joined<["-"], "fopenmp-cuda-teams-reduction-recs-num=">, Group<f_Group>,
Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
-def fopenmp_optimistic_collapse : Flag<["-"], "fopenmp-optimistic-collapse">, Group<f_Group>,
- Flags<[CC1Option, NoArgumentUnused, HelpHidden]>;
-def fno_openmp_optimistic_collapse : Flag<["-"], "fno-openmp-optimistic-collapse">, Group<f_Group>,
- Flags<[NoArgumentUnused, HelpHidden]>;
+defm openmp_optimistic_collapse : BoolFOption<"openmp-optimistic-collapse",
+ "LangOpts->OpenMPOptimisticCollapse", DefaultsToFalse,
+ ChangedBy<PosFlag>, ResetBy<NegFlag>, BothFlags<[NoArgumentUnused, HelpHidden]>>;
def fopenmp_cuda_parallel_target_regions : Flag<["-"], "fopenmp-cuda-parallel-target-regions">, Group<f_Group>,
Flags<[CC1Option, NoArgumentUnused, HelpHidden]>,
HelpText<"Support parallel execution of target regions on Cuda-based devices.">;
@@ -2079,8 +2099,10 @@
def fmax_type_align_EQ : Joined<["-"], "fmax-type-align=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Specify the maximum alignment to enforce on pointers lacking an explicit alignment">;
def fno_max_type_align : Flag<["-"], "fno-max-type-align">, Group<f_Group>;
-def fpascal_strings : Flag<["-"], "fpascal-strings">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Recognize and construct Pascal-style string literals">;
+defm pascal_strings : BoolFOption<"pascal-strings",
+ "LangOpts->PascalStrings", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Recognize and construct Pascal-style string literals">,
+ ResetBy<NegFlag>>;
def fpatchable_function_entry_EQ : Joined<["-"], "fpatchable-function-entry=">, Group<f_Group>, Flags<[CC1Option]>,
MetaVarName<"<N,M>">, HelpText<"Generate M NOPs before function entry and N-M NOPs after function entry">;
def fpcc_struct_return : Flag<["-"], "fpcc-struct-return">, Group<f_Group>, Flags<[CC1Option]>,
@@ -2094,8 +2116,14 @@
"CodeGenOpts.NoPLT", DefaultsToFalse,
ChangedBy<NegFlag, [], "Use GOT indirection instead of PLT to make external function calls (x86 only)">,
ResetBy<PosFlag>>;
-defm ropi : OptInFFlag<"ropi", "Generate read-only position independent code (ARM only)">;
-defm rwpi : OptInFFlag<"rwpi", "Generate read-write position independent code (ARM only)">;
+defm ropi : BoolFOption<"ropi",
+ "LangOpts->ROPI", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Generate read-only position independent code (ARM only)">,
+ ResetBy<NegFlag>>;
+defm rwpi : BoolFOption<"rwpi",
+ "LangOpts->RWPI", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Generate read-write position independent code (ARM only)">,
+ ResetBy<NegFlag>>;
def fplugin_EQ : Joined<["-"], "fplugin=">, Group<f_Group>, Flags<[NoXarchOption]>, MetaVarName<"<dsopath>">,
HelpText<"Load the named plugin (dynamic shared object)">;
def fpass_plugin_EQ : Joined<["-"], "fpass-plugin=">,
@@ -2115,8 +2143,11 @@
defm rtti : OptOutFFlag<"rtti", "", "Disable generation of rtti information">;
defm rtti_data : OptOutFFlag<"rtti-data", "", "Disable generation of RTTI data">;
def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
-def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
+defm short_enums : BoolFOption<"short-enums",
+ "LangOpts->ShortEnums", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Allocate to an enum type only as many bytes as it"
+ " needs for the declared range of possible values">,
+ ResetBy<NegFlag>>;
def fchar8__t : Flag<["-"], "fchar8_t">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Enable C++ builtin type char8_t">;
def fno_char8__t : Flag<["-"], "fno-char8_t">, Group<f_Group>, Flags<[CC1Option]>,
@@ -2130,7 +2161,9 @@
"best|all; defaults to all">, Values<"best,all">;
defm show_column : OptOutFFlag<"show-column", "", "Do not include column number on diagnostics">;
def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>;
-def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
+defm spell_checking : BoolFOption<"spell-checking",
+ "LangOpts->SpellChecking", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Disable spell-checking">, ResetBy<PosFlag>>;
def fspell_checking_limit_EQ : Joined<["-"], "fspell-checking-limit=">, Group<f_Group>;
def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>;
defm signed_char : OptOutFFlag<"signed-char", "char is signed", "char is unsigned">;
@@ -2238,7 +2271,10 @@
def Wframe_larger_than_EQ : Joined<["-"], "Wframe-larger-than=">, Group<f_Group>, Flags<[NoXarchOption]>;
def : Flag<["-"], "fterminated-vtables">, Alias<fapple_kext>;
-def fthreadsafe_statics : Flag<["-"], "fthreadsafe-statics">, Group<f_Group>;
+defm threadsafe_statics : BoolFOption<"threadsafe-statics",
+ "LangOpts->ThreadsafeStatics", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Do not emit code to make initialization of local statics thread safe">,
+ ResetBy<PosFlag>>;
def ftime_report : Flag<["-"], "ftime-report">, Group<f_Group>, Flags<[CC1Option]>,
MarshallingInfoFlag<"CodeGenOpts.TimePasses">;
def ftime_report_EQ: Joined<["-"], "ftime-report=">, Group<f_Group>,
@@ -2311,23 +2347,19 @@
HelpText<"Set the default symbol visibility for all global declarations">, Values<"hidden,default">;
def fvisibility_inlines_hidden : Flag<["-"], "fvisibility-inlines-hidden">, Group<f_Group>,
HelpText<"Give inline C++ member functions hidden visibility by default">,
- Flags<[CC1Option]>;
-def fvisibility_inlines_hidden_static_local_var :
- Flag<["-"], "fvisibility-inlines-hidden-static-local-var">, Group<f_Group>,
- HelpText<"When -fvisibility-inlines-hidden is enabled, static variables in "
- "inline C++ member functions will also be given hidden visibility "
- "by default">,
- Flags<[CC1Option]>;
-def fno_visibility_inlines_hidden_static_local_var :
- Flag<["-"], "fno-visibility-inlines-hidden-static-local-var">, Group<f_Group>,
- HelpText<"Disables -fvisibility-inlines-hidden-static-local-var "
- "(this is the default on non-darwin targets)">,
- Flags<[CC1Option]>;
+ Flags<[CC1Option]>, MarshallingInfoFlag<"LangOpts->InlineVisibilityHidden">;
+defm visibility_inlines_hidden_static_local_var : BoolFOption<"visibility-inlines-hidden-static-local-var",
+ "LangOpts->VisibilityInlinesHiddenStaticLocalVar", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "When -fvisibility-inlines-hidden is enabled, static variables in"
+ " inline C++ member functions will also be given hidden visibility by default">,
+ ResetBy<NegFlag, [], "Disables -fvisibility-inlines-hidden-static-local-var"
+ " (this is the default on non-darwin targets)">, BothFlags<[CC1Option]>>;
def fvisibility_ms_compat : Flag<["-"], "fvisibility-ms-compat">, Group<f_Group>,
HelpText<"Give global types 'default' visibility and global functions and "
"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]>;
+ HelpText<"Give global C++ operator new and delete declarations hidden visibility">, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->GlobalAllocationFunctionVisibilityHidden">;
defm whole_program_vtables : BoolFOption<"whole-program-vtables",
"CodeGenOpts.WholeProgramVTables", DefaultsToFalse,
ChangedBy<PosFlag, [], "Enables whole-program vtable optimization. Requires -flto">,
@@ -2348,7 +2380,8 @@
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">;
+ HelpText<"Store string literals as writable data">,
+ MarshallingInfoFlag<"LangOpts->WritableStrings">;
defm zero_initialized_in_bss : BoolFOption<"zero-initialized-in-bss",
"CodeGenOpts.NoZeroInitializedInBSS", DefaultsToFalse,
ChangedBy<NegFlag, [], "Don't place zero initialized data in BSS">,
@@ -2394,7 +2427,8 @@
def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_Group>,
Flags<[CC1Option]>,
- HelpText<"Enable matrix data type and related builtin functions">;
+ HelpText<"Enable matrix data type and related builtin functions">,
+ MarshallingInfoFlag<"LangOpts->MatrixTypes">;
def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
@@ -2578,7 +2612,8 @@
def m16 : Flag<["-"], "m16">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[NoXarchOption,CC1Option]>,
- HelpText<"Enable hexagon-qdsp6 backward compatibility">;
+ HelpText<"Enable hexagon-qdsp6 backward compatibility">,
+ MarshallingInfoFlag<"LangOpts->HexagonQdsp6Compat">;
def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
@@ -2651,7 +2686,8 @@
def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>,
- HelpText<"Align doubles to two words in structs (x86 only)">;
+ HelpText<"Align doubles to two words in structs (x86 only)">,
+ MarshallingInfoFlag<"LangOpts->AlignDouble">;
def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">;
def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
@@ -2675,7 +2711,8 @@
def mmacos_version_min_EQ : Joined<["-"], "mmacos-version-min=">,
Group<m_Group>, Alias<mmacosx_version_min_EQ>;
def mms_bitfields : Flag<["-"], "mms-bitfields">, Group<m_Group>, Flags<[CC1Option]>,
- HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">;
+ HelpText<"Set the default structure layout to be compatible with the Microsoft compiler standard">,
+ MarshallingInfoFlag<"LangOpts->MSBitfields">;
def moutline : Flag<["-"], "moutline">, Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Enable function outlining (AArch64 only)">;
def mno_outline : Flag<["-"], "mno-outline">, Group<f_clang_Group>, Flags<[CC1Option]>,
@@ -2715,11 +2752,10 @@
def mretpoline : Flag<["-"], "mretpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>;
def mno_retpoline : Flag<["-"], "mno-retpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>;
-def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">,
- Group<m_Group>, Flags<[CoreOption,CC1Option]>,
- MarshallingInfoFlag<"CodeGenOpts.SpeculativeLoadHardening">;
-def mno_speculative_load_hardening : Flag<["-"], "mno-speculative-load-hardening">,
- Group<m_Group>, Flags<[CoreOption]>;
+defm speculative_load_hardening : BoolOption<"speculative-load-hardening",
+ "CodeGenOpts.SpeculativeLoadHardening", DefaultsToFalse,
+ ChangedBy<PosFlag, [CC1Option]>, ResetBy<NegFlag>, BothFlags<[CoreOption]>,
+ "m">, Group<m_Group>;
def mlvi_hardening : Flag<["-"], "mlvi-hardening">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>,
HelpText<"Enable all mitigations for Load Value Injection (LVI)">;
def mno_lvi_hardening : Flag<["-"], "mno-lvi-hardening">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>,
@@ -2778,7 +2814,8 @@
HelpText<"Disallow converting instructions with negative immediates to their negation or inversion.">;
def mcmse : Flag<["-"], "mcmse">, Group<m_arm_Features_Group>,
Flags<[NoXarchOption,CC1Option]>,
- HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">;
+ HelpText<"Allow use of CMSE (Armv8-M Security Extensions)">,
+ MarshallingInfoFlag<"LangOpts->Cmse">;
def ForceAAPCSBitfieldLoad : Flag<["-"], "faapcs-bitfield-load">, Group<m_arm_Features_Group>,
Flags<[NoXarchOption,CC1Option]>,
HelpText<"Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).">,
@@ -2952,7 +2989,10 @@
def mvx : Flag<["-"], "mvx">, Group<m_Group>;
def mno_vx : Flag<["-"], "mno-vx">, Group<m_Group>;
-defm zvector : OptInFFlag<"zvector", "Enable System z vector language extension">;
+defm zvector : BoolFOption<"zvector",
+ "LangOpts->ZVector", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Enable System z vector language extension">,
+ ResetBy<NegFlag>>;
def mzvector : Flag<["-"], "mzvector">, Alias<fzvector>;
def mno_zvector : Flag<["-"], "mno-zvector">, Alias<fno_zvector>;
@@ -3230,7 +3270,8 @@
def print_file_name_EQ : Joined<["-", "--"], "print-file-name=">,
HelpText<"Print the full library path of <file>">, MetaVarName<"<file>">;
def print_ivar_layout : Flag<["-"], "print-ivar-layout">, Flags<[CC1Option]>,
- HelpText<"Enable Objective-C Ivar layout bitmap print trace">;
+ HelpText<"Enable Objective-C Ivar layout bitmap print trace">,
+ MarshallingInfoFlag<"LangOpts->ObjCGCBitmapPrint">;
def print_libgcc_file_name : Flag<["-", "--"], "print-libgcc-file-name">,
HelpText<"Print the library path for the currently used compiler runtime "
"library (\"libgcc.a\" or \"libclang_rt.builtins.*.a\")">;
@@ -3252,9 +3293,10 @@
HelpText<"Print the registered targets">;
def private__bundle : Flag<["-"], "private_bundle">;
def pthreads : Flag<["-"], "pthreads">;
-def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>,
- HelpText<"Support POSIX threads in generated code">;
-def no_pthread : Flag<["-"], "no-pthread">, Flags<[CC1Option]>;
+defm pthread : BoolOption<"pthread",
+ "LangOpts->POSIXThreads", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Support POSIX threads in generated code">,
+ ResetBy<NegFlag>, BothFlags<[CC1Option]>>;
def p : Flag<["-"], "p">;
def pie : Flag<["-"], "pie">, Group<Link_Group>;
def static_pie : Flag<["-"], "static-pie">, Group<Link_Group>;
@@ -3358,7 +3400,8 @@
def time : Flag<["-"], "time">,
HelpText<"Time individual commands">;
def traditional_cpp : Flag<["-", "--"], "traditional-cpp">, Flags<[CC1Option]>,
- HelpText<"Enable some traditional CPP emulation">;
+ HelpText<"Enable some traditional CPP emulation">,
+ MarshallingInfoFlag<"LangOpts->TraditionalCPP">;
def traditional : Flag<["-", "--"], "traditional">;
def trigraphs : Flag<["-", "--"], "trigraphs">, Alias<ftrigraphs>,
HelpText<"Process trigraph sequences">;
@@ -3830,8 +3873,11 @@
defm ipa_cp : BooleanFFlag<"ipa-cp">,
Group<clang_ignored_gcc_optimization_f_Group>;
defm ivopts : BooleanFFlag<"ivopts">, Group<clang_ignored_gcc_optimization_f_Group>;
-def fsemantic_interposition : Flag<["-"], "fsemantic-interposition">, Group<f_Group>, Flags<[CC1Option]>;
-def fno_semantic_interposition: Flag<["-"], "fno-semantic-interposition">, Group<f_Group>, Flags<[CC1Option]>;
+def fsemantic_interposition : Flag<["-"], "fsemantic-interposition">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->SemanticInterposition">;
+// An explicit -fno-semantic-interposition infers dso_local.
+def fno_semantic_interposition: Flag<["-"], "fno-semantic-interposition">, Group<f_Group>, Flags<[CC1Option]>,
+ MarshallingInfoFlag<"LangOpts->ExplicitNoSemanticInterposition">;
defm non_call_exceptions : BooleanFFlag<"non-call-exceptions">, Group<clang_ignored_f_Group>;
defm peel_loops : BooleanFFlag<"peel-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
defm permissive : BooleanFFlag<"permissive">, Group<clang_ignored_f_Group>;
@@ -3950,10 +3996,11 @@
defm whole_file : BooleanFFlag<"whole-file">, Group<gfortran_Group>;
// C++ SYCL options
-def fsycl : Flag<["-"], "fsycl">, Group<sycl_Group>, Flags<[CC1Option, CoreOption]>,
- HelpText<"Enable SYCL kernels compilation for device">;
-def fno_sycl : Flag<["-"], "fno-sycl">, Group<sycl_Group>, Flags<[CoreOption]>,
- HelpText<"Disable SYCL kernels compilation for device">;
+defm sycl : BoolOption<"sycl",
+ "LangOpts->SYCL", DefaultsToFalse,
+ ChangedBy<PosFlag, [CC1Option], "Enable">, ResetBy<NegFlag, [], "Disable">,
+ BothFlags<[CoreOption], " SYCL kernels compilation for device">, "f">,
+ Group<sycl_Group>;
def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>,
HelpText<"SYCL language standard to compile for.">, Values<"2017, 121, 1.2.1, sycl-1.2.1">;
@@ -4205,7 +4252,8 @@
MarshallingInfoString<"CodeGenOpts.RelocationModel", "PIC_">,
AutoNormalizeEnum;
def fno_math_builtin : Flag<["-"], "fno-math-builtin">,
- HelpText<"Disable implicit builtin knowledge of math functions">;
+ HelpText<"Disable implicit builtin knowledge of math functions">,
+ MarshallingInfoFlag<"LangOpts->NoMathBuiltin">;
def fuse_ctor_homing: Flag<["-"], "fuse-ctor-homing">,
HelpText<"Use constructor homing if we are using limited debug info already">;
}
@@ -4248,7 +4296,8 @@
HelpText<"Don't generate implicit floating point instructions">,
MarshallingInfoFlag<"CodeGenOpts.NoImplicitFloat">;
def fdump_vtable_layouts : Flag<["-"], "fdump-vtable-layouts">,
- HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">;
+ HelpText<"Dump the layouts of all vtables that will be emitted in a translation unit">,
+ MarshallingInfoFlag<"LangOpts->DumpVTableLayouts">;
def fmerge_functions : Flag<["-"], "fmerge-functions">,
HelpText<"Permit merging of identical functions when optimizing.">,
MarshallingInfoFlag<"CodeGenOpts.MergeFunctions">;
@@ -4293,7 +4342,8 @@
HelpText<"Allow reassociation transformations for floating-point instructions">,
MarshallingInfoFlag<"LangOpts->AllowFPReassoc">, ImpliedByAnyOf<[menable_unsafe_fp_math]>;
def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">,
- HelpText<"Use IEEE 754 quadruple-precision for long double">;
+ HelpText<"Use IEEE 754 quadruple-precision for long double">,
+ MarshallingInfoFlag<"LangOpts->PPCIEEELongDouble">;
def mfloat_abi : Separate<["-"], "mfloat-abi">,
HelpText<"The float ABI to use">;
def mtp : Separate<["-"], "mtp">,
@@ -4418,8 +4468,10 @@
// don't have to parse the parameter twice.
def msign_return_address_key_EQ : Joined<["-"], "msign-return-address-key=">,
Values<"a_key,b_key">;
-def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">;
-def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">;
+def mbranch_target_enforce : Flag<["-"], "mbranch-target-enforce">,
+ MarshallingInfoFlag<"LangOpts->BranchTargetEnforcement">;
+def fno_dllexport_inlines : Flag<["-"], "fno-dllexport-inlines">,
+ MarshallingInfoFlag<"LangOpts->DllExportInlines", "true">, IsNegative;
def cfguard_no_checks : Flag<["-"], "cfguard-no-checks">,
HelpText<"Emit Windows Control Flow Guard tables only (no checks)">,
MarshallingInfoFlag<"CodeGenOpts.ControlFlowGuardNoChecks">;
@@ -4557,7 +4609,8 @@
HelpText<"Do not automatically generate or update the global module index">,
MarshallingInfoFlag<"FrontendOpts.UseGlobalModuleIndex", "true">, IsNegative;
def fno_modules_error_recovery : Flag<["-"], "fno-modules-error-recovery">,
- HelpText<"Do not automatically import modules for error recovery">;
+ HelpText<"Do not automatically import modules for error recovery">,
+ MarshallingInfoFlag<"LangOpts->ModulesErrorRecovery", "true">, IsNegative;
def fmodule_map_file_home_is_cwd : Flag<["-"], "fmodule-map-file-home-is-cwd">,
HelpText<"Use the current working directory as the home directory of "
"module maps specified by -fmodule-map-file=<FILE>">,
@@ -4580,11 +4633,13 @@
def fmodules_codegen :
Flag<["-"], "fmodules-codegen">,
HelpText<"Generate code for uses of this module that assumes an explicit "
- "object file will be built for the module">;
+ "object file will be built for the module">,
+ MarshallingInfoFlag<"LangOpts->ModulesCodegen">;
def fmodules_debuginfo :
Flag<["-"], "fmodules-debuginfo">,
HelpText<"Generate debug info for types in an object file built from this "
- "module and do not generate them elsewhere">;
+ "module and do not generate them elsewhere">,
+ MarshallingInfoFlag<"LangOpts->ModulesDebugInfo">;
def fmodule_format_EQ : Joined<["-"], "fmodule-format=">,
HelpText<"Select the container format for clang modules and PCH. "
"Supported options are 'raw' and 'obj'.">;
@@ -4596,15 +4651,19 @@
HelpText<"Enable C++ Extensions for Concepts. (deprecated - use -std=c++2a)">;
def fno_concept_satisfaction_caching : Flag<["-"],
"fno-concept-satisfaction-caching">,
- HelpText<"Disable satisfaction caching for C++2a Concepts.">;
+ HelpText<"Disable satisfaction caching for C++2a Concepts.">,
+ MarshallingInfoFlag<"LangOpts->ConceptSatisfactionCaching", "true">, IsNegative;
-def frecovery_ast : Flag<["-"], "frecovery-ast">,
- HelpText<"Preserve expressions in AST rather than dropping them when "
- "encountering semantic errors">;
-def fno_recovery_ast : Flag<["-"], "fno-recovery-ast">;
-def frecovery_ast_type : Flag<["-"], "frecovery-ast-type">,
- HelpText<"Preserve the type for recovery expressions when possible">;
-def fno_recovery_ast_type : Flag<["-"], "fno-recovery-ast-type">;
+defm recovery_ast : BoolOption<"recovery-ast",
+ "LangOpts->RecoveryAST", DefaultsToTrue,
+ ChangedBy<NegFlag>, ResetBy<PosFlag, [], "Preserve expressions in AST rather "
+ "than dropping them when encountering semantic errors">,
+ BothFlags<[]>, "f">;
+defm recovery_ast_type : BoolOption<"recovery-ast-type",
+ "LangOpts->RecoveryASTType", DefaultsToTrue,
+ ChangedBy<NegFlag>, ResetBy<PosFlag, [], "Preserve the type for recovery "
+ "expressions when possible">,
+ BothFlags<[]>, "f">;
let Group = Action_Group in {
@@ -4711,7 +4770,8 @@
def fdump_record_layouts : Flag<["-"], "fdump-record-layouts">,
HelpText<"Dump record layout information">;
def fdump_record_layouts_simple : Flag<["-"], "fdump-record-layouts-simple">,
- HelpText<"Dump record layout information in a simple form used for testing">;
+ HelpText<"Dump record layout information in a simple form used for testing">,
+ MarshallingInfoFlag<"LangOpts->DumpRecordLayoutsSimple">;
def fix_what_you_can : Flag<["-"], "fix-what-you-can">,
HelpText<"Apply fix-it advice even in the presence of unfixable errors">,
MarshallingInfoFlag<"FrontendOpts.FixWhatYouCan">;
@@ -4738,7 +4798,8 @@
HelpText<"Disable inclusion of timestamp in precompiled headers">,
MarshallingInfoFlag<"FrontendOpts.IncludeTimestamps", "true">, IsNegative;
def building_pch_with_obj : Flag<["-"], "building-pch-with-obj">,
- HelpText<"This compilation is part of building a PCH with corresponding object file.">;
+ HelpText<"This compilation is part of building a PCH with corresponding object file.">,
+ MarshallingInfoFlag<"LangOpts->BuildingPCHWithObjectFile">;
def aligned_alloc_unavailable : Flag<["-"], "faligned-alloc-unavailable">,
HelpText<"Aligned allocation/deallocation functions are unavailable">;
@@ -4760,9 +4821,11 @@
}
def fblocks_runtime_optional : Flag<["-"], "fblocks-runtime-optional">,
- HelpText<"Weakly link in the blocks runtime">;
+ HelpText<"Weakly link in the blocks runtime">,
+ MarshallingInfoFlag<"LangOpts->BlocksRuntimeOptional">;
def fexternc_nounwind : Flag<["-"], "fexternc-nounwind">,
- HelpText<"Assume all functions with C linkage do not unwind">;
+ HelpText<"Assume all functions with C linkage do not unwind">,
+ MarshallingInfoFlag<"LangOpts->ExternCNoUnwind">;
def split_dwarf_file : Separate<["-"], "split-dwarf-file">,
HelpText<"Name of the split dwarf debug info file to encode in the object file">;
def fno_wchar : Flag<["-"], "fno-wchar">,
@@ -4777,15 +4840,18 @@
def fobjc_dispatch_method_EQ : Joined<["-"], "fobjc-dispatch-method=">,
HelpText<"Objective-C dispatch method to use">, Values<"legacy,non-legacy,mixed">;
def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">,
- HelpText<"disable the default synthesis of Objective-C properties">;
+ HelpText<"disable the default synthesis of Objective-C properties">,
+ MarshallingInfoFlag<"LangOpts->ObjCDefaultSynthProperties", "true">, IsNegative;
def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">,
- HelpText<"enable extended encoding of block type signature">;
+ HelpText<"enable extended encoding of block type signature">,
+ MarshallingInfoFlag<"LangOpts->EncodeExtendedBlockSig">;
def function_alignment : Separate<["-"], "function-alignment">,
HelpText<"default alignment for functions">;
def pic_level : Separate<["-"], "pic-level">,
HelpText<"Value for __PIC__">;
def pic_is_pie : Flag<["-"], "pic-is-pie">,
- HelpText<"File is for a position independent executable">;
+ HelpText<"File is for a position independent executable">,
+ MarshallingInfoFlag<"LangOpts->PIE">;
def fno_validate_pch : Flag<["-"], "fno-validate-pch">,
HelpText<"Disable validation of precompiled headers">;
def fallow_pch_with_errors : Flag<["-"], "fallow-pch-with-compiler-errors">,
@@ -4799,7 +4865,8 @@
def error_on_deserialized_pch_decl_EQ : Joined<["-"], "error-on-deserialized-decl=">,
Alias<error_on_deserialized_pch_decl>;
def static_define : Flag<["-"], "static-define">,
- HelpText<"Should __STATIC__ be defined">;
+ HelpText<"Should __STATIC__ be defined">,
+ MarshallingInfoFlag<"LangOpts->Static">;
def stack_protector : Separate<["-"], "stack-protector">,
HelpText<"Enable stack protectors">;
def stack_protector_buffer_size : Separate<["-"], "stack-protector-buffer-size">,
@@ -4809,7 +4876,8 @@
def ftype_visibility : Separate<["-"], "ftype-visibility">,
HelpText<"Default type visibility">;
def fapply_global_visibility_to_externs : Flag<["-"], "fapply-global-visibility-to-externs">,
- HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">;
+ HelpText<"Apply global symbol visibility to external declarations without an explicit visibility">,
+ MarshallingInfoFlag<"LangOpts->SetVisibilityForExternDecls">;
def ftemplate_depth : Separate<["-"], "ftemplate-depth">,
HelpText<"Maximum depth of recursive template instantiation">;
def foperator_arrow_depth : Separate<["-"], "foperator-arrow-depth">,
@@ -4820,24 +4888,30 @@
HelpText<"Maximum number of steps in constexpr function evaluation">;
def fbracket_depth : Separate<["-"], "fbracket-depth">,
HelpText<"Maximum nesting level for parentheses, brackets, and braces">;
-def fconst_strings : Flag<["-"], "fconst-strings">,
- HelpText<"Use a const qualified type for string literals in C and ObjC">;
-def fno_const_strings : Flag<["-"], "fno-const-strings">,
- HelpText<"Don't use a const qualified type for string literals in C and ObjC">;
+defm const_strings : BoolFOption<"const-strings",
+ "LangOpts->ConstStrings", DefaultsToFalse,
+ ChangedBy<PosFlag, [], "Use">, ResetBy<NegFlag, [], "Don't use">,
+ BothFlags<[], " a const qualified type for string literals in C and ObjC">>;
def fno_bitfield_type_align : Flag<["-"], "fno-bitfield-type-align">,
- HelpText<"Ignore bit-field types when aligning structures">;
+ HelpText<"Ignore bit-field types when aligning structures">,
+ MarshallingInfoFlag<"LangOpts->NoBitFieldTypeAlign">;
def ffake_address_space_map : Flag<["-"], "ffake-address-space-map">,
- HelpText<"Use a fake address space map; OpenCL testing purposes only">;
+ HelpText<"Use a fake address space map; OpenCL testing purposes only">,
+ MarshallingInfoFlag<"LangOpts->FakeAddressSpaceMap">;
def faddress_space_map_mangling_EQ : Joined<["-"], "faddress-space-map-mangling=">, MetaVarName<"<yes|no|target>">,
HelpText<"Set the mode for address space map based mangling; OpenCL testing purposes only">;
def funknown_anytype : Flag<["-"], "funknown-anytype">,
- HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">;
+ HelpText<"Enable parser support for the __unknown_anytype type; for testing purposes only">,
+ MarshallingInfoFlag<"LangOpts->ParseUnknownAnytype">;
def fdebugger_support : Flag<["-"], "fdebugger-support">,
- HelpText<"Enable special debugger support behavior">;
+ HelpText<"Enable special debugger support behavior">,
+ MarshallingInfoFlag<"LangOpts->DebuggerSupport">;
def fdebugger_cast_result_to_id : Flag<["-"], "fdebugger-cast-result-to-id">,
- HelpText<"Enable casting unknown expression results to id">;
+ HelpText<"Enable casting unknown expression results to id">,
+ MarshallingInfoFlag<"LangOpts->DebuggerCastResultToId">;
def fdebugger_objc_literal : Flag<["-"], "fdebugger-objc-literal">,
- HelpText<"Enable special debugger support for Objective-C subscripting and literals">;
+ HelpText<"Enable special debugger support for Objective-C subscripting and literals">,
+ MarshallingInfoFlag<"LangOpts->DebuggerObjCLiteral">;
def fdeprecated_macro : Flag<["-"], "fdeprecated-macro">,
HelpText<"Defines the __DEPRECATED macro">;
def fno_deprecated_macro : Flag<["-"], "fno-deprecated-macro">,
@@ -4855,21 +4929,24 @@
def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">,
HelpText<"Set default calling convention">, Values<"cdecl,fastcall,stdcall,vectorcall,regcall">;
def finclude_default_header : Flag<["-"], "finclude-default-header">,
- HelpText<"Include default header file for OpenCL">;
+ HelpText<"Include default header file for OpenCL">,
+ MarshallingInfoFlag<"LangOpts->IncludeDefaultHeader">;
def fdeclare_opencl_builtins : Flag<["-"], "fdeclare-opencl-builtins">,
- HelpText<"Add OpenCL builtin function declarations (experimental)">;
+ HelpText<"Add OpenCL builtin function declarations (experimental)">,
+ MarshallingInfoFlag<"LangOpts->DeclareOpenCLBuiltins">;
def fpreserve_vec3_type : Flag<["-"], "fpreserve-vec3-type">,
HelpText<"Preserve 3-component vector type">,
MarshallingInfoFlag<"CodeGenOpts.PreserveVec3Type">;
def fwchar_type_EQ : Joined<["-"], "fwchar-type=">,
HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">;
-def fsigned_wchar : Flag<["-"], "fsigned-wchar">,
- HelpText<"Use a signed type for wchar_t">;
-def fno_signed_wchar : Flag<["-"], "fno-signed-wchar">,
- HelpText<"Use an unsigned type for wchar_t">;
+defm signed_wchar : BoolFOption<"signed-wchar",
+ "LangOpts->WCharIsSigned", DefaultsToTrue,
+ ChangedBy<NegFlag, [], "Use an unsigned">, ResetBy<PosFlag, [], "Use a signed">,
+ BothFlags<[], " type for wchar_t">>;
def fcompatibility_qualified_id_block_param_type_checking : Flag<["-"], "fcompatibility-qualified-id-block-type-checking">,
HelpText<"Allow using blocks with parameters of more specific type than "
- "the type system guarantees when a parameter is qualified id">;
+ "the type system guarantees when a parameter is qualified id">,
+ MarshallingInfoFlag<"LangOpts->CompatibilityQualifiedIdBlockParamTypeChecking">;
def fpass_by_value_is_noalias: Flag<["-"], "fpass-by-value-is-noalias">,
HelpText<"Allows assuming by-value parameters do not alias any other value. "
"Has no effect on non-trivially-copyable classes in C++.">, Group<f_Group>,
@@ -4946,13 +5023,16 @@
//===----------------------------------------------------------------------===//
def fcuda_is_device : Flag<["-"], "fcuda-is-device">,
- HelpText<"Generate code for CUDA device">;
+ HelpText<"Generate code for CUDA device">,
+ MarshallingInfoFlag<"LangOpts->CUDAIsDevice">;
def fcuda_include_gpubinary : Separate<["-"], "fcuda-include-gpubinary">,
HelpText<"Incorporate CUDA device-side binary into host object file.">;
def fcuda_allow_variadic_functions : Flag<["-"], "fcuda-allow-variadic-functions">,
- HelpText<"Allow variadic functions in CUDA device code.">;
+ HelpText<"Allow variadic functions in CUDA device code.">,
+ MarshallingInfoFlag<"LangOpts->CUDAAllowVariadicFunctions">;
def fno_cuda_host_device_constexpr : Flag<["-"], "fno-cuda-host-device-constexpr">,
- HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">;
+ HelpText<"Don't treat unattributed constexpr functions as __host__ __device__.">,
+ MarshallingInfoFlag<"LangOpts->CUDAHostDeviceConstexpr", "true">, IsNegative;
//===----------------------------------------------------------------------===//
// OpenMP Options
Index: clang/include/clang/Basic/LangOptions.h
===================================================================
--- clang/include/clang/Basic/LangOptions.h
+++ clang/include/clang/Basic/LangOptions.h
@@ -30,6 +30,8 @@
/// Bitfields of LangOptions, split out from LangOptions in order to ensure that
/// this large collection of bitfields is a trivial class type.
class LangOptionsBase {
+ friend class CompilerInvocation;
+
public:
// Define simple language options (with no accessors).
#define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
