jansvoboda11 updated this revision to Diff 307028. jansvoboda11 added a comment.
Add tests, fix condition in generator Repository: rG LLVM Github Monorepo CHANGES SINCE LAST ACTION https://reviews.llvm.org/D91861/new/ https://reviews.llvm.org/D91861 Files: 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
Index: llvm/utils/TableGen/OptParserEmitter.cpp =================================================================== --- llvm/utils/TableGen/OptParserEmitter.cpp +++ llvm/utils/TableGen/OptParserEmitter.cpp @@ -71,6 +71,8 @@ StringRef KeyPath; StringRef DefaultValue; StringRef NormalizedValuesScope; + StringRef ImpliedCheck; + StringRef ImpliedValue; StringRef Normalizer; StringRef Denormalizer; StringRef ValueMerger; @@ -113,6 +115,10 @@ OS << ", "; emitScopedNormalizedValue(OS, DefaultValue); OS << ", "; + OS << ImpliedCheck; + OS << ", "; + emitScopedNormalizedValue(OS, ImpliedValue); + OS << ", "; OS << Normalizer; OS << ", "; OS << Denormalizer; @@ -188,6 +194,9 @@ 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"); Index: llvm/unittests/Option/Opts.td =================================================================== --- llvm/unittests/Option/Opts.td +++ llvm/unittests/Option/Opts.td @@ -46,10 +46,13 @@ 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]>; Index: llvm/unittests/Option/OptionMarshallingTest.cpp =================================================================== --- llvm/unittests/Option/OptionMarshallingTest.cpp +++ 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 @@ 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"); } Index: llvm/include/llvm/Option/OptParser.td =================================================================== --- llvm/include/llvm/Option/OptParser.td +++ llvm/include/llvm/Option/OptParser.td @@ -100,6 +100,8 @@ string MarshallingInfoKind = ?; code KeyPath = ?; code DefaultValue = ?; + code ImpliedValue = ?; + code ImpliedCheck = "false"; bit ShouldAlwaysEmit = false; code NormalizerRetTy = ?; code NormalizedValuesScope = ""; @@ -145,9 +147,10 @@ // 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 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"; Index: clang/unittests/Frontend/CompilerInvocationTest.cpp =================================================================== --- clang/unittests/Frontend/CompilerInvocationTest.cpp +++ clang/unittests/Frontend/CompilerInvocationTest.cpp @@ -134,7 +134,36 @@ 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 @@ 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 Index: clang/lib/Frontend/CompilerInvocation.cpp =================================================================== --- clang/lib/Frontend/CompilerInvocation.cpp +++ clang/lib/Frontend/CompilerInvocation.cpp @@ -3742,9 +3742,12 @@ #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)); \ @@ -3753,15 +3756,16 @@ #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" @@ -4018,19 +4022,24 @@ #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) \ - if (((FLAGS) & options::CC1Option) && \ - (ALWAYS_EMIT || EXTRACTOR(this->KEYPATH) != (DEFAULT_VALUE))) { \ + IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \ + TABLE_INDEX) \ + if (((FLAGS)&options::CC1Option) && \ + (ALWAYS_EMIT || \ + (EXTRACTOR(this->KEYPATH) != \ + ((IMPLIED_CHECK) ? (IMPLIED_VALUE) : (DEFAULT_VALUE))))) { \ DENORMALIZER(Args, SPELLING, SA, TABLE_INDEX, EXTRACTOR(this->KEYPATH)); \ } #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) && \ - (ALWAYS_EMIT || EXTRACTOR(this->KEYPATH) != DEFAULT_VALUE)) { \ + (ALWAYS_EMIT || \ + (EXTRACTOR(this->KEYPATH) != \ + ((IMPLIED_CHECK) ? (IMPLIED_VALUE) : (DEFAULT_VALUE))))) { \ DENORMALIZER(Args, SPELLING, NEG_SPELLING, SA, TABLE_INDEX, \ EXTRACTOR(this->KEYPATH)); \ } Index: clang/include/clang/Driver/Options.td =================================================================== --- clang/include/clang/Driver/Options.td +++ clang/include/clang/Driver/Options.td @@ -246,10 +246,11 @@ // 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 @@ // 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 @@ 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">; @@ -1040,10 +1043,11 @@ 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>; @@ -1257,13 +1261,13 @@ 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>; @@ -3920,13 +3924,13 @@ 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">, @@ -4046,9 +4050,11 @@ //===----------------------------------------------------------------------===// 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">,
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits