[flang] Don't blow up when combining mixed COMPLEX operations #66235

klausler · 2023-09-13T16:42:40Z

Expression processing applies some straightforward rewriting of mixed complex/real and complex/integer operations to avoid having to promote the real/integer operand to complex and then perform a complex operation; for example, (a,b)+x becomes (a+x,b) rather than (a,b)+(x,0). But this can blow up the expression representation when the complex operand cannot be duplicated cheaply. So apply this technique only to complex operands that are appropriate to duplicate.

Fixes #65142.

llvmbot · 2023-09-13T16:44:01Z

@llvm/pr-subscribers-flang-semantics

Changes

Expression processing applies some straightforward rewriting of mixed complex/real and complex/integer operations to avoid having to promote the real/integer operand to complex and then perform a complex operation; for example, (a,b)+x becomes (a+x,b) rather than (a,b)+(x,0). But this can blow up the expression representation when the complex operand cannot be duplicated cheaply. So apply this technique only to complex operands that are appropriate to duplicate.

Fixes #65142.

Patch is 20.59 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/66235.diff

3 Files Affected:

(modified) flang/include/flang/Evaluate/tools.h (-10)
(modified) flang/lib/Evaluate/tools.cpp (+175-88)
(added) flang/test/Evaluate/bug65142.f90 (+14)

<pre>
diff --git a/flang/include/flang/Evaluate/tools.h b/flang/include/flang/Evaluate/tools.h
index b3f8f4a67a7b5dd..a3aac185f8542f9 100644
--- a/flang/include/flang/Evaluate/tools.h
+++ b/flang/include/flang/Evaluate/tools.h
@@ -149,16 +149,6 @@ common::IfNoLvalue<Expr<SomeKind<ResultType<A>::category>>, A> AsCategoryExpr(

Expr<SomeType> Parenthesize(Expr<SomeType> &&);

-Expr<SomeReal> GetComplexPart(

const Expr<SomeComplex> &, bool isImaginary = false);
-Expr<SomeReal> GetComplexPart(Expr<SomeComplex> &&, bool isImaginary = false);

-template <int KIND>
-Expr<SomeComplex> MakeComplex(Expr<Type<TypeCategory::Real, KIND>> &&re,

Expr<Type<TypeCategory::Real, KIND>> &&im) {
return AsCategoryExpr(ComplexConstructor<KIND>{std::move(re), std::move(im)});
-}

template <typename A> constexpr bool IsNumericCategoryExpr() {
if constexpr (common::HasMember<A, TypelessExpression>) {
return false;
diff --git a/flang/lib/Evaluate/tools.cpp b/flang/lib/Evaluate/tools.cpp
index d2fa5c9b5f36be6..b1bb1c1c6be8b1d 100644
--- a/flang/lib/Evaluate/tools.cpp
+++ b/flang/lib/Evaluate/tools.cpp
@@ -180,8 +180,9 @@ std::optional<Expr<SomeType>> Package(
std::optional<Expr<SomeKind<CAT>>> &&catExpr) {
if (catExpr) {
return {AsGenericExpr(std::move(*catExpr))};

} else {
return std::nullopt;
}

return NoExpr();
}

// Mixed REAL+INTEGER operations. REAL**INTEGER is a special case that
@@ -204,6 +205,12 @@ std::optional<Expr<SomeType>> MixedRealLeft(
std::move(rx.u)));
}

+template <int KIND>
+Expr<SomeComplex> MakeComplex(Expr<Type<TypeCategory::Real, KIND>> &&re,

Expr<Type<TypeCategory::Real, KIND>> &&im) {
return AsCategoryExpr(ComplexConstructor<KIND>{std::move(re), std::move(im)});
+}

std::optional<Expr<SomeComplex>> ConstructComplex(
parser::ContextualMessages &messages, Expr<SomeType> &&real,
Expr<SomeType> &&imaginary, int defaultRealKind) {
@@ -228,24 +235,87 @@ std::optional<Expr<SomeComplex>> ConstructComplex(
return std::nullopt;
}

-Expr<SomeReal> GetComplexPart(const Expr<SomeComplex> &z, bool isImaginary) {

return common::visit(
```
 [&amp;amp;](const auto &amp;amp;zk) {
```

   static constexpr int kind{ResultType&amp;lt;decltype(zk)&amp;gt;::kind};

   return AsCategoryExpr(ComplexComponent&amp;lt;kind&amp;gt;{isImaginary, zk});

```
 },
```
```
 z.u);
```

-}
+// Extracts the real or imaginary part of the result of a COMPLEX
+// expression, when that expression is simple enough to be duplicated.
+template <bool GET_IMAGINARY> struct ComplexPartExtractor {

template <typename A> static std::optional<Expr<SomeReal>> Get(const A &) {
return std::nullopt;
}

-Expr<SomeReal> GetComplexPart(Expr<SomeComplex> &&z, bool isImaginary) {

return common::visit(

 [&amp;amp;](auto &amp;amp;&amp;amp;zk) {

   static constexpr int kind{ResultType&amp;lt;decltype(zk)&amp;gt;::kind};

```
   return AsCategoryExpr(
```

       ComplexComponent&amp;lt;kind&amp;gt;{isImaginary, std::move(zk)});

```
 },
```
```
 z.u);
```

-}

template <int KIND>
static std::optional<Expr<SomeReal>> Get(

 const Parentheses&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;&amp;gt; &amp;amp;kz) {

if (auto x{Get(kz.left())}) {
```
 return AsGenericExpr(AsSpecificExpr(
```

     Parentheses&amp;lt;Type&amp;lt;TypeCategory::Real, KIND&amp;gt;&amp;gt;{std::move(*x)}));

} else {
```
 return std::nullopt;
```
}
}
template <int KIND>
static std::optional<Expr<SomeReal>> Get(

 const Negate&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;&amp;gt; &amp;amp;kz) {

if (auto x{Get(kz.left())}) {
```
 return AsGenericExpr(AsSpecificExpr(
```

     Negate&amp;lt;Type&amp;lt;TypeCategory::Real, KIND&amp;gt;&amp;gt;{std::move(*x)}));

} else {
```
 return std::nullopt;
```
}
}
template <int KIND>
static std::optional<Expr<SomeReal>> Get(

 const Convert&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;, TypeCategory::Complex&amp;gt;

```
     &amp;amp;kz) {
```
if (auto x{Get(kz.left())}) {
```
 return AsGenericExpr(AsSpecificExpr(
```

     Convert&amp;lt;Type&amp;lt;TypeCategory::Real, KIND&amp;gt;, TypeCategory::Real&amp;gt;{

         AsGenericExpr(std::move(*x))}));

} else {
```
 return std::nullopt;
```
}
}
template <int KIND>
static std::optional<Expr<SomeReal>> Get(const ComplexConstructor<KIND> &kz) {
return GET_IMAGINARY ? Get(kz.right()) : Get(kz.left());
}
template <int KIND>
static std::optional<Expr<SomeReal>> Get(

 const Constant&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;&amp;gt; &amp;amp;kz) {

if (auto cz{kz.GetScalarValue()}) {
```
 return AsGenericExpr(
```

     AsSpecificExpr(GET_IMAGINARY ? cz-&amp;gt;AIMAG() : cz-&amp;gt;REAL()));

} else {
```
 return std::nullopt;
```
}
}
template <int KIND>
static std::optional<Expr<SomeReal>> Get(

 const Designator&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;&amp;gt; &amp;amp;kz) {

if (const auto *symbolRef{std::get_if<SymbolRef>(&kz.u)}) {
```
 return AsGenericExpr(AsSpecificExpr(
```

     Designator&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;&amp;gt;{ComplexPart{

```
         DataRef{*symbolRef},
```

         GET_IMAGINARY ? ComplexPart::Part::IM : ComplexPart::Part::RE}}));

} else {
```
 return std::nullopt;
```
}
}
template <int KIND>
static std::optional<Expr<SomeReal>> Get(

 const Expr&amp;lt;Type&amp;lt;TypeCategory::Complex, KIND&amp;gt;&amp;gt; &amp;amp;kz) {

return Get(kz.u);
}
static std::optional<Expr<SomeReal>> Get(const Expr<SomeComplex> &z) {
return Get(z.u);
}
+};

// Convert REAL to COMPLEX of the same kind. Preserving the real operand kind
// and then applying complex operand promotion rules allows the result to have
@@ -266,19 +336,31 @@ Expr<SomeComplex> PromoteRealToComplex(Expr<SomeReal> &&someX) {
// corresponding COMPLEX+COMPLEX operation.
template <template <typename> class OPR, TypeCategory RCAT>
std::optional<Expr<SomeType>> MixedComplexLeft(

parser::ContextualMessages &messages, Expr<SomeComplex> &&zx,
Expr<SomeKind<RCAT>> &&iry, [[maybe_unused]] int defaultRealKind) {
Expr<SomeReal> zr{GetComplexPart(zx, false)};
Expr<SomeReal> zi{GetComplexPart(zx, true)};
if constexpr (std::is_same_v<OPR<LargestReal>, Add<LargestReal>> ||

parser::ContextualMessages &messages, const Expr<SomeComplex> &zx,
const Expr<SomeKind<RCAT>> &iry, [[maybe_unused]] int defaultRealKind) {
if constexpr (RCAT == TypeCategory::Integer &&

 std::is_same_v&amp;lt;OPR&amp;lt;LargestReal&amp;gt;, Power&amp;lt;LargestReal&amp;gt;&amp;gt;) {

// COMPLEX**INTEGER is a special case that doesn't convert the exponent.
return Package(common::visit(

   [&amp;amp;](const auto &amp;amp;zxk) {

     using Ty = ResultType&amp;lt;decltype(zxk)&amp;gt;;

```
     return AsCategoryExpr(AsExpr(
```

         RealToIntPower&amp;lt;Ty&amp;gt;{common::Clone(zxk), common::Clone(iry)}));

```
   },
```
```
   zx.u));
```
}
std::optional<Expr<SomeReal>> zr{ComplexPartExtractor<false>{}.Get(zx)};
std::optional<Expr<SomeReal>> zi{ComplexPartExtractor<true>{}.Get(zx)};
if (!zr || !zi) {
} else if constexpr (std::is_same_v<OPR<LargestReal>, Add<LargestReal>> ||
std::is_same_v<OPR<LargestReal>, Subtract<LargestReal>>) {
// (a,b) + x -> (a+x, b)
// (a,b) - x -> (a-x, b)
if (std::optional<Expr<SomeType>> rr{

       NumericOperation&amp;lt;OPR&amp;gt;(messages, AsGenericExpr(std::move(zr)),

           AsGenericExpr(std::move(iry)), defaultRealKind)}) {

       NumericOperation&amp;lt;OPR&amp;gt;(messages, AsGenericExpr(std::move(*zr)),

           AsGenericExpr(common::Clone(iry)), defaultRealKind)}) {
 return Package(ConstructComplex(messages, std::move(*rr),

     AsGenericExpr(std::move(zi)), defaultRealKind));

```
     AsGenericExpr(std::move(*zi)), defaultRealKind));
```
}
} else if constexpr (allowOperandDuplication &&
(std::is_same_v<OPR<LargestReal>, Multiply<LargestReal>> ||
@@ -286,36 +368,16 @@ std::optional<Expr<SomeType>> MixedComplexLeft(
// (a,b) * x -> (ax, bx)
// (a,b) / x -> (a/x, b/x)
auto copy{iry};

auto rr{NumericOperation<OPR>(messages, AsGenericExpr(std::move(zr)),

   AsGenericExpr(std::move(iry)), defaultRealKind)};

auto ri{NumericOperation<OPR>(messages, AsGenericExpr(std::move(zi)),

auto rr{NumericOperation<OPR>(messages, AsGenericExpr(std::move(*zr)),

   AsGenericExpr(common::Clone(iry)), defaultRealKind)};

auto ri{NumericOperation<OPR>(messages, AsGenericExpr(std::move(*zi)),
AsGenericExpr(std::move(copy)), defaultRealKind)};
if (auto parts{common::AllPresent(std::move(rr), std::move(ri))}) {
return Package(ConstructComplex(messages, std::get<0>(std::move(*parts)),
std::get<1>(std::move(*parts)), defaultRealKind));
}

} else if constexpr (RCAT == TypeCategory::Integer &&

 std::is_same_v&amp;lt;OPR&amp;lt;LargestReal&amp;gt;, Power&amp;lt;LargestReal&amp;gt;&amp;gt;) {

// COMPLEX**INTEGER is a special case that doesn't convert the exponent.
static_assert(RCAT == TypeCategory::Integer);
return Package(common::visit(

   [&amp;amp;](auto &amp;amp;&amp;amp;zxk) {

     using Ty = ResultType&amp;lt;decltype(zxk)&amp;gt;;

```
     return AsCategoryExpr(
```

         AsExpr(RealToIntPower&amp;lt;Ty&amp;gt;{std::move(zxk), std::move(iry)}));

```
   },
```
```
   std::move(zx.u)));
```
} else {
// (a,b) ** x -> (a,b) ** (x,0)
if constexpr (RCAT == TypeCategory::Integer) {

 Expr&amp;lt;SomeComplex&amp;gt; zy{ConvertTo(zx, std::move(iry))};

 return Package(PromoteAndCombine&amp;lt;OPR&amp;gt;(std::move(zx), std::move(zy)));

} else {

 Expr&amp;lt;SomeComplex&amp;gt; zy{PromoteRealToComplex(std::move(iry))};

 return Package(PromoteAndCombine&amp;lt;OPR&amp;gt;(std::move(zx), std::move(zy)));

}
}
return NoExpr();

return std::nullopt;
}

// Mixed COMPLEX operations with the COMPLEX operand on the right.
@@ -325,39 +387,49 @@ std::optional<Expr<SomeType>> MixedComplexLeft(
// x / (a,b) -> (x,0) / (a,b) (and **)
template <template <typename> class OPR, TypeCategory LCAT>
std::optional<Expr<SomeType>> MixedComplexRight(

parser::ContextualMessages &messages, Expr<SomeKind<LCAT>> &&irx,
Expr<SomeComplex> &&zy, [[maybe_unused]] int defaultRealKind) {

parser::ContextualMessages &messages, const Expr<SomeKind<LCAT>> &irx,
const Expr<SomeComplex> &zy, [[maybe_unused]] int defaultRealKind) {
if constexpr (std::is_same_v<OPR<LargestReal>, Add<LargestReal>>) {
// x + (a,b) -> (a,b) + x -> (a+x, b)

return MixedComplexLeft<OPR, LCAT>(

   messages, std::move(zy), std::move(irx), defaultRealKind);

return MixedComplexLeft<OPR, LCAT>(messages, zy, irx, defaultRealKind);
} else if constexpr (allowOperandDuplication &&
std::is_same_v<OPR<LargestReal>, Multiply<LargestReal>>) {
// x * (a,b) -> (a,b) * x -> (ax, bx)

return MixedComplexLeft<OPR, LCAT>(

   messages, std::move(zy), std::move(irx), defaultRealKind);

return MixedComplexLeft<OPR, LCAT>(messages, zy, irx, defaultRealKind);
} else if constexpr (std::is_same_v<OPR<LargestReal>,
Subtract<LargestReal>>) {
// x - (a,b) -> (x-a, -b)

Expr<SomeReal> zr{GetComplexPart(zy, false)};
Expr<SomeReal> zi{GetComplexPart(zy, true)};
if (std::optional<Expr<SomeType>> rr{

       NumericOperation&amp;lt;Subtract&amp;gt;(messages, AsGenericExpr(std::move(irx)),

           AsGenericExpr(std::move(zr)), defaultRealKind)}) {

 return Package(ConstructComplex(messages, std::move(*rr),

     AsGenericExpr(-std::move(zi)), defaultRealKind));

}
} else {
// x / (a,b) -> (x,0) / (a,b)
if constexpr (LCAT == TypeCategory::Integer) {

 Expr&amp;lt;SomeComplex&amp;gt; zx{ConvertTo(zy, std::move(irx))};

 return Package(PromoteAndCombine&amp;lt;OPR&amp;gt;(std::move(zx), std::move(zy)));

} else {

 Expr&amp;lt;SomeComplex&amp;gt; zx{PromoteRealToComplex(std::move(irx))};

 return Package(PromoteAndCombine&amp;lt;OPR&amp;gt;(std::move(zx), std::move(zy)));

std::optional<Expr<SomeReal>> zr{ComplexPartExtractor<false>{}.Get(zy)};
std::optional<Expr<SomeReal>> zi{ComplexPartExtractor<true>{}.Get(zy)};
if (zr && zi) {

 if (std::optional&amp;lt;Expr&amp;lt;SomeType&amp;gt;&amp;gt; rr{NumericOperation&amp;lt;Subtract&amp;gt;(messages,

         AsGenericExpr(common::Clone(irx)), AsGenericExpr(std::move(*zr)),

```
         defaultRealKind)}) {
```

   return Package(ConstructComplex(messages, std::move(*rr),

       AsGenericExpr(-std::move(*zi)), defaultRealKind));

```
 }
```
}
}

return NoExpr();

return std::nullopt;
+}

+// Promotes REAL(rk) and COMPLEX(zk) operands COMPLEX(max(rk,zk))
+// then combine them with an operator.
+template <template <typename> class OPR, TypeCategory XCAT, TypeCategory YCAT>
+Expr<SomeComplex> PromoteMixedComplexReal(

Expr<SomeKind<XCAT>> &&x, Expr<SomeKind<YCAT>> &&y) {
static_assert(XCAT == TypeCategory::Complex || YCAT == TypeCategory::Complex);
static_assert(XCAT == TypeCategory::Real || YCAT == TypeCategory::Real);
return common::visit(

 [&amp;amp;](const auto &amp;amp;kx, const auto &amp;amp;ky) {

```
   constexpr int maxKind{std::max(
```

       ResultType&amp;lt;decltype(kx)&amp;gt;::kind, ResultType&amp;lt;decltype(ky)&amp;gt;::kind)};

   using ZTy = Type&amp;lt;TypeCategory::Complex, maxKind&amp;gt;;

   return Expr&amp;lt;SomeComplex&amp;gt;{

       Expr&amp;lt;ZTy&amp;gt;{OPR&amp;lt;ZTy&amp;gt;{ConvertToType&amp;lt;ZTy&amp;gt;(std::move(x)),

           ConvertToType&amp;lt;ZTy&amp;gt;(std::move(y))}}};

```
 },
```
```
 x.u, y.u);
```

}

// N.B. When a "typeless" BOZ literal constant appears as one (not both!) of
@@ -397,20 +469,40 @@ std::optional<Expr<SomeType>> NumericOperation(
std::move(zx), std::move(zy)));
},
[&](Expr<SomeComplex> &&zx, Expr<SomeInteger> &&iy) {

       return MixedComplexLeft&amp;lt;OPR&amp;gt;(

           messages, std::move(zx), std::move(iy), defaultRealKind);

```
       if (auto result{
```

               MixedComplexLeft&amp;lt;OPR&amp;gt;(messages, zx, iy, defaultRealKind)}) {

```
         return result;
```
```
       } else {
```

         return Package(PromoteAndCombine&amp;lt;OPR, TypeCategory::Complex&amp;gt;(

             std::move(zx), ConvertTo(zx, std::move(iy))));

       }
     },
     [&amp;amp;](Expr&amp;lt;SomeComplex&amp;gt; &amp;amp;&amp;amp;zx, Expr&amp;lt;SomeReal&amp;gt; &amp;amp;&amp;amp;ry) {

       return MixedComplexLeft&amp;lt;OPR&amp;gt;(

           messages, std::move(zx), std::move(ry), defaultRealKind);

```
       if (auto result{
```

               MixedComplexLeft&amp;lt;OPR&amp;gt;(messages, zx, ry, defaultRealKind)}) {

```
         return result;
```
```
       } else {
```
```
         return Package(
```

             PromoteMixedComplexReal&amp;lt;OPR&amp;gt;(std::move(zx), std::move(ry)));

       }
     },
     [&amp;amp;](Expr&amp;lt;SomeInteger&amp;gt; &amp;amp;&amp;amp;ix, Expr&amp;lt;SomeComplex&amp;gt; &amp;amp;&amp;amp;zy) {

       return MixedComplexRight&amp;lt;OPR&amp;gt;(

           messages, std::move(ix), std::move(zy), defaultRealKind);

       if (auto result{MixedComplexRight&amp;lt;OPR&amp;gt;(

               messages, ix, zy, defaultRealKind)}) {

```
         return result;
```
```
       } else {
```

         return Package(PromoteAndCombine&amp;lt;OPR, TypeCategory::Complex&amp;gt;(

             ConvertTo(zy, std::move(ix)), std::move(zy)));

       }
     },
     [&amp;amp;](Expr&amp;lt;SomeReal&amp;gt; &amp;amp;&amp;amp;rx, Expr&amp;lt;SomeComplex&amp;gt; &amp;amp;&amp;amp;zy) {

       return MixedComplexRight&amp;lt;OPR&amp;gt;(

           messages, std::move(rx), std::move(zy), defaultRealKind);

       if (auto result{MixedComplexRight&amp;lt;OPR&amp;gt;(

               messages, rx, zy, defaultRealKind)}) {

```
         return result;
```
```
       } else {
```
```
         return Package(
```

             PromoteMixedComplexReal&amp;lt;OPR&amp;gt;(std::move(rx), std::move(zy)));

       }
     },
     // Operations with one typeless operand
     [&amp;amp;](BOZLiteralConstant &amp;amp;&amp;amp;bx, Expr&amp;lt;SomeInteger&amp;gt; &amp;amp;&amp;amp;iy) {

@@ -433,7 +525,6 @@ std::optional<Expr<SomeType>> NumericOperation(
},
// Default case
[&](auto &&, auto &&) {

       // TODO: defined operator
       messages.Say(&amp;quot;non-numeric operands to numeric operation&amp;quot;_err_en_US);
       return NoExpr();
     },

@@ -481,17 +572,14 @@ std::optional<Expr<SomeType>> Negation(
[&](Expr<SomeReal> &&x) { return Package(-std::move(x)); },
[&](Expr<SomeComplex> &&x) { return Package(-std::move(x)); },
[&](Expr<SomeCharacter> &&) {

       // TODO: defined operator
       messages.Say(&amp;quot;CHARACTER cannot be negated&amp;quot;_err_en_US);
       return NoExpr();
     },
     [&amp;amp;](Expr&amp;lt;SomeLogical&amp;gt; &amp;amp;&amp;amp;) {

       // TODO: defined operator
       messages.Say(&amp;quot;LOGICAL cannot be negated&amp;quot;_err_en_US);
       return NoExpr();
     },
     [&amp;amp;](Expr&amp;lt;SomeDerived&amp;gt; &amp;amp;&amp;amp;) {

       // TODO: defined operator
       messages.Say(&amp;quot;Operand cannot be negated&amp;quot;_err_en_US);
       return NoExpr();
     },

@@ -643,8 +731,7 @@ std::optional<Expr<SomeType>> ConvertToType(
if (auto length{type.GetCharLength()}) {
converted = common::visit(
[&](auto &&x) {

         using Ty = std::decay_t&amp;lt;decltype(x)&amp;gt;;

         using CharacterType = typename Ty::Result;

         using CharacterType = ResultType&amp;lt;decltype(x)&amp;gt;;
         return Expr&amp;lt;SomeCharacter&amp;gt;{
             Expr&amp;lt;CharacterType&amp;gt;{SetLength&amp;lt;CharacterType::kind&amp;gt;{
                 std::move(x), std::move(*length)}}};

@@ -1100,7 +1187,7 @@ static std::optional<Expr<SomeType>> DataConstantConversionHelper(
if (const auto *someExpr{UnwrapExpr<Expr<SomeKind<FROM>>>(*sized)}) {
return common::visit(
[](const auto &w) -> std::optional<Expr<SomeType>> {

       using FromType = typename std::decay_t&amp;lt;decltype(w)&amp;gt;::Result;

       using FromType = ResultType&amp;lt;decltype(w)&amp;gt;;
       static constexpr int kind{FromType::kind};
       if constexpr (IsValidKindOfIntrinsicType(TO, kind)) {
         if (const auto *fromConst{UnwrapExpr&amp;lt;Constant&amp;lt;FromType&amp;gt;&amp;gt;(w)}) {

diff --git a/flang/test/Evaluate/bug65142.f90 b/flang/test/Evaluate/bug65142.f90
new file mode 100644
index 000000000000000..e9bac4f5bbe0cb5
--- /dev/null
+++ b/flang/test/Evaluate/bug65142.f90
@@ -0,0 +1,14 @@
+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
+! Ensure that expression rewriting doesn't blow up when many
+! mixed complex operations are combined.
+! The result of folding (8,1.542956)**9 is c...

Expression processing applies some straightforward rewriting of mixed complex/real and complex/integer operations to avoid having to promote the real/integer operand to complex and then perform a complex operation; for example, (a,b)+x becomes (a+x,b) rather than (a,b)+(x,0). But this can blow up the expression representation when the complex operand cannot be duplicated cheaply. So apply this technique only to complex operands that are appropriate to duplicate. Fixes llvm#65142. Pull request: llvm#66235

…6235) Expression processing applies some straightforward rewriting of mixed complex/real and complex/integer operations to avoid having to promote the real/integer operand to complex and then perform a complex operation; for example, (a,b)+x becomes (a+x,b) rather than (a,b)+(x,0). But this can blow up the expression representation when the complex operand cannot be duplicated cheaply. So apply this technique only to complex operands that are appropriate to duplicate. Fixes llvm#65142.

klausler requested a review from vdonaldson September 13, 2023 16:42

klausler requested a review from a team as a code owner September 13, 2023 16:42

llvmbot added flang Flang issues not falling into any other category flang:semantics labels Sep 13, 2023

klausler force-pushed the bug65142 branch from 4dda551 to 127709f Compare September 13, 2023 16:43

vdonaldson approved these changes Sep 13, 2023

View reviewed changes

klausler force-pushed the bug65142 branch from 127709f to ca6b9e1 Compare September 13, 2023 23:21

klausler merged commit daa5da0 into llvm:main Sep 13, 2023

klausler deleted the bug65142 branch September 13, 2023 23:34

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[flang] Don't blow up when combining mixed COMPLEX operations #66235

[flang] Don't blow up when combining mixed COMPLEX operations #66235

Uh oh!

klausler commented Sep 13, 2023

Uh oh!

llvmbot commented Sep 13, 2023

Fixes #65142.

Uh oh!

Uh oh!

[flang] Don't blow up when combining mixed COMPLEX operations #66235

[flang] Don't blow up when combining mixed COMPLEX operations #66235

Uh oh!

Conversation

klausler commented Sep 13, 2023

Uh oh!

llvmbot commented Sep 13, 2023

Fixes #65142.

Uh oh!

Uh oh!