More folding, more testing

Author: klausler

flang/include/flang/Evaluate/complex.h

@@ -61,10 +61,11 @@ template <typename REAL_TYPE> class Complex {
 
   template <typename INT>
   static ValueWithRealFlags<Complex> FromInteger(const INT &n,
+      bool isUnsigned = false,
       Rounding rounding = TargetCharacteristics::defaultRounding) {
     ValueWithRealFlags<Complex> result;
-    result.value.re_ =
-        Part::FromInteger(n, rounding).AccumulateFlags(result.flags);
+    result.value.re_ = Part::FromInteger(n, isUnsigned, rounding)
+                           .AccumulateFlags(result.flags);
     return result;
   }
 

flang/include/flang/Evaluate/real.h

@@ -288,8 +288,9 @@ template <typename WORD, int PREC> class Real {
 
   template <typename INT>
   static ValueWithRealFlags<Real> FromInteger(const INT &n,
+      bool isUnsigned = false,
       Rounding rounding = TargetCharacteristics::defaultRounding) {
-    bool isNegative{n.IsNegative()};
+    bool isNegative{!isUnsigned && n.IsNegative()};
     INT absN{n};
     if (isNegative) {
       absN = n.Negate().value; // overflow is safe to ignore

flang/lib/Evaluate/fold-implementation.h

@@ -1735,7 +1735,8 @@ Expr<TO> FoldOperation(
         if (auto value{GetScalarConstantValue<Operand>(kindExpr)}) {
           FoldingContext &ctx{msvcWorkaround.context};
           if constexpr (TO::category == TypeCategory::Integer) {
-            if constexpr (FromCat == TypeCategory::Integer) {
+            if constexpr (FromCat == TypeCategory::Integer ||
+                FromCat == TypeCategory::Unsigned) {
               auto converted{Scalar<TO>::ConvertSigned(*value)};
               if (converted.overflow &&
                   msvcWorkaround.context.languageFeatures().ShouldWarn(
@@ -1762,9 +1763,20 @@ Expr<TO> FoldOperation(
               }
               return ScalarConstantToExpr(std::move(converted.value));
             }
+          } else if constexpr (TO::category == TypeCategory::Unsigned) {
+            if constexpr (FromCat == TypeCategory::Integer ||
+                FromCat == TypeCategory::Unsigned) {
+              return Expr<TO>{
+                  Constant<TO>{Scalar<TO>::ConvertUnsigned(*value).value}};
+            } else if constexpr (FromCat == TypeCategory::Real) {
+              return Expr<TO>{
+                  Constant<TO>{value->template ToInteger<Scalar<TO>>().value}};
+            }
           } else if constexpr (TO::category == TypeCategory::Real) {
-            if constexpr (FromCat == TypeCategory::Integer) {
-              auto converted{Scalar<TO>::FromInteger(*value)};
+            if constexpr (FromCat == TypeCategory::Integer ||
+                FromCat == TypeCategory::Unsigned) {
+              auto converted{Scalar<TO>::FromInteger(
+                  *value, FromCat == TypeCategory::Unsigned)};
               if (!converted.flags.empty()) {
                 char buffer[64];
                 std::snprintf(buffer, sizeof buffer,

flang/lib/Evaluate/tools.cpp

@@ -643,6 +643,10 @@ std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
               Expr<SomeInteger> &&iy) -> std::optional<Expr<LogicalResult>> {
             return PromoteAndRelate(opr, std::move(ix), std::move(iy));
           },
+          [=](Expr<SomeUnsigned> &&ix,
+              Expr<SomeUnsigned> &&iy) -> std::optional<Expr<LogicalResult>> {
+            return PromoteAndRelate(opr, std::move(ix), std::move(iy));
+          },
           [=](Expr<SomeReal> &&rx,
               Expr<SomeReal> &&ry) -> std::optional<Expr<LogicalResult>> {
             return PromoteAndRelate(opr, std::move(rx), std::move(ry));

flang/test/Evaluate/fold-unsigned.f90

@@ -0,0 +1,12 @@
+! RUN: %python %S/test_folding.py %s %flang_fc1 -funsigned
+! UNSIGNED operations and intrinsic functions
+
+module m
+
+  logical, parameter :: test_huge_1  = huge(0u_1)  == 255u_1
+  logical, parameter :: test_huge_2  = huge(0u_2)  == 65535u_2
+  logical, parameter :: test_huge_4  = huge(0u_4)  == uint(huge(0_4),4) * 2u + 1u
+  logical, parameter :: test_huge_8  = huge(0u_8)  == uint(huge(0_8),8) * 2u + 1u
+  logical, parameter :: test_huge_16 = huge(0u_16) == uint(huge(0_16),16) * 2u + 1u
+
+end

flang/unittests/Evaluate/real.cpp

@@ -142,7 +142,7 @@ template <typename R> void basicTests(int rm, Rounding rounding) {
     Integer8 ix{x};
     TEST(!ix.IsNegative())(ldesc);
     MATCH(x, ix.ToUInt64())(ldesc);
-    vr = R::FromInteger(ix, rounding);
+    vr = R::FromInteger(ix, false, rounding);
     TEST(!vr.value.IsNegative())(ldesc);
     TEST(!vr.value.IsNotANumber())(ldesc);
     TEST(!vr.value.IsZero())(ldesc);
@@ -303,7 +303,7 @@ void inttest(std::int64_t x, int pass, Rounding rounding) {
   ScopedHostFloatingPointEnvironment fpenv;
   Integer8 ix{x};
   ValueWithRealFlags<REAL> real;
-  real = real.value.FromInteger(ix, rounding);
+  real = real.value.FromInteger(ix, false, rounding);
 #ifndef __clang__ // broken and also slow
   fpenv.ClearFlags();
 #endif