llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-driver @llvm/pr-subscribers-clang Author: Shunsuke Watanabe (s-watanabe314) <details> <summary>Changes</summary> This patch improves the warnings to show which user options override the complex range. When a complex range is overridden, explicitly display both the option name and the implied complex range value for both the overriding and the overridden options. See also the discussion in the following discourse post: https://discourse.llvm.org/t/the-priority-of-fno-fast-math-regarding-complex-number-calculations/84679 --- Patch is 55.05 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/154899.diff 7 Files Affected: - (modified) clang/include/clang/Basic/DiagnosticDriverKinds.td (+3) - (modified) clang/lib/Driver/ToolChains/Clang.cpp (+63-101) - (modified) clang/lib/Driver/ToolChains/CommonArgs.cpp (+3) - (modified) clang/test/Driver/cl-options.c (+4-2) - (modified) clang/test/Driver/fp-model.c (+6-5) - (added) clang/test/Driver/range-wanings.c (+605) - (modified) clang/test/Driver/range.c (+5-58) ``````````diff diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td index 6df8f9932f30f..fad8afd98b1a3 100644 --- a/clang/include/clang/Basic/DiagnosticDriverKinds.td +++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td @@ -488,6 +488,9 @@ def warn_drv_overriding_option : Warning< def warn_drv_overriding_deployment_version : Warning<"overriding deployment version from '%0' to '%1'">, InGroup<DiagGroup<"overriding-deployment-version">>; +def warn_drv_overriding_complex_range : Warning< + "'%1' sets complex range to \"%3\" overriding the setting of \"%2\" that was implied by '%0'">, + InGroup<DiagGroup<"overriding-complex-range">>; def warn_drv_treating_input_as_cxx : Warning< "treating '%0' input as '%1' when in C++ mode, this behavior is deprecated">, InGroup<Deprecated>; diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 29b7180df5cb5..81f1d2dbac349 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -2730,17 +2730,38 @@ static void CollectArgsForIntegratedAssembler(Compilation &C, } } -static std::string ComplexArithmeticStr(LangOptions::ComplexRangeKind Range) { - return (Range == LangOptions::ComplexRangeKind::CX_None) - ? "" - : "-fcomplex-arithmetic=" + complexRangeKindToStr(Range); -} +static void EmitComplexRangeDiag(const Driver &D, StringRef LastOpt, + LangOptions::ComplexRangeKind Range, + StringRef NewOpt, + LangOptions::ComplexRangeKind NewRange) { + // Do not emit a warning if NewOpt overrides LastOpt in the following cases. + // + // | LastOpt | NewOpt | + // |-----------------------|-----------------------| + // | -fcx-limited-range | -fno-cx-limited-range | + // | -fno-cx-limited-range | -fcx-limited-range | + // | -fcx-fortran-rules | -fno-cx-fortran-rules | + // | -fno-cx-fortran-rules | -fcx-fortran-rules | + // | -ffast-math | -fno-fast-math | + // | -ffp-model= | -fno-fast-math | + // | -ffp-model= | -ffp-model= | + // | -fcomplex-arithmetic= | -fcomplex-arithmetic= | + if (LastOpt == NewOpt || NewOpt.empty() || LastOpt.empty() || + (LastOpt == "-fcx-limited-range" && NewOpt == "-fno-cx-limited-range") || + (LastOpt == "-fno-cx-limited-range" && NewOpt == "-fcx-limited-range") || + (LastOpt == "-fcx-fortran-rules" && NewOpt == "-fno-cx-fortran-rules") || + (LastOpt == "-fno-cx-fortran-rules" && NewOpt == "-fcx-fortran-rules") || + (LastOpt == "-ffast-math" && NewOpt == "-fno-fast-math") || + (LastOpt.starts_with("-ffp-model=") && NewOpt == "-fno-fast-math") || + (LastOpt.starts_with("-ffp-model=") && + NewOpt.starts_with("-ffp-model=")) || + (LastOpt.starts_with("-fcomplex-arithmetic=") && + NewOpt.starts_with("-fcomplex-arithmetic="))) + return; -static void EmitComplexRangeDiag(const Driver &D, std::string str1, - std::string str2) { - if (str1 != str2 && !str2.empty() && !str1.empty()) { - D.Diag(clang::diag::warn_drv_overriding_option) << str1 << str2; - } + D.Diag(clang::diag::warn_drv_overriding_complex_range) + << LastOpt << NewOpt << complexRangeKindToStr(Range) + << complexRangeKindToStr(NewRange); } static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, @@ -2797,31 +2818,29 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, StringRef BFloat16ExcessPrecision = ""; LangOptions::ComplexRangeKind Range = LangOptions::ComplexRangeKind::CX_None; std::string ComplexRangeStr; - std::string GccRangeComplexOption; - std::string LastComplexRangeOption; - - auto setComplexRange = [&](LangOptions::ComplexRangeKind NewRange) { - // Warn if user expects to perform full implementation of complex - // multiplication or division in the presence of nnan or ninf flags. - if (Range != NewRange) - EmitComplexRangeDiag(D, - !GccRangeComplexOption.empty() - ? GccRangeComplexOption - : ComplexArithmeticStr(Range), - ComplexArithmeticStr(NewRange)); + StringRef LastComplexRangeOption; + + auto setComplexRange = [&](StringRef NewOption, + LangOptions::ComplexRangeKind NewRange) { + // Warn if user overrides the previously set complex number + // multiplication/division option. + if (Range != LangOptions::ComplexRangeKind::CX_None && Range != NewRange) + EmitComplexRangeDiag(D, LastComplexRangeOption, Range, NewOption, + NewRange); + LastComplexRangeOption = NewOption; Range = NewRange; }; // Lambda to set fast-math options. This is also used by -ffp-model=fast - auto applyFastMath = [&](bool Aggressive) { + auto applyFastMath = [&](bool Aggressive, StringRef CallerOption) { if (Aggressive) { HonorINFs = false; HonorNaNs = false; - setComplexRange(LangOptions::ComplexRangeKind::CX_Basic); + setComplexRange(CallerOption, LangOptions::ComplexRangeKind::CX_Basic); } else { HonorINFs = true; HonorNaNs = true; - setComplexRange(LangOptions::ComplexRangeKind::CX_Promoted); + setComplexRange(CallerOption, LangOptions::ComplexRangeKind::CX_Promoted); } MathErrno = false; AssociativeMath = true; @@ -2873,54 +2892,18 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, default: continue; case options::OPT_fcx_limited_range: - if (GccRangeComplexOption.empty()) { - if (Range != LangOptions::ComplexRangeKind::CX_Basic) - EmitComplexRangeDiag(D, renderComplexRangeOption(Range), - "-fcx-limited-range"); - } else { - if (GccRangeComplexOption != "-fno-cx-limited-range") - EmitComplexRangeDiag(D, GccRangeComplexOption, "-fcx-limited-range"); - } - GccRangeComplexOption = "-fcx-limited-range"; - LastComplexRangeOption = A->getSpelling(); - Range = LangOptions::ComplexRangeKind::CX_Basic; + setComplexRange(A->getSpelling(), + LangOptions::ComplexRangeKind::CX_Basic); break; case options::OPT_fno_cx_limited_range: - if (GccRangeComplexOption.empty()) { - EmitComplexRangeDiag(D, renderComplexRangeOption(Range), - "-fno-cx-limited-range"); - } else { - if (GccRangeComplexOption != "-fcx-limited-range" && - GccRangeComplexOption != "-fno-cx-fortran-rules") - EmitComplexRangeDiag(D, GccRangeComplexOption, - "-fno-cx-limited-range"); - } - GccRangeComplexOption = "-fno-cx-limited-range"; - LastComplexRangeOption = A->getSpelling(); - Range = LangOptions::ComplexRangeKind::CX_Full; + setComplexRange(A->getSpelling(), LangOptions::ComplexRangeKind::CX_Full); break; case options::OPT_fcx_fortran_rules: - if (GccRangeComplexOption.empty()) - EmitComplexRangeDiag(D, renderComplexRangeOption(Range), - "-fcx-fortran-rules"); - else - EmitComplexRangeDiag(D, GccRangeComplexOption, "-fcx-fortran-rules"); - GccRangeComplexOption = "-fcx-fortran-rules"; - LastComplexRangeOption = A->getSpelling(); - Range = LangOptions::ComplexRangeKind::CX_Improved; + setComplexRange(A->getSpelling(), + LangOptions::ComplexRangeKind::CX_Improved); break; case options::OPT_fno_cx_fortran_rules: - if (GccRangeComplexOption.empty()) { - EmitComplexRangeDiag(D, renderComplexRangeOption(Range), - "-fno-cx-fortran-rules"); - } else { - if (GccRangeComplexOption != "-fno-cx-limited-range") - EmitComplexRangeDiag(D, GccRangeComplexOption, - "-fno-cx-fortran-rules"); - } - GccRangeComplexOption = "-fno-cx-fortran-rules"; - LastComplexRangeOption = A->getSpelling(); - Range = LangOptions::ComplexRangeKind::CX_Full; + setComplexRange(A->getSpelling(), LangOptions::ComplexRangeKind::CX_Full); break; case options::OPT_fcomplex_arithmetic_EQ: { LangOptions::ComplexRangeKind RangeVal; @@ -2938,25 +2921,7 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, << A->getSpelling() << Val; break; } - if (!GccRangeComplexOption.empty()) { - if (GccRangeComplexOption != "-fcx-limited-range") { - if (GccRangeComplexOption != "-fcx-fortran-rules") { - if (RangeVal != LangOptions::ComplexRangeKind::CX_Improved) - EmitComplexRangeDiag(D, GccRangeComplexOption, - ComplexArithmeticStr(RangeVal)); - } else { - EmitComplexRangeDiag(D, GccRangeComplexOption, - ComplexArithmeticStr(RangeVal)); - } - } else { - if (RangeVal != LangOptions::ComplexRangeKind::CX_Basic) - EmitComplexRangeDiag(D, GccRangeComplexOption, - ComplexArithmeticStr(RangeVal)); - } - } - LastComplexRangeOption = - Args.MakeArgString(A->getSpelling() + A->getValue()); - Range = RangeVal; + setComplexRange(Args.MakeArgString(A->getSpelling() + Val), RangeVal); break; } case options::OPT_ffp_model_EQ: { @@ -2984,19 +2949,20 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, << Args.MakeArgString("-ffp-model=" + Val); if (Val == "fast") { FPModel = Val; - applyFastMath(false); + applyFastMath(false, Args.MakeArgString(A->getSpelling() + Val)); // applyFastMath sets fp-contract="fast" LastFpContractOverrideOption = "-ffp-model=fast"; } else if (Val == "aggressive") { FPModel = Val; - applyFastMath(true); + applyFastMath(true, Args.MakeArgString(A->getSpelling() + Val)); // applyFastMath sets fp-contract="fast" LastFpContractOverrideOption = "-ffp-model=aggressive"; } else if (Val == "precise") { FPModel = Val; FPContract = "on"; LastFpContractOverrideOption = "-ffp-model=precise"; - setComplexRange(LangOptions::ComplexRangeKind::CX_Full); + setComplexRange(Args.MakeArgString(A->getSpelling() + Val), + LangOptions::ComplexRangeKind::CX_Full); } else if (Val == "strict") { StrictFPModel = true; FPExceptionBehavior = "strict"; @@ -3005,11 +2971,11 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, LastFpContractOverrideOption = "-ffp-model=strict"; TrappingMath = true; RoundingFPMath = true; - setComplexRange(LangOptions::ComplexRangeKind::CX_Full); + setComplexRange(Args.MakeArgString(A->getSpelling() + Val), + LangOptions::ComplexRangeKind::CX_Full); } else D.Diag(diag::err_drv_unsupported_option_argument) << A->getSpelling() << Val; - LastComplexRangeOption = A->getSpelling(); break; } @@ -3194,8 +3160,7 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, continue; [[fallthrough]]; case options::OPT_ffast_math: - applyFastMath(true); - LastComplexRangeOption = A->getSpelling(); + applyFastMath(true, A->getSpelling()); if (A->getOption().getID() == options::OPT_Ofast) LastFpContractOverrideOption = "-Ofast"; else @@ -3213,15 +3178,12 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, ApproxFunc = false; SignedZeros = true; restoreFPContractState(); - // If the last specified option related to complex range is not - // -ffast-math or -ffp-model=, emit warning. - if (LastComplexRangeOption != "-ffast-math" && - LastComplexRangeOption != "-ffp-model=" && - Range != LangOptions::ComplexRangeKind::CX_Full) - EmitComplexRangeDiag(D, LastComplexRangeOption, "-fno-fast-math"); - Range = LangOptions::ComplexRangeKind::CX_None; + if (Range != LangOptions::ComplexRangeKind::CX_Full) + setComplexRange(A->getSpelling(), + LangOptions::ComplexRangeKind::CX_None); + else + Range = LangOptions::ComplexRangeKind::CX_None; LastComplexRangeOption = ""; - GccRangeComplexOption = ""; LastFpContractOverrideOption = ""; break; } // End switch (A->getOption().getID()) diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index a21f89da55009..98230e4d19bda 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -3518,6 +3518,9 @@ std::string tools::complexRangeKindToStr(LangOptions::ComplexRangeKind Range) { case LangOptions::ComplexRangeKind::CX_Promoted: return "promoted"; break; + case LangOptions::ComplexRangeKind::CX_None: + return "none"; + break; default: return ""; } diff --git a/clang/test/Driver/cl-options.c b/clang/test/Driver/cl-options.c index 57e16e8795a28..627592e808d78 100644 --- a/clang/test/Driver/cl-options.c +++ b/clang/test/Driver/cl-options.c @@ -54,11 +54,13 @@ // fpfast: -funsafe-math-optimizations // fpfast: -ffast-math -// RUN: %clang_cl /fp:fast /fp:precise -### -- %s 2>&1 | FileCheck -check-prefix=fpprecise %s +// RUN: %clang_cl /fp:fast /fp:precise -Wno-overriding-complex-range -### -- %s 2>&1 | \ +// RUN: FileCheck -check-prefix=fpprecise %s // fpprecise-NOT: -funsafe-math-optimizations // fpprecise-NOT: -ffast-math -// RUN: %clang_cl /fp:fast /fp:strict -### -- %s 2>&1 | FileCheck -check-prefix=fpstrict %s +// RUN: %clang_cl /fp:fast /fp:strict -Wno-overriding-complex-range -### -- %s 2>&1 | \ +// RUN: FileCheck -check-prefix=fpstrict %s // fpstrict-NOT: -funsafe-math-optimizations // fpstrict-NOT: -ffast-math // fpstrict: -ffp-contract=off diff --git a/clang/test/Driver/fp-model.c b/clang/test/Driver/fp-model.c index 6f17d4aeb1ef5..9cf5d0c53b24b 100644 --- a/clang/test/Driver/fp-model.c +++ b/clang/test/Driver/fp-model.c @@ -81,8 +81,7 @@ // WARN12: warning: overriding '-ffp-model=strict' option with '-Ofast' // RUN: %clang -### -ffast-math -ffp-model=strict -c %s 2>&1 | FileCheck \ -// RUN: --check-prefix=WARN-CX-BASIC-TO-FULL %s -// WARN-CX-BASIC-TO-FULL: warning: overriding '-fcomplex-arithmetic=basic' option with '-fcomplex-arithmetic=full' +// RUN: --check-prefix=CHECK-FASTMATH-FPM-STRICT %s // RUN: %clang -### -ffp-model=strict -fapprox-func -c %s 2>&1 \ // RUN: | FileCheck --check-prefix=WARN13 %s @@ -205,7 +204,7 @@ // RUN: %clang -### -nostdinc -ffast-math -ffp-model=fast -c %s 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-FASTMATH-FPM-FAST %s -// CHECK-FASTMATH-FPM-FAST: warning: overriding '-fcomplex-arithmetic=basic' option with '-fcomplex-arithmetic=promoted' +// CHECK-FASTMATH-FPM-FAST: warning: '-ffp-model=fast' sets complex range to "promoted" overriding the setting of "basic" that was implied by '-ffast-math' // CHECK-FASTMATH-FPM-FAST: "-cc1" // CHECK-FASTMATH-FPM-FAST-NOT: "-menable-no-infs" // CHECK-FASTMATH-FPM-FAST-NOT: "-menable-no-nans" @@ -221,7 +220,8 @@ // CHECK-FASTMATH-FPM-FAST-SAME: "-complex-range=promoted" // RUN: %clang -### -nostdinc -ffast-math -ffp-model=precise -c %s 2>&1 \ -// RUN: | FileCheck --check-prefixes=CHECK-FASTMATH-FPM-PRECISE,WARN-CX-BASIC-TO-FULL %s +// RUN: | FileCheck --check-prefixes=CHECK-FASTMATH-FPM-PRECISE %s +// CHECK-FASTMATH-FPM-PRECISE: warning: '-ffp-model=precise' sets complex range to "full" overriding the setting of "basic" that was implied by '-ffast-math' // CHECK-FASTMATH-FPM-PRECISE: "-cc1" // CHECK-FASTMATH-FPM-PRECISE-NOT: "-menable-no-infs" // CHECK-FASTMATH-FPM-PRECISE-NOT: "-menable-no-nans" @@ -237,7 +237,8 @@ // CHECK-FASTMATH-FPM-PRECISE-SAME: "-complex-range=full" // RUN: %clang -### -nostdinc -ffast-math -ffp-model=strict -c %s 2>&1 \ -// RUN: | FileCheck --check-prefixes=CHECK-FASTMATH-FPM-STRICT,WARN-CX-BASIC-TO-FULL %s +// RUN: | FileCheck --check-prefixes=CHECK-FASTMATH-FPM-STRICT %s +// CHECK-FASTMATH-FPM-STRICT: warning: '-ffp-model=strict' sets complex range to "full" overriding the setting of "basic" that was implied by '-ffast-math' // CHECK-FASTMATH-FPM-STRICT: "-cc1" // CHECK-FASTMATH-FPM-STRICT-NOT: "-menable-no-infs" // CHECK-FASTMATH-FPM-STRICT-NOT: "-menable-no-nans" diff --git a/clang/test/Driver/range-wanings.c b/clang/test/Driver/range-wanings.c new file mode 100644 index 0000000000000..368ac03f579c3 --- /dev/null +++ b/clang/test/Driver/range-wanings.c @@ -0,0 +1,605 @@ +// Test overriding warnings about complex range. +// range.c tests the settings of -complex-range=, and this test covers +// all warnings related to complex range. + +// Clang options related to complex range are as follows: +// -f[no-]fast-math +// -f[no-]cx-limited-range +// -f[no-]cx-fortran-rules +// -fcomplex-arithmetic=[full|improved|promoted|basic] +// -ffp-model=[strict|precise|fast|aggressive] + +// Emit warnings about overriding when options implying different +// complex ranges are specified. However, warnings are not emitted in +// the following cases: +// (a) When the positive/negative form or a different value of the same +// option is specified. +// Example: +// `-ffast-math -fno-fast-math` +// `-fcx-limited-range -fno-cx-limited-range` +// `-fcx-fortran-rules -fno-cx-fortran-rules` +// `-fcomplex-arithmetic=full -fcomplex-arithmetic=improved` +// `-ffp-model=strict -ffp-model=aggressive` +// +// (b) When -ffp-model= is negated by -fno-fast-math. +// Example: +// `-ffp-model=fast -fno-fast-math` + + +// RUN: %clang -### -Werror -ffast-math -fno-fast-math -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NO-OVR-WARN %s + +// RUN: %clang -### -Werror -ffast-math -fcx-limited-range -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NO-OVR-WARN %s + +// RUN: %clang -### -ffast-math -fno-cx-limited-range -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NOLIM-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -fcx-fortran-rules -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=FORT-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -fno-cx-fortran-rules -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NOFORT-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -fcomplex-arithmetic=full -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=ARITH-FULL-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -fcomplex-arithmetic=improved -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=ARITH-IMPROVED-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -fcomplex-arithmetic=promoted -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=ARITH-PROMOTED-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -Werror -ffast-math -fcomplex-arithmetic=basic -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NO-OVR-WARN %s + +// RUN: %clang -### -ffast-math -ffp-model=strict -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=MODEL-STRICT-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -ffp-model=precise -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=MODEL-PRECISE-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -ffast-math -ffp-model=fast -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=MODEL-FAST-OVERRIDING,FAST-OVERRIDDEN %s + +// RUN: %clang -### -Werror -ffast-math -ffp-model=aggressive -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NO-OVR-WARN %s + +// RUN: %clang -### -Werror -fno-fast-math -ffast-math -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NO-OVR-WARN %s + +// RUN: %clang -### -Werror -fno-fast-math -fcx-limited-range -c %s 2>&1 \ +// RUN: | FileCheck --check-prefixes=NO-OVR-WARN %s + +// RUN: %clang -### -We... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/154899 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
