[flang] IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, IEEE_NEXT_UP, NEAREST #100782
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
flang:runtime
flang
|
@llvm/pr-subscribers-flang-runtime @llvm/pr-subscribers-flang-fir-hlfir Author: None (vdonaldson) ChangesIEEE_ARITHMETIC intrinsic module procedures IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, and IEEE_NEXT_UP, and intrinsic NEAREST return larger or smaller values adjacent to their primary REAL argument. The four procedures vary in how the direction is chosen, in how special cases are treated, and in what exceptions are generated. Implement the three IEEE_ARITHMETIC procedures. Update the NEAREST implementation to support all six REAL kinds 2,3,4,8,10,16, and fix several bugs. IEEE_NEXT_AFTER(X,Y) returns a NaN when Y is a NaN as that seems to be the universal choice of other compilers. Change the front end compile time implementation of these procedures to return normal (HUGE) values for infinities when applicable, rather than always returning the input infinity. Patch is 82.01 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/100782.diff 13 Files Affected:
diff --git a/flang/include/flang/Optimizer/Builder/IntrinsicCall.h b/flang/include/flang/Optimizer/Builder/IntrinsicCall.h
index 80f077ad133f3..78bb82b17d405 100644
--- a/flang/include/flang/Optimizer/Builder/IntrinsicCall.h
+++ b/flang/include/flang/Optimizer/Builder/IntrinsicCall.h
@@ -330,6 +330,8 @@ struct IntrinsicLibrary {
mlir::Value genModulo(mlir::Type, llvm::ArrayRef<mlir::Value>);
void genMoveAlloc(llvm::ArrayRef<fir::ExtendedValue>);
void genMvbits(llvm::ArrayRef<fir::ExtendedValue>);
+ enum class NearestProc { Nearest, NextAfter, NextDown, NextUp };
+ template <NearestProc>
mlir::Value genNearest(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genNint(mlir::Type, llvm::ArrayRef<mlir::Value>);
fir::ExtendedValue genNorm2(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
@@ -422,9 +424,12 @@ struct IntrinsicLibrary {
mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args);
- /// Generate code to raise \p except if \p cond is absent,
+ /// Generate code to raise \p excepts if \p cond is absent,
/// or present and true.
- void genRaiseExcept(int except, mlir::Value cond = {});
+ void genRaiseExcept(int excepts, mlir::Value cond = {});
+
+ /// Generate a quiet NaN of a given floating point type.
+ mlir::Value genQNan(mlir::Type resultType);
/// Define the different FIR generators that can be mapped to intrinsic to
/// generate the related code.
diff --git a/flang/include/flang/Optimizer/Builder/Runtime/Exceptions.h b/flang/include/flang/Optimizer/Builder/Runtime/Exceptions.h
index 29745b8c231db..aa6e33c7440ad 100644
--- a/flang/include/flang/Optimizer/Builder/Runtime/Exceptions.h
+++ b/flang/include/flang/Optimizer/Builder/Runtime/Exceptions.h
@@ -21,10 +21,10 @@ class FirOpBuilder;
namespace fir::runtime {
-/// Generate a runtime call to map an ieee_flag_type exception value to a
-/// libm fenv.h value.
-mlir::Value genMapException(fir::FirOpBuilder &builder, mlir::Location loc,
- mlir::Value except);
+/// Generate a runtime call to map a set of ieee_flag_type exceptions to a
+/// libm fenv.h excepts value.
+mlir::Value genMapExcept(fir::FirOpBuilder &builder, mlir::Location loc,
+ mlir::Value excepts);
} // namespace fir::runtime
#endif // FORTRAN_OPTIMIZER_BUILDER_RUNTIME_EXCEPTIONS_H
diff --git a/flang/include/flang/Runtime/exceptions.h b/flang/include/flang/Runtime/exceptions.h
index 8f806ab9ad98a..1ab22da103a50 100644
--- a/flang/include/flang/Runtime/exceptions.h
+++ b/flang/include/flang/Runtime/exceptions.h
@@ -12,7 +12,6 @@
#define FORTRAN_RUNTIME_EXCEPTIONS_H_
#include "flang/Runtime/entry-names.h"
-#include "flang/Runtime/magic-numbers.h"
#include <cinttypes>
namespace Fortran::runtime {
@@ -21,11 +20,9 @@ class Descriptor;
extern "C" {
-// Map a (single) IEEE_FLAG_TYPE exception value to a libm fenv.h value.
-// This could be extended to handle sets of exceptions, but there is no
-// current use case for that. This mapping is done at runtime to support
-// cross compilation.
-std::int32_t RTNAME(MapException)(std::int32_t except);
+// Map a set of IEEE_FLAG_TYPE exception values to a libm fenv.h excepts value.
+// This mapping is done at runtime to support cross compilation.
+std::uint32_t RTNAME(MapException)(std::uint32_t excepts);
} // extern "C"
} // namespace Fortran::runtime
diff --git a/flang/include/flang/Runtime/magic-numbers.h b/flang/include/flang/Runtime/magic-numbers.h
index 1cded1fd63238..bab0e9ae05299 100644
--- a/flang/include/flang/Runtime/magic-numbers.h
+++ b/flang/include/flang/Runtime/magic-numbers.h
@@ -100,6 +100,10 @@ The denorm value is a nonstandard extension.
#define _FORTRAN_RUNTIME_IEEE_OVERFLOW 8
#define _FORTRAN_RUNTIME_IEEE_UNDERFLOW 16
#define _FORTRAN_RUNTIME_IEEE_INEXACT 32
+#define _FORTRAN_RUNTIME_IEEE_ALL \
+ _FORTRAN_RUNTIME_IEEE_INVALID | _FORTRAN_RUNTIME_IEEE_DENORM | \
+ _FORTRAN_RUNTIME_IEEE_DIVIDE_BY_ZERO | _FORTRAN_RUNTIME_IEEE_OVERFLOW | \
+ _FORTRAN_RUNTIME_IEEE_UNDERFLOW | _FORTRAN_RUNTIME_IEEE_INEXACT
#if 0
ieee_round_type values
diff --git a/flang/lib/Evaluate/real.cpp b/flang/lib/Evaluate/real.cpp
index 223f67fee41df..a5f8070c684fe 100644
--- a/flang/lib/Evaluate/real.cpp
+++ b/flang/lib/Evaluate/real.cpp
@@ -330,12 +330,12 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::SQRT(Rounding rounding) const {
template <typename W, int P>
ValueWithRealFlags<Real<W, P>> Real<W, P>::NEAREST(bool upward) const {
ValueWithRealFlags<Real> result;
+ bool isNegative{IsNegative()};
if (IsFinite()) {
Fraction fraction{GetFraction()};
int expo{Exponent()};
Fraction one{1};
Fraction nearest;
- bool isNegative{IsNegative()};
if (upward != isNegative) { // upward in magnitude
auto next{fraction.AddUnsigned(one)};
if (next.carry) {
@@ -359,6 +359,8 @@ ValueWithRealFlags<Real<W, P>> Real<W, P>::NEAREST(bool upward) const {
}
}
result.flags = result.value.Normalize(isNegative, expo, nearest);
+ } else if (IsInfinite() && upward == isNegative) {
+ result.value = isNegative ? HUGE().Negate() : HUGE(); // largest mag finite
} else {
result.flags.set(RealFlag::InvalidArgument);
result.value = *this;
diff --git a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
index 0e5e30a7024d8..22439010e7797 100644
--- a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
+++ b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
@@ -98,9 +98,6 @@ static bool isStaticallyPresent(const fir::ExtendedValue &exv) {
/// IEEE module procedure names not yet implemented for genModuleProcTODO.
static constexpr char ieee_int[] = "ieee_int";
static constexpr char ieee_get_underflow_mode[] = "ieee_get_underflow_mode";
-static constexpr char ieee_next_after[] = "ieee_next_after";
-static constexpr char ieee_next_down[] = "ieee_next_down";
-static constexpr char ieee_next_up[] = "ieee_next_up";
static constexpr char ieee_real[] = "ieee_real";
static constexpr char ieee_rem[] = "ieee_rem";
static constexpr char ieee_rint[] = "ieee_rint";
@@ -355,9 +352,9 @@ static constexpr IntrinsicHandler handlers[]{
&I::genIeeeMaxMin</*isMax=*/false, /*isNum=*/true, /*isMag=*/false>},
{"ieee_min_num_mag",
&I::genIeeeMaxMin</*isMax=*/false, /*isNum=*/true, /*isMag=*/true>},
- {"ieee_next_after", &I::genModuleProcTODO<ieee_next_after>},
- {"ieee_next_down", &I::genModuleProcTODO<ieee_next_down>},
- {"ieee_next_up", &I::genModuleProcTODO<ieee_next_up>},
+ {"ieee_next_after", &I::genNearest<I::NearestProc::NextAfter>},
+ {"ieee_next_down", &I::genNearest<I::NearestProc::NextDown>},
+ {"ieee_next_up", &I::genNearest<I::NearestProc::NextUp>},
{"ieee_quiet_eq", &I::genIeeeQuietCompare<mlir::arith::CmpFPredicate::OEQ>},
{"ieee_quiet_ge", &I::genIeeeQuietCompare<mlir::arith::CmpFPredicate::OGE>},
{"ieee_quiet_gt", &I::genIeeeQuietCompare<mlir::arith::CmpFPredicate::OGT>},
@@ -497,7 +494,7 @@ static constexpr IntrinsicHandler handlers[]{
{"len", asValue},
{"to", asAddr},
{"topos", asValue}}}},
- {"nearest", &I::genNearest},
+ {"nearest", &I::genNearest<I::NearestProc::Nearest>},
{"nint", &I::genNint},
{"norm2",
&I::genNorm2,
@@ -3972,11 +3969,14 @@ IntrinsicLibrary::genIchar(mlir::Type resultType,
// 8 Positive normal
// 9 Positive infinity
static constexpr int finiteTest = 0b0111111000;
+static constexpr int infiniteTest = 0b1000000100;
static constexpr int nanTest = 0b0000000011;
static constexpr int negativeTest = 0b0000111100;
static constexpr int normalTest = 0b0101101000;
static constexpr int positiveTest = 0b1111000000;
static constexpr int snanTest = 0b0000000001;
+static constexpr int subnormalTest = 0b0010010000;
+static constexpr int zeroTest = 0b0001100000;
mlir::Value IntrinsicLibrary::genIsFPClass(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args,
@@ -3988,8 +3988,15 @@ mlir::Value IntrinsicLibrary::genIsFPClass(mlir::Type resultType,
return builder.createConvert(loc, resultType, isfpclass);
}
-/// Generate code to raise \p except if \p cond is absent, or present and true.
-void IntrinsicLibrary::genRaiseExcept(int except, mlir::Value cond) {
+// Generate a quiet NaN of a given floating point type.
+mlir::Value IntrinsicLibrary::genQNan(mlir::Type resultType) {
+ return genIeeeValue(resultType, builder.createIntegerConstant(
+ loc, builder.getIntegerType(8),
+ _FORTRAN_RUNTIME_IEEE_QUIET_NAN));
+}
+
+// Generate code to raise \p excepts if \p cond is absent, or present and true.
+void IntrinsicLibrary::genRaiseExcept(int excepts, mlir::Value cond) {
fir::IfOp ifOp;
if (cond) {
ifOp = builder.create<fir::IfOp>(loc, cond, /*withElseRegion=*/false);
@@ -3998,8 +4005,8 @@ void IntrinsicLibrary::genRaiseExcept(int except, mlir::Value cond) {
mlir::Type i32Ty = builder.getIntegerType(32);
genRuntimeCall(
"feraiseexcept", i32Ty,
- fir::runtime::genMapException(
- builder, loc, builder.createIntegerConstant(loc, i32Ty, except)));
+ fir::runtime::genMapExcept(
+ builder, loc, builder.createIntegerConstant(loc, i32Ty, excepts)));
if (cond)
builder.setInsertionPointAfter(ifOp);
}
@@ -4363,14 +4370,14 @@ void IntrinsicLibrary::genIeeeGetFlag(llvm::ArrayRef<fir::ExtendedValue> args) {
mlir::Value zero = builder.createIntegerConstant(loc, i32Ty, 0);
auto [fieldRef, ignore] = getFieldRef(builder, loc, flag);
mlir::Value field = builder.create<fir::LoadOp>(loc, fieldRef);
- mlir::Value exceptSet = IntrinsicLibrary::genRuntimeCall(
+ mlir::Value excepts = IntrinsicLibrary::genRuntimeCall(
"fetestexcept", i32Ty,
- fir::runtime::genMapException(
+ fir::runtime::genMapExcept(
builder, loc, builder.create<fir::ConvertOp>(loc, i32Ty, field)));
mlir::Value logicalResult = builder.create<fir::ConvertOp>(
loc, resultTy,
builder.create<mlir::arith::CmpIOp>(loc, mlir::arith::CmpIPredicate::ne,
- exceptSet, zero));
+ excepts, zero));
builder.create<fir::StoreOp>(loc, logicalResult, flagValue);
}
@@ -4391,7 +4398,7 @@ void IntrinsicLibrary::genIeeeGetHaltingMode(
IntrinsicLibrary::genRuntimeCall("fegetexcept", i32Ty, {});
mlir::Value intResult = builder.create<mlir::arith::AndIOp>(
loc, haltSet,
- fir::runtime::genMapException(
+ fir::runtime::genMapExcept(
builder, loc, builder.create<fir::ConvertOp>(loc, i32Ty, field)));
mlir::Value logicalResult = builder.create<fir::ConvertOp>(
loc, resultTy,
@@ -4657,7 +4664,6 @@ mlir::Value IntrinsicLibrary::genIeeeMaxMin(mlir::Type resultType,
y1 = y;
}
mlir::Type i1Ty = builder.getI1Type();
- mlir::Type i8Ty = builder.getIntegerType(8);
mlir::arith::CmpFPredicate pred;
mlir::Value cmp, result, resultIsX, resultIsY;
@@ -4698,12 +4704,10 @@ mlir::Value IntrinsicLibrary::genIeeeMaxMin(mlir::Type resultType,
} else {
resultIsX = resultIsY = builder.createBool(loc, false);
}
- mlir::Value qNaN =
- genIeeeValue(resultType, builder.createIntegerConstant(
- loc, i8Ty, _FORTRAN_RUNTIME_IEEE_QUIET_NAN));
result = builder.create<mlir::arith::SelectOp>(
loc, resultIsX, x,
- builder.create<mlir::arith::SelectOp>(loc, resultIsY, y, qNaN));
+ builder.create<mlir::arith::SelectOp>(loc, resultIsY, y,
+ genQNan(resultType)));
mlir::Value hasSNaNOp = builder.create<mlir::arith::OrIOp>(
loc, genIsFPClass(builder.getI1Type(), args[0], snanTest),
genIsFPClass(builder.getI1Type(), args[1], snanTest));
@@ -4747,7 +4751,7 @@ void IntrinsicLibrary::genIeeeSetFlagOrHaltingMode(
mlir::Type i32Ty = builder.getIntegerType(32);
auto [fieldRef, ignore] = getFieldRef(builder, loc, getBase(args[0]));
mlir::Value field = builder.create<fir::LoadOp>(loc, fieldRef);
- mlir::Value except = fir::runtime::genMapException(
+ mlir::Value except = fir::runtime::genMapExcept(
builder, loc, builder.create<fir::ConvertOp>(loc, i32Ty, field));
auto ifOp = builder.create<fir::IfOp>(
loc, builder.create<fir::ConvertOp>(loc, i1Ty, getBase(args[1])),
@@ -5610,16 +5614,186 @@ void IntrinsicLibrary::genMvbits(llvm::ArrayRef<fir::ExtendedValue> args) {
builder.create<fir::StoreOp>(loc, res, toAddr);
}
-// NEAREST
+// NEAREST, IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, IEEE_NEXT_UP
+template <I::NearestProc proc>
mlir::Value IntrinsicLibrary::genNearest(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
- assert(args.size() == 2);
+ // NEAREST
+ // Return the number adjacent to arg X in the direction of the infinity
+ // with the sign of arg S. Terminate with an error if arg S is zero.
+ // Generate exceptions as for IEEE_NEXT_AFTER.
+ // IEEE_NEXT_AFTER
+ // Return isNan(Y) ? NaN : X==Y ? X : num adjacent to X in the dir of Y.
+ // Signal IEEE_OVERFLOW, IEEE_INEXACT for finite X and infinite result.
+ // Signal IEEE_UNDERFLOW, IEEE_INEXACT for subnormal result.
+ // IEEE_NEXT_DOWN
+ // Return the number adjacent to X and less than X.
+ // Signal IEEE_INVALID when X is a signaling NaN.
+ // IEEE_NEXT_UP
+ // Return the number adjacent to X and greater than X.
+ // Signal IEEE_INVALID when X is a signaling NaN.
+ //
+ // valueUp -- true if a finite result must be larger than X.
+ // magnitudeUp -- true if a finite abs(result) must be larger than abs(X).
+ //
+ // if (isNextAfter && isNan(Y)) X = NaN // result = NaN
+ // if (isNan(X) || (isNextAfter && X == Y) || (isInfinite(X) && magnitudeUp))
+ // result = X
+ // else if (isZero(X))
+ // result = valueUp ? minPositiveSubnormal : minNegativeSubnormal
+ // else
+ // result = magUp ? (X + minPositiveSubnormal) : (X - minPositiveSubnormal)
- mlir::Value realX = fir::getBase(args[0]);
- mlir::Value realS = fir::getBase(args[1]);
+ assert(args.size() == 1 || args.size() == 2);
+ mlir::Value x = args[0];
+ mlir::FloatType xType = mlir::dyn_cast<mlir::FloatType>(x.getType());
+ const unsigned xBitWidth = xType.getWidth();
+ mlir::Type i1Ty = builder.getI1Type();
+ if constexpr (proc == NearestProc::NextAfter)
+ // If isNan(Y), set X to a qNaN that will propagate to the resultIsX result.
+ x = builder.create<mlir::arith::SelectOp>(
+ loc, genIsFPClass(i1Ty, args[1], nanTest), genQNan(xType), x);
+ mlir::Value resultIsX = genIsFPClass(i1Ty, x, nanTest);
+ mlir::Type intType = builder.getIntegerType(xBitWidth);
+ mlir::Value one = builder.createIntegerConstant(loc, intType, 1);
- return builder.createConvert(
- loc, resultType, fir::runtime::genNearest(builder, loc, realX, realS));
+ // Set valueUp to true if a finite result must be larger than arg X.
+ mlir::Value valueUp;
+ if constexpr (proc == NearestProc::Nearest) {
+ // Arg S must not be zero.
+ fir::IfOp ifOp =
+ builder.create<fir::IfOp>(loc, genIsFPClass(i1Ty, args[1], zeroTest),
+ /*withElseRegion=*/false);
+ builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
+ fir::runtime::genReportFatalUserError(
+ builder, loc, "intrinsic nearest S argument is zero");
+ builder.setInsertionPointAfter(ifOp);
+ mlir::Value sSign = IntrinsicLibrary::genIeeeSignbit(intType, {args[1]});
+ valueUp = builder.create<mlir::arith::CmpIOp>(
+ loc, mlir::arith::CmpIPredicate::ne, sSign, one);
+ } else if constexpr (proc == NearestProc::NextAfter) {
+ // Convert X and Y to a common type to allow comparison. Direct conversions
+ // between kinds 2, 3, 10, and 16 are not all supported. These conversions
+ // are implemented by converting kind=2,3 values to kind=4, possibly
+ // followed with a conversion of that value to a larger type.
+ mlir::Value x1 = x;
+ mlir::Value y = args[1];
+ mlir::FloatType yType = mlir::dyn_cast<mlir::FloatType>(args[1].getType());
+ const unsigned yBitWidth = yType.getWidth();
+ if (xType != yType) {
+ mlir::Type f32Ty = mlir::FloatType::getF32(builder.getContext());
+ if (xBitWidth < 32)
+ x1 = builder.createConvert(loc, f32Ty, x1);
+ if (yBitWidth > 32 && yBitWidth > xBitWidth)
+ x1 = builder.createConvert(loc, yType, x1);
+ if (yBitWidth < 32)
+ y = builder.createConvert(loc, f32Ty, y);
+ if (xBitWidth > 32 && xBitWidth > yBitWidth)
+ y = builder.createConvert(loc, xType, y);
+ }
+ resultIsX = builder.create<mlir::arith::OrIOp>(
+ loc, resultIsX,
+ builder.create<mlir::arith::CmpFOp>(
+ loc, mlir::arith::CmpFPredicate::OEQ, x1, y));
+ valueUp = builder.create<mlir::arith::CmpFOp>(
+ loc, mlir::arith::CmpFPredicate::OLT, x1, y);
+ } else if constexpr (proc == NearestProc::NextDown) {
+ valueUp = builder.createBool(loc, false);
+ } else if constexpr (proc == NearestProc::NextUp) {
+ valueUp = builder.createBool(loc, true);
+ }
+ mlir::Value magnitudeUp = builder.create<mlir::arith::CmpIOp>(
+ loc, mlir::arith::CmpIPredicate::ne, valueUp,
+ IntrinsicLibrary::genIeeeSignbit(i1Ty, {args[0]}));
+ resultIsX = builder.create<mlir::arith::OrIOp>(
+ loc, resultIsX,
+ builder.create<mlir::arith::AndIOp>(
+ loc, genIsFPClass(i1Ty, x, infiniteTest), magnitudeUp));
+
+ // Result is X. (For ieee_next_after with isNan(Y), X has been set to a NaN.)
+ fir::IfOp outerIfOp = builder.create<fir::IfOp>(loc, resultType, resultIsX,
+ /*withElseRegion=*/true);
+ builder.setInsertionPointToStart(&outerIfOp.getThenRegion().front());
+ if constexpr (proc == NearestProc::NextDown || proc == NearestProc::NextUp)
+ genRaiseExcept(_FORTRAN_RUNTIME_IEEE_INVALID,
+ genIsFPClass(i1Ty, x, snanTest));
+ builder.create<fir::ResultOp>(loc, x);
+
+ // Result is minPositiveSubnormal or minNegativeSubnormal. (X is zero.)
+ builder.setInsertionPointToStart(&outerIfOp.getElseRegion().front());
+ mlir::Value resultIsMinSubnormal = builder.create<mlir::arith::CmpFOp>(
+ loc, mlir::arith::CmpFPredicate::OEQ, x,
+ builder.createRealZeroConstant(loc, xType));
+ fir::IfOp innerIfOp =
+ builder.create<fir::IfOp>(loc, resultType, resultIsMinSubnormal,
+ /*withElseRegion=*/true);
+ builder.setInsertionPointToStart(&innerIfOp.getThenRegion().front());
+ mlir::Value minPositiveSubnormal =
+ builder.create<mlir::arith::BitcastOp>(loc, resultType, one);
+ mlir::Value minNegativeSubnormal = builder.create<mlir::arith::BitcastOp>(
+ loc, resultType,
+ builder.create<mlir::arith::ConstantOp>(
+ loc, intType,
+ builder.getIntegerAttr(
+ intType, llvm::APInt::getBitsSetWithWrap(
+ xBitWidth, /*lo=*/xBitWidth - 1, /*hi=*/1))));
+ mlir::Value result = builder.create<mlir::arith::SelectOp>(
+ loc, valueUp, minPositiveSubnormal, minNegativeSubnormal);
+ if constexpr (proc == NearestProc::Nearest || proc == NearestProc::NextAfter)
+ genRaiseExcept(_FORTRAN_RUNTIME_IEEE_UNDERFLOW |
+ _FORTRAN_RUNTIME_IEEE_INEXACT);
+ builder.create<fir::ResultOp>(loc, result);
+
+ // Result is (X + minPositiveSubnormal) or (X - minPositiveSubnormal).
+ builder.setInsertionPointToStart(&innerIfOp.getElseRegion().front());
+ if (xBitWidth == 80) {
+ // Kind 10. Call std::nextafter, which generates exceptions as required
+ // for ieee_next_after and nearest. Override this exception processing
+ // for ieee_next_down and ieee_next_up.
+ constexpr bool overrideExceptionGeneration =
+ proc == NearestProc::NextDown || proc == NearestProc::NextUp;
+ [[maybe_unused]] mlir::Type i32Ty;
+ [[maybe_unused]] mlir::Value allExcepts, excepts, mask;
+ if constexpr (overrideExceptionGeneration) {
+ i32Ty = builder.getIntegerType(32);
+ allExcepts = fir::runtime::genMapExcept(
+ builder, loc,
+ builder.createIntegerConstant(loc, i32Ty, _FORTRAN_RUNTIME_IEE...
[truncated]
|
klausler
changed the title
klausler
approved these changes
Jul 26, 2024
psteinfeld
approved these changes
Jul 26, 2024
IEEE_ARITHMETIC intrinsic module procedures IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, and IEEE_NEXT_UP, and intrinsic NEAREST return larger or smaller values adjacent to their primary REAL argument. The four procedures vary in how the direction is chosen, in how special cases are treated, and in what exceptions are generated. Implement the three IEEE_ARITHMETIC procedures. Update the NEAREST implementation to support all six REAL kinds 2,3,4,8,10,16, and fix several bugs. IEEE_NEXT_AFTER(X,Y) returns a NaN when Y is a NaN as that seems to be the universal choice of other compilers. Change the front end compile time implementation of these procedures to return normal (HUGE) values for infinities when applicable, rather than always returning the input infinity.
|
Several lit test failures are due to instruction order variations. I've changed some CHECK sequences to CHECK-DAG sequences to accommodate multiple orders. |
h-vetinari
pushed a commit
to h-vetinari/llvm-project
that referenced
this pull request
Aug 10, 2024
…100782) IEEE_ARITHMETIC intrinsic module procedures IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, and IEEE_NEXT_UP, and intrinsic NEAREST return larger or smaller values adjacent to their primary REAL argument. The four procedures vary in how the direction is chosen, in how special cases are treated, and in what exceptions are generated. Implement the three IEEE_ARITHMETIC procedures. Update the NEAREST implementation to support all six REAL kinds 2,3,4,8,10,16, and fix several bugs. IEEE_NEXT_AFTER(X,Y) returns a NaN when Y is a NaN as that seems to be the universal choice of other compilers. Change the front end compile time implementation of these procedures to return normal (HUGE) values for infinities when applicable, rather than always returning the input infinity.
5 tasks
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
IEEE_ARITHMETIC intrinsic module procedures IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, and IEEE_NEXT_UP, and intrinsic NEAREST return larger or smaller values adjacent to their primary REAL argument. The four procedures vary in how the direction is chosen, in how special cases are treated, and in what exceptions are generated. Implement the three IEEE_ARITHMETIC procedures. Update the NEAREST implementation to support all six REAL kinds 2,3,4,8,10,16, and fix several bugs.
IEEE_NEXT_AFTER(X,Y) returns a NaN when Y is a NaN as that seems to be the universal choice of other compilers.
Change the front end compile time implementation of these procedures to return normal (HUGE) values for infinities when applicable, rather than always returning the input infinity.