[llvm-branch-commits] [llvm] 88ab384 - [clang][cli] Split DefaultAnyOf into a default value and ImpliedByAnyOf
Jan Svoboda via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Dec 1 01:05:28 PST 2020
Author: Jan Svoboda
Date: 2020-12-01T09:50:11+01:00
New Revision: 88ab38449b49bf002ed7794d1b81d362aa9f9df2
URL: https://github.com/llvm/llvm-project/commit/88ab38449b49bf002ed7794d1b81d362aa9f9df2
DIFF: https://github.com/llvm/llvm-project/commit/88ab38449b49bf002ed7794d1b81d362aa9f9df2.diff
LOG: [clang][cli] Split DefaultAnyOf into a default value and ImpliedByAnyOf
This makes the options API composable, allows boolean flags to imply non-boolean values and makes the code more logical (IMO).
Differential Revision: https://reviews.llvm.org/D91861
Added:
Modified:
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/OptionMarshallingTest.cpp
llvm/unittests/Option/Opts.td
llvm/utils/TableGen/OptParserEmitter.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 48d9607e734a..09c02989a6a8 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -246,10 +246,11 @@ def clang_ignored_gcc_optimization_f_Group : OptionGroup<
// This is useful if the option is usually disabled.
multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="",
string help="", list<OptionFlag> flags=[], code keypath="",
- DefaultAnyOf defaults = DefaultAnyOf<[]>> {
+ list<Option> enablers = []> {
def f#NAME : Flag<["-"], "f"#name>, Flags<!listconcat([CC1Option], flags)>,
Group<f_Group>, HelpText<!strconcat(pos_prefix, help)>,
- MarshallingInfoFlag<keypath, defaults>;
+ MarshallingInfoFlag<keypath, "false">,
+ ImpliedByAnyOf<enablers, "true">;
def fno_#NAME : Flag<["-"], "fno-"#name>, Flags<flags>,
Group<f_Group>, HelpText<!strconcat(neg_prefix, help)>;
}
@@ -258,12 +259,13 @@ multiclass OptInFFlag<string name, string pos_prefix, string neg_prefix="",
// 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=[], code keypath="",
- DefaultAnyOf defaults = DefaultAnyOf<[]>> {
+ list<Option> disablers = []> {
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)>,
- MarshallingInfoFlag<keypath, defaults>;
+ MarshallingInfoFlag<keypath, "false">,
+ ImpliedByAnyOf<disablers, "true">;
}
multiclass BooleanMarshalledFFlag<string name, code keypath, code default_value, string pos_help = "", string neg_help=""> {
@@ -606,7 +608,8 @@ def cl_fast_relaxed_math : Flag<["-"], "cl-fast-relaxed-math">, Group<opencl_Gro
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.">,
- MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD", DefaultAnyOf<[cl_unsafe_math_optimizations, cl_fast_relaxed_math]>>;
+ MarshallingInfoFlag<"CodeGenOpts.LessPreciseFPMAD">,
+ ImpliedByAnyOf<[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.">,
MarshallingInfoFlag<"LangOpts->CLNoSignedZero">;
@@ -1048,10 +1051,11 @@ def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[NoXarchOp
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", "", "", [],
- "LangOpts->FastMath", DefaultAnyOf<[cl_fast_relaxed_math]>>;
+ "LangOpts->FastMath", [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]>>;
+ MarshallingInfoFlag<"LangOpts->UnsafeFPMath">,
+ ImpliedByAnyOf<[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>;
@@ -1265,13 +1269,13 @@ def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">
def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
defm reciprocal_math : OptInFFlag<"reciprocal-math", "Allow division operations to be reassociated", "", "", [],
- "LangOpts->AllowRecip", DefaultAnyOf<[menable_unsafe_fp_math]>>;
+ "LangOpts->AllowRecip", [menable_unsafe_fp_math]>;
def fapprox_func : Flag<["-"], "fapprox-func">, Group<f_Group>, Flags<[CC1Option, NoDriverOption]>,
- MarshallingInfoFlag<"LangOpts->ApproxFunc", DefaultAnyOf<[menable_unsafe_fp_math]>>;
+ MarshallingInfoFlag<"LangOpts->ApproxFunc">, ImpliedByAnyOf<[menable_unsafe_fp_math]>;
defm finite_math_only : OptInFFlag<"finite-math-only", "", "", "", [],
- "LangOpts->FiniteMathOnly", DefaultAnyOf<[cl_finite_math_only, ffast_math]>>;
+ "LangOpts->FiniteMathOnly", [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]>>;
+ "LangOpts->NoSignedZero", [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>;
@@ -3941,13 +3945,13 @@ def mdisable_tail_calls : Flag<["-"], "mdisable-tail-calls">,
HelpText<"Disable tail call optimization, keeping the call stack accurate">;
def menable_no_infinities : Flag<["-"], "menable-no-infs">,
HelpText<"Allow optimization to assume there are no infinities.">,
- MarshallingInfoFlag<"LangOpts->NoHonorInfs", DefaultAnyOf<[ffinite_math_only]>>;
+ MarshallingInfoFlag<"LangOpts->NoHonorInfs">, ImpliedByAnyOf<[ffinite_math_only]>;
def menable_no_nans : Flag<["-"], "menable-no-nans">,
HelpText<"Allow optimization to assume there are no NaNs.">,
- MarshallingInfoFlag<"LangOpts->NoHonorNaNs", DefaultAnyOf<[ffinite_math_only]>>;
+ MarshallingInfoFlag<"LangOpts->NoHonorNaNs">, ImpliedByAnyOf<[ffinite_math_only]>;
def mreassociate : Flag<["-"], "mreassociate">,
HelpText<"Allow reassociation transformations for floating-point instructions">,
- MarshallingInfoFlag<"LangOpts->AllowFPReassoc", DefaultAnyOf<[menable_unsafe_fp_math]>>;
+ MarshallingInfoFlag<"LangOpts->AllowFPReassoc">, ImpliedByAnyOf<[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">,
@@ -4067,9 +4071,11 @@ def fdenormal_fp_math_f32_EQ : Joined<["-"], "fdenormal-fp-math-f32=">,
//===----------------------------------------------------------------------===//
def sys_header_deps : Flag<["-"], "sys-header-deps">,
- HelpText<"Include system headers in dependency output">;
+ HelpText<"Include system headers in dependency output">,
+ MarshallingInfoFlag<"DependencyOutputOpts.IncludeSystemHeaders">;
def module_file_deps : Flag<["-"], "module-file-deps">,
- HelpText<"Include module files in dependency output">;
+ HelpText<"Include module files in dependency output">,
+ MarshallingInfoFlag<"DependencyOutputOpts.IncludeModuleFiles">;
def header_include_file : Separate<["-"], "header-include-file">,
HelpText<"Filename (or -) to write header include output to">;
def show_includes : Flag<["--"], "show-includes">,
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index 35cd1a4f949e..6b4da610d396 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -3789,9 +3789,12 @@ bool CompilerInvocation::parseSimpleArgs(const ArgList &Args,
#define OPTION_WITH_MARSHALLING( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
- NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
+ IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
+ TABLE_INDEX) \
{ \
this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE); \
+ if (IMPLIED_CHECK) \
+ this->KEYPATH = MERGER(this->KEYPATH, IMPLIED_VALUE); \
if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, Args, Diags)) \
this->KEYPATH = MERGER( \
this->KEYPATH, static_cast<decltype(this->KEYPATH)>(*MaybeValue)); \
@@ -3800,15 +3803,16 @@ bool CompilerInvocation::parseSimpleArgs(const ArgList &Args,
#define OPTION_WITH_MARSHALLING_BOOLEAN( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
- NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX, NEG_ID, \
- NEG_SPELLING) \
+ IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
+ TABLE_INDEX, NEG_ID, NEG_SPELLING) \
{ \
+ this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE); \
+ if (IMPLIED_CHECK) \
+ this->KEYPATH = MERGER(this->KEYPATH, IMPLIED_VALUE); \
if (auto MaybeValue = \
NORMALIZER(OPT_##ID, OPT_##NEG_ID, TABLE_INDEX, Args, Diags)) \
this->KEYPATH = MERGER( \
this->KEYPATH, static_cast<decltype(this->KEYPATH)>(*MaybeValue)); \
- else \
- this->KEYPATH = MERGER(this->KEYPATH, DEFAULT_VALUE); \
}
#include "clang/Driver/Options.inc"
@@ -4067,10 +4071,12 @@ void CompilerInvocation::generateCC1CommandLine(
#define OPTION_WITH_MARSHALLING( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
- NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
+ IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
+ TABLE_INDEX) \
if ((FLAGS)&options::CC1Option) { \
[&](const auto &Extracted) { \
- if (ALWAYS_EMIT || Extracted != (DEFAULT_VALUE)) \
+ if (ALWAYS_EMIT || (Extracted != ((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
+ : (DEFAULT_VALUE)))) \
DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, Extracted); \
}(EXTRACTOR(this->KEYPATH)); \
}
@@ -4078,11 +4084,12 @@ void CompilerInvocation::generateCC1CommandLine(
#define OPTION_WITH_MARSHALLING_BOOLEAN( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
- NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX, NEG_ID, \
- NEG_SPELLING) \
+ IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
+ TABLE_INDEX, NEG_ID, NEG_SPELLING) \
if ((FLAGS)&options::CC1Option) { \
bool Extracted = EXTRACTOR(this->KEYPATH); \
- if (ALWAYS_EMIT || Extracted != (DEFAULT_VALUE)) \
+ if (ALWAYS_EMIT || \
+ (Extracted != ((IMPLIED_CHECK) ? (IMPLIED_VALUE) : (DEFAULT_VALUE)))) \
DENORMALIZER(Args, SPELLING, NEG_SPELLING, SA, TABLE_INDEX, Extracted); \
}
diff --git a/clang/unittests/Frontend/CompilerInvocationTest.cpp b/clang/unittests/Frontend/CompilerInvocationTest.cpp
index d9b55f0ae5ba..f14fa58ba817 100644
--- a/clang/unittests/Frontend/CompilerInvocationTest.cpp
+++ b/clang/unittests/Frontend/CompilerInvocationTest.cpp
@@ -134,7 +134,36 @@ TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineSeparateEnum) {
ASSERT_THAT(GeneratedArgs, Each(StrNe(RelocationModelCStr)));
}
-TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineImpliedFlags) {
+TEST_F(CC1CommandLineGenerationTest, NotPresentAndNotImpliedNotGenerated) {
+ const char *Args[] = {"clang", "-xc++"};
+
+ CompilerInvocation CInvok;
+ CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
+
+ CInvok.generateCC1CommandLine(GeneratedArgs, *this);
+
+ // Missing options are not generated.
+ ASSERT_THAT(GeneratedArgs,
+ Not(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"))));
+}
+
+TEST_F(CC1CommandLineGenerationTest, NotPresentAndImpliedNotGenerated) {
+ const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"};
+
+ CompilerInvocation CInvok;
+ CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
+
+ CInvok.generateCC1CommandLine(GeneratedArgs, *this);
+
+ // Missing options that were implied 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"))));
+}
+
+TEST_F(CC1CommandLineGenerationTest, PresentAndImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations",
"-cl-mad-enable", "-menable-unsafe-fp-math"};
@@ -143,11 +172,23 @@ TEST_F(CC1CommandLineGenerationTest, CanGenerateCC1CommandLineImpliedFlags) {
CInvok.generateCC1CommandLine(GeneratedArgs, *this);
- // Explicitly provided flags that were also implied by another flag are not
- // generated.
+ // Present options that were also implied 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"))));
}
+TEST_F(CC1CommandLineGenerationTest, PresentAndNotImpliedGenerated) {
+ const char *Args[] = {"clang", "-xc++", "-cl-mad-enable",
+ "-menable-unsafe-fp-math"};
+
+ CompilerInvocation CInvok;
+ CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags);
+
+ CInvok.generateCC1CommandLine(GeneratedArgs, *this);
+
+ // Present options that were not implied are generated.
+ ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
+ ASSERT_THAT(GeneratedArgs, 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 ea94abdff40a..67fda9112ac3 100644
--- a/llvm/include/llvm/Option/OptParser.td
+++ b/llvm/include/llvm/Option/OptParser.td
@@ -100,6 +100,8 @@ class Option<list<string> prefixes, string name, OptionKind kind> {
string MarshallingInfoKind = ?;
code KeyPath = ?;
code DefaultValue = ?;
+ code ImpliedValue = ?;
+ code ImpliedCheck = "false";
bit ShouldAlwaysEmit = false;
code NormalizerRetTy = ?;
code NormalizedValuesScope = "";
@@ -145,9 +147,10 @@ class ValuesCode<code valuecode> { code ValuesCode = valuecode; }
// Helpers for defining marshalling information.
-class DefaultAnyOf<list<Option> options, string default = "false", string separator = " || "> {
- code DefaultValue = !foldl(default, options, accumulator, option,
- !strconcat(accumulator, separator, !cast<string>(option.KeyPath)));
+class ImpliedByAnyOf<list<Option> options, code value = "true"> {
+ code ImpliedCheck = !foldl("false", options, accumulator, option,
+ !strconcat(accumulator, " || ", !cast<string>(option.KeyPath)));
+ code ImpliedValue = value;
}
class MarshallingInfo<code keypath, code defaultvalue> {
@@ -159,21 +162,21 @@ class MarshallingInfo<code keypath, code defaultvalue> {
class MarshallingInfoString<code keypath, code defaultvalue>
: MarshallingInfo<keypath, defaultvalue> {}
-class MarshallingInfoFlag<code keypath, DefaultAnyOf defaults = DefaultAnyOf<[]>>
- : MarshallingInfo<keypath, defaults.DefaultValue> {
+class MarshallingInfoFlag<code keypath, code defaultvalue = "false">
+ : MarshallingInfo<keypath, defaultvalue> {
code Normalizer = "normalizeSimpleFlag";
code Denormalizer = "denormalizeSimpleFlag";
}
class MarshallingInfoBitfieldFlag<code keypath, code value>
- : MarshallingInfoFlag<keypath, DefaultAnyOf<[], "0u", " | ">> {
+ : MarshallingInfoFlag<keypath, "0u"> {
code Normalizer = "(normalizeFlagToValue<unsigned, "#value#">)";
code ValueMerger = "mergeMaskValue";
code ValueExtractor = "(extractMaskValue<unsigned, decltype("#value#"), "#value#">)";
}
class MarshallingInfoBooleanFlag<code keypath, code defaultvalue, Option negopt>
- : MarshallingInfoFlag<keypath, DefaultAnyOf<[], defaultvalue>> {
+ : MarshallingInfoFlag<keypath, defaultvalue> {
bit ShouldAlwaysEmit = 1;
string MarshallingInfoKind = "BooleanFlag";
code Normalizer = "normalizeBooleanFlag";
diff --git a/llvm/unittests/Option/OptionMarshallingTest.cpp b/llvm/unittests/Option/OptionMarshallingTest.cpp
index 4b53d047be89..71fb807b9253 100644
--- a/llvm/unittests/Option/OptionMarshallingTest.cpp
+++ b/llvm/unittests/Option/OptionMarshallingTest.cpp
@@ -11,15 +11,17 @@
struct OptionWithMarshallingInfo {
const char *Name;
const char *KeyPath;
- const char *DefaultValue;
+ const char *ImpliedCheck;
+ const char *ImpliedValue;
};
static const OptionWithMarshallingInfo MarshallingTable[] = {
#define OPTION_WITH_MARSHALLING( \
PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES, SPELLING, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, \
- NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
- {NAME, #KEYPATH, #DEFAULT_VALUE},
+ IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
+ TABLE_INDEX) \
+ {NAME, #KEYPATH, #IMPLIED_CHECK, #IMPLIED_VALUE},
#include "Opts.inc"
#undef OPTION_WITH_MARSHALLING
};
@@ -38,10 +40,16 @@ TEST(OptionMarshalling, EmittedSpecifiedKeyPath) {
ASSERT_STREQ(MarshallingTable[3].KeyPath, "MarshalledFlagA");
}
-TEST(OptionMarshalling, DefaultAnyOfConstructedDisjunctionOfKeypaths) {
- ASSERT_STREQ(MarshallingTable[0].DefaultValue, "false");
- ASSERT_STREQ(MarshallingTable[1].DefaultValue, "false || MarshalledFlagD");
- ASSERT_STREQ(MarshallingTable[2].DefaultValue, "false || MarshalledFlagD");
- ASSERT_STREQ(MarshallingTable[3].DefaultValue,
- "false || MarshalledFlagC || MarshalledFlagB");
+TEST(OptionMarshalling, ImpliedCheckContainsDisjunctionOfKeypaths) {
+ ASSERT_STREQ(MarshallingTable[0].ImpliedCheck, "false");
+
+ ASSERT_STREQ(MarshallingTable[1].ImpliedCheck, "false || MarshalledFlagD");
+ ASSERT_STREQ(MarshallingTable[1].ImpliedValue, "true");
+
+ ASSERT_STREQ(MarshallingTable[2].ImpliedCheck, "false || MarshalledFlagD");
+ ASSERT_STREQ(MarshallingTable[2].ImpliedValue, "true");
+
+ ASSERT_STREQ(MarshallingTable[3].ImpliedCheck,
+ "false || MarshalledFlagC || MarshalledFlagB");
+ ASSERT_STREQ(MarshallingTable[3].ImpliedValue, "true");
}
diff --git a/llvm/unittests/Option/Opts.td b/llvm/unittests/Option/Opts.td
index 62cd6151ea9e..01275a964203 100644
--- a/llvm/unittests/Option/Opts.td
+++ b/llvm/unittests/Option/Opts.td
@@ -46,10 +46,13 @@ def Blurmpq_eq : Flag<["--"], "blurmp=">;
def DashDash : Option<["--"], "", KIND_REMAINING_ARGS>;
def marshalled_flag_d : Flag<["-"], "marshalled-flag-d">,
- MarshallingInfoFlag<"MarshalledFlagD", DefaultAnyOf<[]>>;
+ MarshallingInfoFlag<"MarshalledFlagD">;
def marshalled_flag_c : Flag<["-"], "marshalled-flag-c">,
- MarshallingInfoFlag<"MarshalledFlagC", DefaultAnyOf<[marshalled_flag_d]>>;
+ MarshallingInfoFlag<"MarshalledFlagC">,
+ ImpliedByAnyOf<[marshalled_flag_d], "true">;
def marshalled_flag_b : Flag<["-"], "marshalled-flag-b">,
- MarshallingInfoFlag<"MarshalledFlagB", DefaultAnyOf<[marshalled_flag_d]>>;
+ MarshallingInfoFlag<"MarshalledFlagB">,
+ ImpliedByAnyOf<[marshalled_flag_d], "true">;
def marshalled_flag_a : Flag<["-"], "marshalled-flag-a">,
- MarshallingInfoFlag<"MarshalledFlagA", DefaultAnyOf<[marshalled_flag_c, marshalled_flag_b]>>;
+ MarshallingInfoFlag<"MarshalledFlagA">,
+ ImpliedByAnyOf<[marshalled_flag_c, marshalled_flag_b]>;
diff --git a/llvm/utils/TableGen/OptParserEmitter.cpp b/llvm/utils/TableGen/OptParserEmitter.cpp
index 91d9aeb104fb..edbe66630572 100644
--- a/llvm/utils/TableGen/OptParserEmitter.cpp
+++ b/llvm/utils/TableGen/OptParserEmitter.cpp
@@ -71,6 +71,8 @@ class MarshallingInfo {
StringRef KeyPath;
StringRef DefaultValue;
StringRef NormalizedValuesScope;
+ StringRef ImpliedCheck;
+ StringRef ImpliedValue;
StringRef Normalizer;
StringRef Denormalizer;
StringRef ValueMerger;
@@ -113,6 +115,10 @@ struct SimpleEnumValueTable {
OS << ", ";
emitScopedNormalizedValue(OS, DefaultValue);
OS << ", ";
+ OS << ImpliedCheck;
+ OS << ", ";
+ emitScopedNormalizedValue(OS, ImpliedValue);
+ OS << ", ";
OS << Normalizer;
OS << ", ";
OS << Denormalizer;
@@ -188,6 +194,9 @@ static MarshallingInfo::Ptr createMarshallingInfo(const Record &R) {
Ret->KeyPath = R.getValueAsString("KeyPath");
Ret->DefaultValue = R.getValueAsString("DefaultValue");
Ret->NormalizedValuesScope = R.getValueAsString("NormalizedValuesScope");
+ Ret->ImpliedCheck = R.getValueAsString("ImpliedCheck");
+ Ret->ImpliedValue =
+ R.getValueAsOptionalString("ImpliedValue").getValueOr(Ret->DefaultValue);
Ret->Normalizer = R.getValueAsString("Normalizer");
Ret->Denormalizer = R.getValueAsString("Denormalizer");
More information about the llvm-branch-commits
mailing list