[flang] Add ieee_is_normal/ieee_is_negative to ieee_arithmetic module.

[klausler]

Looks great to me! Please resolve the failed Windows build before merging.

[ygribov]

In D117882#3261754, @klausler wrote:

Looks great to me! Please resolve the failed Windows build before merging.

Actually both crashes have happened due to a recent refactor and have already been fixed (in 2a9e33db4f0 and 5597ec2dc4).

Unfortunately I haven't yet been able to find my commit credentials (I haven't contributed for a few years) :/ Could someone merge?

[klausler]

Please find or renew your GitHub account credentials. Merging a change is easy, but watching the buildbots afterwards and fixing breakage would take time that I don't have much of at the moment.

[kiranchandramohan]

@ygribov Thanks for this patch. Could you rebase the patch to ensure that the precommit CI is passing?

As mentioned by Peter, we have to monitor the builds after a patch is submitted. And the notification typically goes to the person who submitted it. So it is always good to have commit access to submit patches so that you may take the appropriate action on a failure. It is also recommended if you plan to contribute on a regular basis.
You can find the details for obtaining commit access from the following link.
https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

I can submit this patch for you if you share the email id that you want to use. Our buildbots are in the following location.
https://lab.llvm.org/buildbot/#/console

[ygribov]

In D117882#3268615, @kiranchandramohan wrote:

As mentioned by Peter, we have to monitor the builds after a patch is submitted.

No worries, I realize that this is indeed too inconvenient for maintainers. I'll re-request push access for myself and proceed with rebase, etc., just haven't got it it yet.

[ygribov]

Rebased on ToT

[ygribov]

Closed with

commit d3f5ef241ae3841b6f9b70bd138a9252ed3a002e
Author: Yury Gribov <[e-mail]>
Date:   Fri Jan 21 17:24:32 2022 +0900

    Add ieee_is_normal/ieee_is_negative to ieee_arithmetic module.

flang/include/flang/Evaluate/real.h

public:
   }
   constexpr bool IsFinite() const { return Exponent() != maxExponent; }
   constexpr bool IsZero() const {
     return Exponent() == 0 && GetSignificand().IsZero();
   }
   constexpr bool IsSubnormal() const {
     return Exponent() == 0 && !GetSignificand().IsZero();
   }
+  constexpr bool IsNormal() const {
+    return !(IsInfinite() || IsNotANumber() || IsSubnormal());
+  }
 
   constexpr Real ABS() const { // non-arithmetic, no flags returned
     return {word_.IBCLR(bits - 1)};
   }
   constexpr Real SetSign(bool toNegative) const { // non-arithmetic
     if (toNegative) {
       return {word_.IBSET(bits - 1)};
     } else {

flang/lib/Evaluate/fold-logical.cpp

if (name == "all") {
     // A warning about an invalid argument is discarded from converting
     // the argument of isnan() / IEEE_IS_NAN().
     auto restorer{context.messages().DiscardMessages()};
     using DefaultReal = Type<TypeCategory::Real, 4>;
     return FoldElementalIntrinsic<T, DefaultReal>(context, std::move(funcRef),
         ScalarFunc<T, DefaultReal>([](const Scalar<DefaultReal> &x) {
           return Scalar<T>{x.IsNotANumber()};
         }));
+  } else if (name == "__builtin_ieee_is_negative") {
+    auto restorer{context.messages().DiscardMessages()};
+    using DefaultReal = Type<TypeCategory::Real, 4>;
+    return FoldElementalIntrinsic<T, DefaultReal>(context, std::move(funcRef),
+        ScalarFunc<T, DefaultReal>([](const Scalar<DefaultReal> &x) {
+          return Scalar<T>{x.IsNegative()};
+        }));
+  } else if (name == "__builtin_ieee_is_normal") {
+    auto restorer{context.messages().DiscardMessages()};
+    using DefaultReal = Type<TypeCategory::Real, 4>;
+    return FoldElementalIntrinsic<T, DefaultReal>(context, std::move(funcRef),
+        ScalarFunc<T, DefaultReal>([](const Scalar<DefaultReal> &x) {
+          return Scalar<T>{x.IsNormal()};
+        }));
   } else if (name == "is_contiguous") {
     if (args.at(0)) {
       if (auto *expr{args[0]->UnwrapExpr()}) {
         if (IsSimplyContiguous(*expr, context)) {
           return Expr<T>{true};
         }
       }
     }

flang/lib/Evaluate/intrinsics.cpp

// NULL() is a special case handled in Probe() below
             {"field", SameType, Rank::conformable}},
         SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
     {"verify",
         {{"string", SameChar}, {"set", SameChar},
             {"back", AnyLogical, Rank::elemental, Optionality::optional},
             DefaultingKIND},
         KINDInt},
     {"__builtin_ieee_is_nan", {{"a", AnyFloating}}, DefaultLogical},
+    {"__builtin_ieee_is_normal", {{"a", AnyFloating}}, DefaultLogical},
+    {"__builtin_ieee_is_negative", {{"a", AnyFloating}}, DefaultLogical},
     {"__builtin_ieee_next_after", {{"x", SameReal}, {"y", AnyReal}}, SameReal},
     {"__builtin_ieee_next_down", {{"x", SameReal}}, SameReal},
     {"__builtin_ieee_next_up", {{"x", SameReal}}, SameReal},
     {"__builtin_ieee_selected_real_kind", // alias for selected_real_kind
         {{"p", AnyInt, Rank::scalar},
             {"r", AnyInt, Rank::scalar, Optionality::optional},
             {"radix", AnyInt, Rank::scalar, Optionality::optional}},
         DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},

flang/module/__fortran_builtins.f90

module __Fortran_builtins
   end type
 
   type :: __builtin_team_type
     integer(kind=int64) :: __id
   end type
 
   procedure(type(__builtin_c_ptr)) :: __builtin_c_loc
 
-  intrinsic :: __builtin_ieee_is_nan
+  intrinsic :: __builtin_ieee_is_nan, __builtin_ieee_is_normal, &
+    __builtin_ieee_is_negative
   intrinsic :: __builtin_ieee_next_after, __builtin_ieee_next_down, &
     __builtin_ieee_next_up
   intrinsic :: scale ! for ieee_scalb
   intrinsic :: __builtin_ieee_selected_real_kind
   intrinsic :: __builtin_ieee_support_datatype, &
     __builtin_ieee_support_denormal, __builtin_ieee_support_divide, &
     __builtin_ieee_support_inf, __builtin_ieee_support_io, &
     __builtin_ieee_support_nan, __builtin_ieee_support_sqrt, &

flang/module/ieee_arithmetic.f90

 !===-- module/ieee_arithmetic.f90 ------------------------------------------===!
 !
 ! Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 ! See https://llvm.org/LICENSE.txt for license information.
 ! SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 !
 !===------------------------------------------------------------------------===!
 
 ! See Fortran 2018, clause 17.2
 module ieee_arithmetic
 
   use __Fortran_builtins, only: &
     ieee_is_nan => __builtin_ieee_is_nan, &
+    ieee_is_normal => __builtin_ieee_is_normal, &
+    ieee_is_negative => __builtin_ieee_is_negative, &
     ieee_next_after => __builtin_ieee_next_after, &
     ieee_next_down => __builtin_ieee_next_down, &
     ieee_next_up => __builtin_ieee_next_up, &
     ieee_scalb => scale, &
     ieee_selected_real_kind => __builtin_ieee_selected_real_kind, &
     ieee_support_datatype => __builtin_ieee_support_datatype, &
     ieee_support_denormal => __builtin_ieee_support_denormal, &
     ieee_support_divide => __builtin_ieee_support_divide, &
#define _IS_FINITE(KIND) \
   _IS_FINITE(2)
   _IS_FINITE(3)
   _IS_FINITE(4)
   _IS_FINITE(8)
   _IS_FINITE(10)
   _IS_FINITE(16)
 #undef _IS_FINITE
 
+#define _IS_NEGATIVE(KIND) \
+  elemental function ieee_is_negative_a##KIND(x) result(res); \
+    real(kind=KIND), intent(in) :: x; \
+    logical :: res; \
+    type(ieee_class_type) :: classification; \
+    classification = ieee_class(x); \
+    res = classification == ieee_negative_zero .or. classification == ieee_negative_denormal \
+     .or. classification == ieee_negative_normal .or. classification == ieee_negative_inf; \
+  end function
+  _IS_NEGATIVE(2)
+  _IS_NEGATIVE(3)
+  _IS_NEGATIVE(4)
+  _IS_NEGATIVE(8)
+  _IS_NEGATIVE(10)
+  _IS_NEGATIVE(16)
+#undef _IS_NEGATIVE
+
+#define _IS_NORMAL(KIND) \
+  elemental function ieee_is_normal_a##KIND(x) result(res); \
+    real(kind=KIND), intent(in) :: x; \
+    logical :: res; \
+    type(ieee_class_type) :: classification; \
+    classification = ieee_class(x); \
+    res = classification == ieee_negative_normal .or. classification == ieee_positive_normal \
+      .or. classification == ieee_negative_zero .or. classification == ieee_positive_zero; \
+  end function
+  _IS_NORMAL(2)
+  _IS_NORMAL(3)
+  _IS_NORMAL(4)
+  _IS_NORMAL(8)
+  _IS_NORMAL(10)
+  _IS_NORMAL(16)
+#undef _IS_NORMAL
+
 ! TODO: handle edge cases from 17.11.31
 #define _REM(XKIND,YKIND) \
   elemental function ieee_rem_a##XKIND##_a##YKIND(x, y) result(res); \
     real(kind=XKIND), intent(in) :: x; \
     real(kind=YKIND), intent(in) :: y; \
     integer, parameter :: rkind = max(XKIND, YKIND); \
     real(kind=rkind) :: res, tmp; \
     tmp = anint(real(x, kind=rkind) / y); \