[flang] Implement isnan and ieee_is_nan intrinsics

[DavidTruby]

Summary

To implement these we call the LLVM intrinsic is.fpclass indicating that
we are checking for either a quiet or signalling NaN.

[DavidTruby]

Clarify in unit test that in the f64 case we convert to f32 first

[vzakhari]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

3708

Could you please use mlir::LLVM::IsFPClass operation when mathRuntimeVersion != preciseVersion?

flang/test/Lower/Intrinsics/isnan.f90

39

Where is this conversion coming from? Can we get rid of it?

[kiranchandramohan]

In D144649#4147707, @DavidTruby wrote:

Clarify in unit test that in the f64 case we convert to f32 first

Is converting to f32 correct? I see that the f64 case is supported (https://github.com/llvm/llvm-project/blob/bb588519c5b5a6555e418259bb5d4a37d35f5837/llvm/test/CodeGen/X86/is_fpclass.ll#L649).

Can you add the following to the summary?
-> The isnan extension is already captured in the Extensions documentation (https://github.com/llvm/llvm-project/blob/main/flang/docs/Extensions.md).
-> Add Fixes #6082 ( https://github.com/llvm/llvm-project/issues/60882).

Could you add tests for kind=10 and 16 as well?

[tschuett]

According to the tests in https://reviews.llvm.org/D112025 it also supports f64.

[DavidTruby]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

3708

I think we can just use mlir::LLVM::IsFPClass unconditionally? It will always lower directly to this function call but is cleaner code anyway.

flang/test/Lower/Intrinsics/isnan.f90

39

I didn't add this conversion here, it appears to be happening before the IntrinsicCall class gets hold of it, so I guess somewhere prior we're defining isnan to have that conversion. I didn't really consider it as this will be correct (converting a f64 to f32 will preserve the isnan) but on second thought we should try and avoid the conversion to remove the extra instruction. I'll see if I can find out where it is coming from.

[tschuett]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

3697

Can you check whether args are f32 or f64?

[jeanPerier]

flang/test/Lower/Intrinsics/isnan.f90

39

It is indeed inserted before lowering, probably when resolving the intrinsic call (it appears in the -fdebug-unparse).
The convert is being inserted here to simplify its processing: https://github.com/llvm/llvm-project/blob/e4c4841e5bbaf6d09aff65387102ed22a9eac60b/flang/lib/Evaluate/fold-logical.cpp#L162 (It is implicitly added because of the "DefaultReal" on FoldElementalIntrinsic that inserts conversions from the actual arguments to the requested template argument types if needed).

[DavidTruby]

Remove unnecessary casts to f32 for other real types

[DavidTruby]

flang/lib/Evaluate/fold-logical.cpp

163 ↗

(On Diff #500190)

I've tried to add a check that we only replace the type of the function when we are actually able to fold, i.e. when the argument can be treated as a constant real of kind 4. This seems to pass both my own tests and the existing fold tests for isnan, but I'm not 100% confident it's correct so wanted to highlight this to get a review from someone more familiar with the folding code.

[DavidTruby]

flang/test/Lower/Intrinsics/isnan.f90

39

This is now slightly confusingly pointing at a different conversion (the one to fir.logical<4>), which I don't think can be removed. Just for reference to anyone coming along to review in future.

[jeanPerier]

flang/lib/Evaluate/fold-logical.cpp

163 ↗

(On Diff #500190)

I think this will prevent folding of isnan with constant arguments that are not of default real type.

It is probably best to only use args[0] && args[0]->UnwrapExpr() && IsActuallyConstant(*args[0]->UnwrapExpr()) that will let let isnan be folded for any real type constant argument.

Otherwise, bypassing the folding that cannot succeed seems OK to me.

[DavidTruby]

Use suggested check for constant argument instead

[vzakhari]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

3708

I think we can just use mlir::LLVM::IsFPClass unconditionally? It will always lower directly to this function call but is cleaner code anyway.

I think it may be okay to always generate the intrinsic operation. Thanks!

[clementval]

FYI I see couple of gfortran tests related to isnan are failing

maxlocval_2
maxlocval_4
minlocval_1
minlocval_4
namelist_42
namelist_43
nan_6
nearest_3

[kiranchandramohan]

In D144649#4178100, @clementval wrote:

FYI I see couple of gfortran tests related to isnan are failing

maxlocval_2
maxlocval_4
minlocval_1
minlocval_4
namelist_42
namelist_43
nan_6
nearest_3

An initial investigation by @SBallantyne revealed that these failures are not related to the implementation of the isnan intrinsic. See details in https://github.com/llvm/llvm-project/issues/61286#issuecomment-1462224026. Will need input before we can make progress.

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

struct IntrinsicLibrary {
   fir::ExtendedValue genIeeeTypeCompare(mlir::Type,
                                         llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genIeor(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genIndex(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genIor(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genIparity(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genIsContiguous(mlir::Type,
                                      llvm::ArrayRef<fir::ExtendedValue>);
+  mlir::Value genIsNan(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genIshft(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genIshftc(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genLbound(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genLeadz(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genLen(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genLenTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genLoc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   template <typename Shift>
static constexpr IntrinsicHandler handlers[]{
      /*isElemental=*/false},
     {"ibclr", &I::genIbclr},
     {"ibits", &I::genIbits},
     {"ibset", &I::genIbset},
     {"ichar", &I::genIchar},
     {"ieee_class_eq", &I::genIeeeTypeCompare<mlir::arith::CmpIPredicate::eq>},
     {"ieee_class_ne", &I::genIeeeTypeCompare<mlir::arith::CmpIPredicate::ne>},
     {"ieee_is_finite", &I::genIeeeIsFinite},
+    {"ieee_is_nan", &I::genIsNan},
     {"ieee_round_eq", &I::genIeeeTypeCompare<mlir::arith::CmpIPredicate::eq>},
     {"ieee_round_ne", &I::genIeeeTypeCompare<mlir::arith::CmpIPredicate::ne>},
     {"ieor", &I::genIeor},
     {"index",
      &I::genIndex,
      {{{"string", asAddr},
        {"substring", asAddr},
        {"back", asValue, handleDynamicOptional},
        {"kind", asValue}}}},
     {"ior", &I::genIor},
     {"iparity",
      &I::genIparity,
      {{{"array", asBox},
        {"dim", asValue},
        {"mask", asBox, handleDynamicOptional}}},
      /*isElemental=*/false},
     {"is_contiguous",
      &I::genIsContiguous,
      {{{"array", asBox}}},
      /*isElemental=*/false},
     {"ishft", &I::genIshft},
     {"ishftc", &I::genIshftc},
+    {"isnan", &I::genIsNan},
     {"lbound",
      &I::genLbound,
      {{{"array", asInquired}, {"dim", asValue}, {"kind", asValue}}},
      /*isElemental=*/false},
     {"leadz", &I::genLeadz},
     {"len",
      &I::genLen,
      {{{"string", asInquired}, {"kind", asValue}}},
if (const auto *boxValue = args[0].getBoxOf<fir::BoxValue>())
     if (boxValue->hasAssumedRank())
       TODO(loc, "intrinsic: is_contiguous with assumed rank argument");
 
   return builder.createConvert(
       loc, resultType,
       fir::runtime::genIsContiguous(builder, loc, fir::getBase(args[0])));
 }
 
+mlir::Value IntrinsicLibrary::genIsNan(mlir::Type resultType,
+                                       llvm::ArrayRef<mlir::Value> args) {
+  assert(args.size() == 1);
+  mlir::MLIRContext *context = builder.getContext();
+  mlir::IntegerType i1ty = mlir::IntegerType::get(context, 1);
+  mlir::IntegerType i32ty = mlir::IntegerType::get(context, 32);
+  mlir::FunctionType funtype =
+      mlir::FunctionType::get(context, {args[0].getType(), i32ty}, {i1ty});
+  // The last two bits indicate we are checking for signalling or quiet nan.
+  mlir::Value nan = builder.createIntegerConstant(loc, i32ty, 0b11);
+
+  mlir::Value call =
+      genLibCall(builder, loc, "llvm.is.fpclass.f32", funtype, {args[0], nan});
+  return builder.createConvert(loc, resultType, call);
+}
+
 // ISHFT
 mlir::Value IntrinsicLibrary::genIshft(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
   // A conformant ISHFT(I,SHIFT) call satisfies:
   //     abs(SHIFT) <= BIT_SIZE(I)
   // Return:  abs(SHIFT) >= BIT_SIZE(I)
   //              ? 0
   //              : SHIFT < 0

flang/test/Lower/Intrinsics/isnan.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: flang-new -fc1 -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: isnan_f32
+subroutine isnan_f32(r)
+  real :: r
+  i = isnan(r)
+  ! CHECK: %[[test:.*]] = arith.constant 3 : i32
+  ! CHECK: %[[l:.*]] = fir.call @llvm.is.fpclass.f32(%{{.*}}, %[[test]]) {{.*}} (f32, i32) -> i1
+  ! CHECK: fir.convert %[[l]] : (i1) -> !fir.logical<4>
+end subroutine isnan_f32
+
+! CHECK-LABEL: ieee_is_nan_f32
+subroutine ieee_is_nan_f32(r)
+  use ieee_arithmetic
+  real :: r
+  i = ieee_is_nan(r)
+  ! CHECK: %[[test:.*]] = arith.constant 3 : i32
+  ! CHECK: %[[l:.*]] = fir.call @llvm.is.fpclass.f32(%{{.*}}, %[[test]]) {{.*}} (f32, i32) -> i1
+  ! CHECK: fir.convert %[[l]] : (i1) -> !fir.logical<4>
+end subroutine ieee_is_nan_f32
+
+! CHECK-LABEL: isnan_f64
+subroutine isnan_f64(r)
+  real(KIND=8) :: r
+  i = isnan(r)
+  ! CHECK: %[[test:.*]] = arith.constant 3 : i32
+  ! CHECK: %[[l:.*]] = fir.call @llvm.is.fpclass.f32(%{{.*}}, %[[test]]) {{.*}} (f32, i32) -> i1
+  ! CHECK: fir.convert %[[l]] : (i1) -> !fir.logical<4>
+end subroutine isnan_f64
+
+! CHECK-LABEL: ieee_is_nan_f64
+subroutine ieee_is_nan_f64(r)
+  use ieee_arithmetic
+  real(KIND=8) :: r
+  i = ieee_is_nan(r)
+  ! CHECK: %[[test:.*]] = arith.constant 3 : i32
+  ! CHECK: %[[l:.*]] = fir.call @llvm.is.fpclass.f32(%{{.*}}, %[[test]]) {{.*}} (f32, i32) -> i1
+  ! CHECK: fir.convert %[[l]] : (i1) -> !fir.logical<4>
+end subroutine ieee_is_nan_f64