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"); _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
