This is an archive of the discontinued LLVM Phabricator instance.

Differential D154371

[flang] Warn about overflow after folding HYPOT
ClosedPublic

Authored by klausler on Jul 3 2023, 10:24 AM.

Details

Reviewers
vdonaldson
Commits
rGb2b43794b977: [flang] Warn about overflow after folding HYPOT
Summary

The code that folds the intrinsic function HYPOT was neglecting to
warn the programmer about overflow when it occurs.

Diff Detail

Event Timeline

klausler created this revision.Jul 3 2023, 10:24 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 3 2023, 10:24 AM
Herald added subscribers: sunshaoce, jdoerfert. · View Herald Transcript
klausler requested review of this revision.Jul 3 2023, 10:24 AM
vdonaldson accepted this revision.Jul 3 2023, 10:58 AM
This revision is now accepted and ready to land.Jul 3 2023, 10:58 AM
This revision was landed with ongoing or failed builds.Jul 3 2023, 11:21 AM
Closed by commit rGb2b43794b977: [flang] Warn about overflow after folding HYPOT (authored by klausler). · Explain Why
This revision was automatically updated to reflect the committed changes.
klausler added a commit: rGb2b43794b977: [flang] Warn about overflow after folding HYPOT.
Harbormaster completed remote builds in B242847: Diff 536833.Jul 3 2023, 1:50 PM

Revision Contents

PathSize
flang/
lib/
Evaluate/
9 lines
test/
Evaluate/
2 lines

Diff 536853

flang/lib/Evaluate/fold-real.cpp

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines return FoldElementalIntrinsic<T, T>(context, std::move(funcRef),
ScalarFunc<T, T>( ScalarFunc<T, T>(
[](const Scalar<T> &x) -> Scalar<T> { return x.FRACTION(); })); [](const Scalar<T> &x) -> Scalar<T> { return x.FRACTION(); }));
} else if (name == "huge") { } else if (name == "huge") {
return Expr<T>{Scalar<T>::HUGE()}; return Expr<T>{Scalar<T>::HUGE()};
} else if (name == "hypot") { } else if (name == "hypot") {
CHECK(args.size() == 2); CHECK(args.size() == 2);
return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef), return FoldElementalIntrinsic<T, T, T>(context, std::move(funcRef),
ScalarFunc<T, T, T>( ScalarFunc<T, T, T>(
[](const Scalar<T> &x, const Scalar<T> &y) -> Scalar<T> { [&](const Scalar<T> &x, const Scalar<T> &y) -> Scalar<T> {
return x.HYPOT(y).value; ValueWithRealFlags<Scalar<T>> result{x.HYPOT(y)};
if (result.flags.test(RealFlag::Overflow)) {
context.messages().Say(
"HYPOT intrinsic folding overflow"_warn_en_US);
}
return result.value;
})); }));
} else if (name == "max") { } else if (name == "max") {
return FoldMINorMAX(context, std::move(funcRef), Ordering::Greater); return FoldMINorMAX(context, std::move(funcRef), Ordering::Greater);
} else if (name == "maxval") { } else if (name == "maxval") {
return FoldMaxvalMinval<T>(context, std::move(funcRef), return FoldMaxvalMinval<T>(context, std::move(funcRef),
RelationalOperator::GT, T::Scalar::HUGE().Negate()); RelationalOperator::GT, T::Scalar::HUGE().Negate());
} else if (name == "merge") { } else if (name == "merge") {
return FoldMerge<T>(context, std::move(funcRef)); return FoldMerge<T>(context, std::move(funcRef));
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

flang/test/Evaluate/errors01.f90

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines subroutine warnings
!CHECK: SCALE intrinsic folding overflow !CHECK: SCALE intrinsic folding overflow
real, parameter :: bad1 = scale(1.0, 99999) real, parameter :: bad1 = scale(1.0, 99999)
!CHECK: complex ABS intrinsic folding overflow !CHECK: complex ABS intrinsic folding overflow
real, parameter :: bad2 = abs(cmplx(huge(0.),huge(0.))) real, parameter :: bad2 = abs(cmplx(huge(0.),huge(0.)))
!CHECK: warning: DIM intrinsic folding overflow !CHECK: warning: DIM intrinsic folding overflow
real, parameter :: bad3 = dim(huge(1.),-.5*huge(1.)) real, parameter :: bad3 = dim(huge(1.),-.5*huge(1.))
!CHECK: warning: DIM intrinsic folding overflow !CHECK: warning: DIM intrinsic folding overflow
integer, parameter :: bad4 = dim(huge(1),-1) integer, parameter :: bad4 = dim(huge(1),-1)
!CHECK: warning: HYPOT intrinsic folding overflow
real, parameter :: bad5 = hypot(huge(0.), huge(0.))
!CHECK: warning: overflow on REAL(8) to REAL(4) conversion !CHECK: warning: overflow on REAL(8) to REAL(4) conversion
x = 1.D40 x = 1.D40
end subroutine end subroutine
end module end module