[flang] COMPLEX folding

Original-commit: flang-compiler/f18@6f1ef45
Reviewed-on: flang-compiler/f18#162
Tree-same-pre-rewrite: false

Author: klausler

flang/lib/evaluate/common.h

@@ -82,6 +82,8 @@ template<typename A> struct ValueWithRealFlags {
 
 ENUM_CLASS(Rounding, TiesToEven, ToZero, Down, Up, TiesAwayFromZero)
 
+static constexpr Rounding defaultRounding{Rounding::TiesToEven};
+
 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 constexpr bool IsHostLittleEndian{false};
 #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

flang/lib/evaluate/complex.cc

@@ -17,36 +17,40 @@
 namespace Fortran::evaluate::value {
 
 template<typename R>
-ValueWithRealFlags<Complex<R>> Complex<R>::Add(const Complex &that) const {
+ValueWithRealFlags<Complex<R>> Complex<R>::Add(
+    const Complex &that, Rounding rounding) const {
   RealFlags flags;
-  Part reSum{re_.Add(that.re_).AccumulateFlags(flags)};
-  Part imSum{im_.Add(that.im_).AccumulateFlags(flags)};
+  Part reSum{re_.Add(that.re_, rounding).AccumulateFlags(flags)};
+  Part imSum{im_.Add(that.im_, rounding).AccumulateFlags(flags)};
   return {Complex{reSum, imSum}, flags};
 }
 
 template<typename R>
-ValueWithRealFlags<Complex<R>> Complex<R>::Subtract(const Complex &that) const {
+ValueWithRealFlags<Complex<R>> Complex<R>::Subtract(
+    const Complex &that, Rounding rounding) const {
   RealFlags flags;
-  Part reDiff{re_.Subtract(that.re_).AccumulateFlags(flags)};
-  Part imDiff{im_.Subtract(that.im_).AccumulateFlags(flags)};
+  Part reDiff{re_.Subtract(that.re_, rounding).AccumulateFlags(flags)};
+  Part imDiff{im_.Subtract(that.im_, rounding).AccumulateFlags(flags)};
   return {Complex{reDiff, imDiff}, flags};
 }
 
 template<typename R>
-ValueWithRealFlags<Complex<R>> Complex<R>::Multiply(const Complex &that) const {
+ValueWithRealFlags<Complex<R>> Complex<R>::Multiply(
+    const Complex &that, Rounding rounding) const {
   // (a + ib)*(c + id) -> ac - bd + i(ad + bc)
   RealFlags flags;
-  Part ac{re_.Multiply(that.re_).AccumulateFlags(flags)};
-  Part bd{im_.Multiply(that.im_).AccumulateFlags(flags)};
-  Part ad{re_.Multiply(that.im_).AccumulateFlags(flags)};
-  Part bc{im_.Multiply(that.re_).AccumulateFlags(flags)};
-  Part acbd{ac.Subtract(bd).AccumulateFlags(flags)};
-  Part adbc{ad.Add(bc).AccumulateFlags(flags)};
+  Part ac{re_.Multiply(that.re_, rounding).AccumulateFlags(flags)};
+  Part bd{im_.Multiply(that.im_, rounding).AccumulateFlags(flags)};
+  Part ad{re_.Multiply(that.im_, rounding).AccumulateFlags(flags)};
+  Part bc{im_.Multiply(that.re_, rounding).AccumulateFlags(flags)};
+  Part acbd{ac.Subtract(bd, rounding).AccumulateFlags(flags)};
+  Part adbc{ad.Add(bc, rounding).AccumulateFlags(flags)};
   return {Complex{acbd, adbc}, flags};
 }
 
 template<typename R>
-ValueWithRealFlags<Complex<R>> Complex<R>::Divide(const Complex &that) const {
+ValueWithRealFlags<Complex<R>> Complex<R>::Divide(
+    const Complex &that, Rounding rounding) const {
   // (a + ib)/(c + id) -> [(a+ib)*(c-id)] / [(c+id)*(c-id)]
   //   -> [ac+bd+i(bc-ad)] / (cc+dd)
   //   -> ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
@@ -55,30 +59,30 @@ ValueWithRealFlags<Complex<R>> Complex<R>::Divide(const Complex &that) const {
   RealFlags flags;
   bool cGEd{that.re_.ABS().Compare(that.im_.ABS()) != Relation::Less};
   if (cGEd) {
-    scale = that.im_.Divide(that.re_).AccumulateFlags(flags);
+    scale = that.im_.Divide(that.re_, rounding).AccumulateFlags(flags);
   } else {
-    scale = that.re_.Divide(that.im_).AccumulateFlags(flags);
+    scale = that.re_.Divide(that.im_, rounding).AccumulateFlags(flags);
   }
   Part den;
   if (cGEd) {
-    Part dS{scale.Multiply(that.im_).AccumulateFlags(flags)};
-    den = dS.Add(that.re_).AccumulateFlags(flags);
+    Part dS{scale.Multiply(that.im_, rounding).AccumulateFlags(flags)};
+    den = dS.Add(that.re_, rounding).AccumulateFlags(flags);
   } else {
-    Part cS{scale.Multiply(that.re_).AccumulateFlags(flags)};
-    den = cS.Add(that.im_).AccumulateFlags(flags);
+    Part cS{scale.Multiply(that.re_, rounding).AccumulateFlags(flags)};
+    den = cS.Add(that.im_, rounding).AccumulateFlags(flags);
   }
-  Part aS{scale.Multiply(re_).AccumulateFlags(flags)};
-  Part bS{scale.Multiply(im_).AccumulateFlags(flags)};
+  Part aS{scale.Multiply(re_, rounding).AccumulateFlags(flags)};
+  Part bS{scale.Multiply(im_, rounding).AccumulateFlags(flags)};
   Part re1, im1;
   if (cGEd) {
-    re1 = re_.Add(bS).AccumulateFlags(flags);
-    im1 = im_.Subtract(aS).AccumulateFlags(flags);
+    re1 = re_.Add(bS, rounding).AccumulateFlags(flags);
+    im1 = im_.Subtract(aS, rounding).AccumulateFlags(flags);
   } else {
-    re1 = aS.Add(im_).AccumulateFlags(flags);
-    im1 = bS.Subtract(re_).AccumulateFlags(flags);
+    re1 = aS.Add(im_, rounding).AccumulateFlags(flags);
+    im1 = bS.Subtract(re_, rounding).AccumulateFlags(flags);
   }
-  Part re{re1.Divide(den).AccumulateFlags(flags)};
-  Part im{im1.Divide(den).AccumulateFlags(flags)};
+  Part re{re1.Divide(den, rounding).AccumulateFlags(flags)};
+  Part im{im1.Divide(den, rounding).AccumulateFlags(flags)};
   return {Complex{re, im}, flags};
 }
 

flang/lib/evaluate/complex.h

@@ -29,6 +29,8 @@ template<typename REAL_TYPE> class Complex {
   constexpr Complex(const Complex &) = default;
   constexpr Complex(const Part &r, const Part &i) : re_{r}, im_{i} {}
   explicit constexpr Complex(const Part &r) : re_{r} {}
+  constexpr Complex &operator=(const Complex &) = default;
+  constexpr Complex &operator=(Complex &&) = default;
 
   constexpr const Part &REAL() const { return re_; }
   constexpr const Part &AIMAG() const { return im_; }
@@ -40,10 +42,43 @@ template<typename REAL_TYPE> class Complex {
         im_.Compare(that.im_) == Relation::Equal;
   }
 
-  ValueWithRealFlags<Complex> Add(const Complex &) const;
-  ValueWithRealFlags<Complex> Subtract(const Complex &) const;
-  ValueWithRealFlags<Complex> Multiply(const Complex &) const;
-  ValueWithRealFlags<Complex> Divide(const Complex &) const;
+  constexpr bool IsZero() const { return re_.IsZero() || im_.IsZero(); }
+
+  constexpr bool IsInfinite() const {
+    return re_.IsInfinite() || im_.IsInfinite();
+  }
+
+  constexpr bool IsNotANumber() const {
+    return re_.IsNotANumber() || im_.IsNotANumber();
+  }
+
+  constexpr bool IsSignalingNaN() const {
+    return re_.IsSignalingNaN() || im_.IsSignalingNaN();
+  }
+
+  template<typename INT>
+  static ValueWithRealFlags<Complex> FromInteger(
+      const INT &n, Rounding rounding = defaultRounding) {
+    ValueWithRealFlags<Complex> result;
+    result.value.re_ =
+        Part::FromInteger(n, rounding).AccumulateFlags(result.flags);
+    return result;
+  }
+
+  ValueWithRealFlags<Complex> Add(
+      const Complex &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Complex> Subtract(
+      const Complex &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Complex> Multiply(
+      const Complex &, Rounding rounding = defaultRounding) const;
+  ValueWithRealFlags<Complex> Divide(
+      const Complex &, Rounding rounding = defaultRounding) const;
+
+  constexpr Complex FlushDenormalToZero() const {
+    return {re_.FlushDenormalToZero(), im_.FlushDenormalToZero()};
+  }
+
+  static constexpr Complex NaN() { return {Part::NaN(), Part::NaN()}; }
 
   std::string DumpHexadecimal() const;
   // TODO: (C)ABS once Real::HYPOT is done