[clang] dbfa69c - Port some floating point options to new option marshalling infrastructure
Duncan P. N. Exon Smith via cfe-commits
cfe-commits at lists.llvm.org
Mon Nov 9 15:00:28 PST 2020
Author: Jan Svoboda
Date: 2020-11-09T18:00:10-05:00
New Revision: dbfa69c5024cfe58b8029a3766ec46c857cddb1e
URL: https://github.com/llvm/llvm-project/commit/dbfa69c5024cfe58b8029a3766ec46c857cddb1e
DIFF: https://github.com/llvm/llvm-project/commit/dbfa69c5024cfe58b8029a3766ec46c857cddb1e.diff
LOG: Port some floating point options to new option marshalling infrastructure
This ports a number of OpenCL and fast-math flags for floating point
over to the new marshalling infrastructure.
As part of this, `Opt{In,Out}FFlag` were enhanced to allow other flags to
imply them, via `DefaultAnyOf<>`. For example:
```
defm signed_zeros : OptOutFFlag<"signed-zeros", ...,
"LangOpts->NoSignedZero",
DefaultAnyOf<[cl_no_signed_zeros, menable_unsafe_fp_math]>>;
```
defines `-fsigned-zeros` (`false`) and `-fno-signed-zeros` (`true`)
linked to the keypath `LangOpts->NoSignedZero`, defaulting to `false`,
but set to `true` implicitly if one of `-cl-no-signed-zeros` or
`-menable-unsafe-fp-math` is on.
Note that the initial patch was written Daniel Grumberg.
Differential Revision: https://reviews.llvm.org/D82756
Added:
llvm/unittests/Option/OptionMarshallingTest.cpp
Modified:
clang/include/clang/Basic/LangOptions.def
clang/include/clang/Driver/Options.td
clang/lib/Frontend/CompilerInvocation.cpp
clang/unittests/Frontend/CompilerInvocationTest.cpp
llvm/include/llvm/Option/OptParser.td
llvm/unittests/Option/CMakeLists.txt
llvm/unittests/Option/Opts.td
llvm/utils/TableGen/OptParserEmitter.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
index 1d203f8489eb..3788ae87f6b9 100644
--- a/clang/include/clang/Basic/LangOptions.def
+++ b/clang/include/clang/Basic/LangOptions.def
@@ -274,6 +274,9 @@ BENIGN_LANGOPT(DebuggerObjCLiteral , 1, 0, "debugger Objective-C literals and su
BENIGN_LANGOPT(SpellChecking , 1, 1, "spell-checking")
LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating point constants as single precision constants")
LANGOPT(FastRelaxedMath , 1, 0, "OpenCL fast relaxed math")
+BENIGN_LANGOPT(CLNoSignedZero , 1, 0, "Permit Floating Point optimization without regard to signed zeros")
+COMPATIBLE_LANGOPT(CLUnsafeMath , 1, 0, "Unsafe Floating Point Math")
+COMPATIBLE_LANGOPT(CLFiniteMathOnly , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
/// FP_CONTRACT mode (on/off/fast).
BENIGN_ENUM_LANGOPT(DefaultFPContractMode, FPModeKind, 2, FPM_Off, "FP contraction type")
COMPATIBLE_LANGOPT(ExpStrictFP, 1, false, "Enable experimental strict floating point")
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 33cfa72c0888..e13946f98ea4 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -245,9 +245,11 @@ def clang_ignored_gcc_optimization_f_Group : OptionGroup<
// Args.hasArg(OPT_ffoo) is used to check that the flag is enabled.
// This is useful if the option is usually disabled.
multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="",
- string help="", list<OptionFlag> flags=[]> {
+ string help="", list<OptionFlag> flags=[], code keypath="",
+ DefaultAnyOf defaults = DefaultAnyOf<[]>> {
def f#NAME : Flag<["-"], "f"#name>, Flags<!listconcat([CC1Option], flags)>,
- Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>;
+ Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>,
+ MarshallingInfoFlag<keypath, defaults>;
def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<flags>,
Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>;
}
@@ -255,11 +257,13 @@ multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="",
// A boolean option which is opt-out in CC1. The negative option exists in CC1 and
// Args.hasArg(OPT_fno_foo) is used to check that the flag is disabled.
multiclass OptOutFFlag<string name, string pos_prefix, string neg_prefix,
- string help="", list<OptionFlag> flags=[]> {
+ string help="", list<OptionFlag> flags=[], code keypath="",
+ DefaultAnyOf defaults = DefaultAnyOf<[]>> {
def f#NAME : Flag<["-"], "f"#name>, Flags<flags>,
Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>;
def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<!listconcat([CC1Option], flags)>,
- Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>;
+ Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>,
+ MarshallingInfoFlag<keypath, defaults>;
}
/////////
@@ -563,27 +567,36 @@ def cl_opt_disable : Flag<["-"], "cl-opt-disable">, Group<opencl_Group>, Flags<[
def cl_strict_aliasing : Flag<["-"], "cl-strict-aliasing">, Group<opencl_Group>, Flags<[CC1Option]>,
HelpText<"OpenCL only. This option is added for compatibility with OpenCL 1.0.">;
def cl_single_precision_constant : Flag<["-"], "cl-single-precision-constant">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">;
+ HelpText<"OpenCL only. Treat double precision floating-point constant as single precision constant.">,
+ MarshallingInfoFlag<"LangOpts->SinglePrecisionConstants">;
def cl_finite_math_only : Flag<["-"], "cl-finite-math-only">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">;
+ HelpText<"OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.">,
+ MarshallingInfoFlag<"LangOpts->CLFiniteMathOnly">;
def cl_kernel_arg_info : Flag<["-"], "cl-kernel-arg-info">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Generate kernel argument metadata.">;
+ HelpText<"OpenCL only. Generate kernel argument metadata.">,
+ MarshallingInfoFlag<"CodeGenOpts.EmitOpenCLArgMetadata">;
def cl_unsafe_math_optimizations : Flag<["-"], "cl-unsafe-math-optimizations">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.">;
+ HelpText<"OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.">,
+ MarshallingInfoFlag<"LangOpts->CLUnsafeMath">;
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__.">;
+ HelpText<"OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.">,
+ MarshallingInfoFlag<"LangOpts->FastRelaxedMath">;
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.">;
+ HelpText<"OpenCL only. Allow use of less precise MAD computations in the generated binary.">,
+ MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD", DefaultAnyOf<[cl_unsafe_math_optimizations, cl_fast_relaxed_math]>>;
def cl_no_signed_zeros : Flag<["-"], "cl-no-signed-zeros">, Group<opencl_Group>, Flags<[CC1Option]>,
- HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">;
+ HelpText<"OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.">,
+ MarshallingInfoFlag<"LangOpts->CLNoSignedZero">;
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,cl3.0,CL3.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.">;
+ HelpText<"OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.">,
+ MarshallingInfoFlag<"CodeGenOpts.CorrectlyRoundedDivSqrt">;
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">;
+ HelpText<"OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel">,
+ MarshallingInfoFlag<"CodeGenOpts.UniformWGSize">;
def client__name : JoinedOrSeparate<["-"], "client_name">;
def combine : Flag<["-", "--"], "combine">, Flags<[NoXarchOption, Unsupported]>;
def compatibility__version : JoinedOrSeparate<["-"], "compatibility_version">;
@@ -890,7 +903,7 @@ def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>,
def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>,
Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">,
- MarshallingInfoFlag<"DiagnosticOpts->UseANSIEscapeCodes", "false">;
+ MarshallingInfoFlag<"DiagnosticOpts->UseANSIEscapeCodes">;
def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,
MetaVarName<"<arg>">;
@@ -1002,7 +1015,11 @@ def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[NoXarchOp
HelpText<"Controls the semantics of floating-point calculations.">;
def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Specifies the exception behavior of floating-point operations.">;
-defm fast_math : OptInFFlag<"fast-math", "Allow aggressive, lossy floating-point optimizations">;
+defm fast_math : OptInFFlag<"fast-math", "Allow aggressive, lossy floating-point optimizations", "", "", [],
+ "LangOpts->FastMath", DefaultAnyOf<[cl_fast_relaxed_math]>>;
+def menable_unsafe_fp_math : Flag<["-"], "menable-unsafe-fp-math">, Flags<[CC1Option]>,
+ HelpText<"Allow unsafe floating-point math optimizations which may decrease precision">,
+ MarshallingInfoFlag<"LangOpts->UnsafeFPMath", DefaultAnyOf<[cl_unsafe_math_optimizations, ffast_math]>>;
defm math_errno : OptInFFlag<"math-errno", "Require math functions to indicate errors by setting errno">;
def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>, Flags<[CoreOption]>;
def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>;
@@ -1215,16 +1232,14 @@ def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">
Group<f_Group>;
def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
-def freciprocal_math :
- Flag<["-"], "freciprocal-math">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Allow division operations to be reassociated">;
-def fno_reciprocal_math : Flag<["-"], "fno-reciprocal-math">, Group<f_Group>;
-def ffinite_math_only : Flag<["-"], "ffinite-math-only">, Group<f_Group>, Flags<[CC1Option]>;
-def fno_finite_math_only : Flag<["-"], "fno-finite-math-only">, Group<f_Group>;
-def fsigned_zeros : Flag<["-"], "fsigned-zeros">, Group<f_Group>;
-def fno_signed_zeros :
- Flag<["-"], "fno-signed-zeros">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Allow optimizations that ignore the sign of floating point zeros">;
+defm reciprocal_math : OptInFFlag<"reciprocal-math", "Allow division operations to be reassociated", "", "", [],
+ "LangOpts->AllowRecip", DefaultAnyOf<[menable_unsafe_fp_math]>>;
+def fapprox_func : Flag<["-"], "fapprox-func">, Group<f_Group>, Flags<[CC1Option, NoDriverOption]>,
+ MarshallingInfoFlag<"LangOpts->ApproxFunc", DefaultAnyOf<[menable_unsafe_fp_math]>>;
+defm finite_math_only : OptInFFlag<"finite-math-only", "", "", "", [],
+ "LangOpts->FiniteMathOnly", DefaultAnyOf<[cl_finite_math_only, ffast_math]>>;
+defm signed_zeros : OptOutFFlag<"signed-zeros", "Allow optimizations that ignore the sign of floating point zeros", "", "", [],
+ "LangOpts->NoSignedZero", DefaultAnyOf<[cl_no_signed_zeros, menable_unsafe_fp_math]>>;
def fhonor_nans : Flag<["-"], "fhonor-nans">, Group<f_Group>;
def fno_honor_nans : Flag<["-"], "fno-honor-nans">, Group<f_Group>;
def fhonor_infinities : Flag<["-"], "fhonor-infinities">, Group<f_Group>;
@@ -3847,14 +3862,14 @@ def mframe_pointer_EQ : Joined<["-"], "mframe-pointer=">,
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.">;
+ HelpText<"Allow optimization to assume there are no infinities.">,
+ MarshallingInfoFlag<"LangOpts->NoHonorInfs", DefaultAnyOf<[ffinite_math_only]>>;
def menable_no_nans : Flag<["-"], "menable-no-nans">,
- HelpText<"Allow optimization to assume there are no NaNs.">;
-def menable_unsafe_fp_math : Flag<["-"], "menable-unsafe-fp-math">,
- HelpText<"Allow unsafe floating-point math optimizations which may decrease "
- "precision">;
+ HelpText<"Allow optimization to assume there are no NaNs.">,
+ MarshallingInfoFlag<"LangOpts->NoHonorNaNs", DefaultAnyOf<[ffinite_math_only]>>;
def mreassociate : Flag<["-"], "mreassociate">,
- HelpText<"Allow reassociation transformations for floating-point instructions">;
+ HelpText<"Allow reassociation transformations for floating-point instructions">,
+ MarshallingInfoFlag<"LangOpts->AllowFPReassoc", DefaultAnyOf<[menable_unsafe_fp_math]>>;
def mabi_EQ_ieeelongdouble : Flag<["-"], "mabi=ieeelongdouble">,
HelpText<"Use IEEE 754 quadruple-precision for long double">;
def mfloat_abi : Separate<["-"], "mfloat-abi">,
@@ -4405,7 +4420,7 @@ def fmodules_hash_content : Flag<["-"], "fmodules-hash-content">,
def fmodules_strict_context_hash : Flag<["-"], "fmodules-strict-context-hash">,
HelpText<"Enable hashing of all compiler options that could impact the "
"semantics of a module in an implicit build">,
- MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash", "false">;
+ MarshallingInfoFlag<"HeaderSearchOpts->ModulesStrictContextHash">;
def c_isystem : JoinedOrSeparate<["-"], "c-isystem">, MetaVarName<"<directory>">,
HelpText<"Add directory to the C SYSTEM include search path">;
def objc_isystem : JoinedOrSeparate<["-"], "objc-isystem">,
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index 7b8554c0fe49..d2c4482972b0 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -941,15 +941,8 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
Opts.NoEscapingBlockTailCalls =
Args.hasArg(OPT_fno_escaping_block_tail_calls);
Opts.FloatABI = std::string(Args.getLastArgValue(OPT_mfloat_abi));
- Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable) ||
- Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
Opts.LimitFloatPrecision =
std::string(Args.getLastArgValue(OPT_mlimit_float_precision));
- Opts.CorrectlyRoundedDivSqrt =
- Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
- Opts.UniformWGSize =
- Args.hasArg(OPT_cl_uniform_work_group_size);
Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
Opts.StrictFloatCastOverflow =
!Args.hasArg(OPT_fno_strict_float_cast_overflow);
@@ -1161,7 +1154,6 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
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();
@@ -3061,8 +3053,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
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);
- Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
- Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
if (Opts.FastRelaxedMath)
Opts.setDefaultFPContractMode(LangOptions::FPM_Fast);
Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
@@ -3330,47 +3320,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
if (InlineArg->getOption().matches(options::OPT_fno_inline))
Opts.NoInlineDefine = true;
- Opts.FastMath =
- Args.hasArg(OPT_ffast_math) || Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_finite_math_only) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.AllowFPReassoc = Args.hasArg(OPT_mreassociate) ||
- Args.hasArg(OPT_menable_unsafe_fp_math) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.NoHonorNaNs =
- Args.hasArg(OPT_menable_no_nans) || Args.hasArg(OPT_ffinite_math_only) ||
- Args.hasArg(OPT_ffast_math) || Args.hasArg(OPT_cl_finite_math_only) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.NoHonorInfs = Args.hasArg(OPT_menable_no_infinities) ||
- Args.hasArg(OPT_ffinite_math_only) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_finite_math_only) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.NoSignedZero = Args.hasArg(OPT_fno_signed_zeros) ||
- Args.hasArg(OPT_menable_unsafe_fp_math) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_no_signed_zeros) ||
- Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- Opts.AllowRecip = Args.hasArg(OPT_freciprocal_math) ||
- Args.hasArg(OPT_menable_unsafe_fp_math) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
- // Currently there's no clang option to enable this individually
- Opts.ApproxFunc = Args.hasArg(OPT_menable_unsafe_fp_math) ||
- Args.hasArg(OPT_ffast_math) ||
- Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
- Args.hasArg(OPT_cl_fast_relaxed_math);
-
if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
StringRef Val = A->getValue();
if (Val == "fast")
@@ -3777,7 +3726,7 @@ bool CompilerInvocation::parseSimpleArgs(const ArgList &Args,
ALIAS, ALIASARGS, FLAGS, PARAM, HELPTEXT, \
METAVAR, VALUES, SPELLING, ALWAYS_EMIT, \
KEYPATH, DEFAULT_VALUE, IS_POSITIVE) \
- this->KEYPATH = Args.hasArg(OPT_##ID) && IS_POSITIVE;
+ this->KEYPATH = (Args.hasArg(OPT_##ID) && IS_POSITIVE) || (DEFAULT_VALUE);
#define OPTION_WITH_MARSHALLING_STRING( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
@@ -4051,15 +4000,15 @@ void CompilerInvocation::generateCC1CommandLine(
ALIAS, ALIASARGS, FLAGS, PARAM, HELPTEXT, \
METAVAR, VALUES, SPELLING, ALWAYS_EMIT, \
KEYPATH, DEFAULT_VALUE, IS_POSITIVE) \
- if ((FLAGS) & options::CC1Option && \
- (ALWAYS_EMIT || this->KEYPATH != DEFAULT_VALUE)) \
+ if ((FLAGS) & options::CC1Option && \
+ (ALWAYS_EMIT || this->KEYPATH != (DEFAULT_VALUE))) \
Args.push_back(SPELLING);
#define OPTION_WITH_MARSHALLING_STRING( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
NORMALIZER_RET_TY, NORMALIZER, DENORMALIZER, TABLE_INDEX) \
- if (((FLAGS) & options::CC1Option) && \
+ if (((FLAGS) & options::CC1Option) && \
(ALWAYS_EMIT || this->KEYPATH != DEFAULT_VALUE)) { \
if (Option::KIND##Class == Option::SeparateClass) { \
Args.push_back(SPELLING); \
diff --git a/clang/unittests/Frontend/CompilerInvocationTest.cpp b/clang/unittests/Frontend/CompilerInvocationTest.cpp
index ed82d678462f..d9b55f0ae5ba 100644
--- a/clang/unittests/Frontend/CompilerInvocationTest.cpp
+++ b/clang/unittests/Frontend/CompilerInvocationTest.cpp
@@ -37,6 +37,25 @@ class CC1CommandLineGenerationTest : public ::testing::Test {
: Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions())) {}
};
+TEST(OptsPopulationTest, CanPopulateOptsWithImpliedFlags) {
+ const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"};
+
+ auto Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions());
+
+ CompilerInvocation CInvok;
+ CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
+
+ // Explicitly provided flag.
+ ASSERT_EQ(CInvok.getLangOpts()->CLUnsafeMath, true);
+
+ // Flags directly implied by explicitly provided flag.
+ ASSERT_EQ(CInvok.getCodeGenOpts().LessPreciseFPMAD, true);
+ ASSERT_EQ(CInvok.getLangOpts()->UnsafeFPMath, true);
+
+ // Flag transitively implied by explicitly provided flag.
+ ASSERT_EQ(CInvok.getLangOpts()->AllowRecip, true);
+}
+
TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineFlag) {
const char *Args[] = {"clang", "-xc++", "-fmodules-strict-context-hash", "-"};
@@ -115,4 +134,20 @@ TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineSeparateEnum) {
ASSERT_THAT(GeneratedArgs, Each(StrNe(RelocationModelCStr)));
}
+TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineImpliedFlags) {
+ const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations",
+ "-cl-mad-enable", "-menable-unsafe-fp-math"};
+
+ CompilerInvocation CInvok;
+ CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
+
+ CInvok.generateCC1CommandLine(GeneratedArgs, *this);
+
+ // Explicitly provided flags that were also implied by another flag are not
+ // generated.
+ ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
+ ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
+ ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
+}
+
} // anonymous namespace
diff --git a/llvm/include/llvm/Option/OptParser.td b/llvm/include/llvm/Option/OptParser.td
index e32355444d7b..47b4788b2209 100644
--- a/llvm/include/llvm/Option/OptParser.td
+++ b/llvm/include/llvm/Option/OptParser.td
@@ -144,6 +144,11 @@ class ValuesCode<code valuecode> { code ValuesCode = valuecode; }
// Helpers for defining marshalling information.
+class DefaultAnyOf<list<Option> defaults> {
+ code DefaultValue = !foldl("false", defaults, accumulator, option,
+ !strconcat(accumulator, " || ", !cast<string>(option.KeyPath)));
+}
+
class MarshallingInfo<code keypath, code defaultvalue> {
code KeyPath = keypath;
code DefaultValue = defaultvalue;
@@ -154,8 +159,8 @@ class MarshallingInfoString<code keypath, code defaultvalue, code normalizerrett
code NormalizerRetTy = normalizerretty;
}
-class MarshallingInfoFlag<code keypath, code defaultvalue>
- : MarshallingInfo<keypath, defaultvalue> {
+class MarshallingInfoFlag<code keypath, DefaultAnyOf defaults = DefaultAnyOf<[]>>
+ : MarshallingInfo<keypath, defaults.DefaultValue> {
string MarshallingKind = "flag";
}
diff --git a/llvm/unittests/Option/CMakeLists.txt b/llvm/unittests/Option/CMakeLists.txt
index 07f7b91d5f5b..7be4300c0f3d 100644
--- a/llvm/unittests/Option/CMakeLists.txt
+++ b/llvm/unittests/Option/CMakeLists.txt
@@ -10,4 +10,5 @@ add_public_tablegen_target(OptsTestTableGen)
add_llvm_unittest(OptionTests
OptionParsingTest.cpp
+ OptionMarshallingTest.cpp
)
diff --git a/llvm/unittests/Option/OptionMarshallingTest.cpp b/llvm/unittests/Option/OptionMarshallingTest.cpp
new file mode 100644
index 000000000000..bf26a767bba1
--- /dev/null
+++ b/llvm/unittests/Option/OptionMarshallingTest.cpp
@@ -0,0 +1,47 @@
+//===- unittest/Support/OptionMarshallingTest.cpp - OptParserEmitter tests ===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+struct OptionWithMarshallingInfo {
+ const char *Name;
+ const char *KeyPath;
+ const char *DefaultValue;
+};
+
+static const OptionWithMarshallingInfo MarshallingTable[] = {
+#define OPTION_WITH_MARSHALLING_FLAG(PREFIX_TYPE, NAME, ID, KIND, GROUP, \
+ ALIAS, ALIASARGS, FLAGS, PARAM, HELPTEXT, \
+ METAVAR, VALUES, SPELLING, ALWAYS_EMIT, \
+ KEYPATH, DEFAULT_VALUE, IS_POSITIVE) \
+ { NAME, #KEYPATH, #DEFAULT_VALUE },
+#include "Opts.inc"
+#undef OPTION_WITH_MARSHALLING_FLAG
+};
+
+TEST(OptionMarshalling, EmittedOrderSameAsDefinitionOrder) {
+ ASSERT_STREQ(MarshallingTable[0].Name, "marshalled-flag-0");
+ ASSERT_STREQ(MarshallingTable[1].Name, "marshalled-flag-1");
+ ASSERT_STREQ(MarshallingTable[2].Name, "marshalled-flag-2");
+ ASSERT_STREQ(MarshallingTable[3].Name, "marshalled-flag-3");
+}
+
+TEST(OptionMarshalling, EmittedSpecifiedKeyPath) {
+ ASSERT_STREQ(MarshallingTable[0].KeyPath, "MarshalledFlag0");
+ ASSERT_STREQ(MarshallingTable[1].KeyPath, "MarshalledFlag1");
+ ASSERT_STREQ(MarshallingTable[2].KeyPath, "MarshalledFlag2");
+ ASSERT_STREQ(MarshallingTable[3].KeyPath, "MarshalledFlag3");
+}
+
+TEST(OptionMarshalling, DefaultAnyOfConstructedDisjunctionOfKeypaths) {
+ ASSERT_STREQ(MarshallingTable[0].DefaultValue, "false");
+ ASSERT_STREQ(MarshallingTable[1].DefaultValue, "false || MarshalledFlag0");
+ ASSERT_STREQ(MarshallingTable[2].DefaultValue, "false || MarshalledFlag0");
+ ASSERT_STREQ(MarshallingTable[3].DefaultValue,
+ "false || MarshalledFlag1 || MarshalledFlag2");
+}
diff --git a/llvm/unittests/Option/Opts.td b/llvm/unittests/Option/Opts.td
index e1ebffd1881f..3bbf210b0b74 100644
--- a/llvm/unittests/Option/Opts.td
+++ b/llvm/unittests/Option/Opts.td
@@ -44,3 +44,12 @@ def Blurmpq : Flag<["--"], "blurmp">;
def Blurmpq_eq : Flag<["--"], "blurmp=">;
def DashDash : Option<["--"], "", KIND_REMAINING_ARGS>;
+
+def marshalled_flag_0 : Flag<["-"], "marshalled-flag-0">,
+ MarshallingInfoFlag<"MarshalledFlag0", DefaultAnyOf<[]>>;
+def marshalled_flag_1 : Flag<["-"], "marshalled-flag-1">,
+ MarshallingInfoFlag<"MarshalledFlag1", DefaultAnyOf<[marshalled_flag_0]>>;
+def marshalled_flag_2 : Flag<["-"], "marshalled-flag-2">,
+ MarshallingInfoFlag<"MarshalledFlag2", DefaultAnyOf<[marshalled_flag_0]>>;
+def marshalled_flag_3 : Flag<["-"], "marshalled-flag-3">,
+ MarshallingInfoFlag<"MarshalledFlag3", DefaultAnyOf<[marshalled_flag_1, marshalled_flag_2]>>;
diff --git a/llvm/utils/TableGen/OptParserEmitter.cpp b/llvm/utils/TableGen/OptParserEmitter.cpp
index 6e49e248e4b8..0c30a2dd28dc 100644
--- a/llvm/utils/TableGen/OptParserEmitter.cpp
+++ b/llvm/utils/TableGen/OptParserEmitter.cpp
@@ -435,7 +435,12 @@ void EmitOptParser(RecordKeeper &Records, raw_ostream &OS) {
OS << "nullptr";
};
- std::vector<std::unique_ptr<MarshallingKindInfo>> OptsWithMarshalling;
+ auto IsMarshallingOption = [](const Record &R) {
+ return !isa<UnsetInit>(R.getValueInit("MarshallingKind")) &&
+ !R.getValueAsString("KeyPath").empty();
+ };
+
+ std::vector<const Record *> OptsWithMarshalling;
for (unsigned I = 0, E = Opts.size(); I != E; ++I) {
const Record &R = *Opts[I];
@@ -443,12 +448,33 @@ void EmitOptParser(RecordKeeper &Records, raw_ostream &OS) {
OS << "OPTION(";
WriteOptRecordFields(OS, R);
OS << ")\n";
- if (!isa<UnsetInit>(R.getValueInit("MarshallingKind")))
- OptsWithMarshalling.push_back(MarshallingKindInfo::create(R));
+ if (IsMarshallingOption(R))
+ OptsWithMarshalling.push_back(&R);
}
OS << "#endif // OPTION\n";
- for (const auto &KindInfo : OptsWithMarshalling) {
+ auto CmpMarshallingOpts = [](const Record *const *A, const Record *const *B) {
+ unsigned AID = (*A)->getID();
+ unsigned BID = (*B)->getID();
+
+ if (AID < BID)
+ return -1;
+ if (AID > BID)
+ return 1;
+ return 0;
+ };
+ // The RecordKeeper stores records (options) in lexicographical order, and we
+ // have reordered the options again when generating prefix groups. We need to
+ // restore the original definition order of options with marshalling to honor
+ // the topology of the dependency graph implied by `DefaultAnyOf`.
+ array_pod_sort(OptsWithMarshalling.begin(), OptsWithMarshalling.end(),
+ CmpMarshallingOpts);
+
+ std::vector<std::unique_ptr<MarshallingKindInfo>> MarshallingKindInfos;
+ for (const auto *R : OptsWithMarshalling)
+ MarshallingKindInfos.push_back(MarshallingKindInfo::create(*R));
+
+ for (const auto &KindInfo : MarshallingKindInfos) {
OS << "#ifdef " << KindInfo->MacroName << "\n";
OS << KindInfo->MacroName << "(";
WriteOptRecordFields(OS, KindInfo->R);
@@ -463,7 +489,7 @@ void EmitOptParser(RecordKeeper &Records, raw_ostream &OS) {
OS << "\n";
OS << MarshallingStringInfo::ValueTablePreamble;
std::vector<StringRef> ValueTableNames;
- for (const auto &KindInfo : OptsWithMarshalling)
+ for (const auto &KindInfo : MarshallingKindInfos)
if (auto MaybeValueTableName = KindInfo->emitValueTable(OS))
ValueTableNames.push_back(*MaybeValueTableName);
More information about the cfe-commits
mailing list