[flang][openacc] Add support for complex mul reduction

[clementval]

Summary

Add support to lower reduction with the multiply operator and
complex type.

Depends on D155007

[clementval]

Rebase + update init value

[razvanlupusoru]

flang/lib/Lower/OpenACC.cpp

718

Can you swap the names. Use init0 for the 0.0 value and init1 for the 1.0 value?

720–722

This seems swapped. The real value should be 1 and imaginary should be 0.

flang/test/Lower/OpenACC/acc-reduction.f90

7

Can you also swap the CST0 and CST1 names to match the values. I think it will help readability.

[clementval]

flang/lib/Lower/OpenACC.cpp

718

I can. I named them in sequence and not really about the value they carry.

[clementval]

Address review comment

[razvanlupusoru]

Looks great now! Thank you!

flang/lib/Lower/OpenACC.cpp

if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty))
                                getReductionInitValue<llvm::APFloat>(op, ty)));
   } else if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty)) {
     return builder.create<mlir::arith::ConstantOp>(
         loc, ty,
         builder.getFloatAttr(ty, getReductionInitValue<int64_t>(op, ty)));
   } else if (auto cmplxTy = mlir::dyn_cast_or_null<fir::ComplexType>(ty)) {
     mlir::Type floatTy =
         Fortran::lower::convertReal(builder.getContext(), cmplxTy.getFKind());
-    mlir::Value init = builder.createRealConstant(
+    mlir::Value realInit = builder.createRealConstant(
         loc, floatTy, getReductionInitValue<int64_t>(op, cmplxTy));
-    return fir::factory::Complex{builder, loc}.createComplex(cmplxTy.getFKind(),
-                                                             init, init);
+    mlir::Value imagInit = builder.createRealConstant(loc, floatTy, 0.0);
+    return fir::factory::Complex{builder, loc}.createComplex(
+        cmplxTy.getFKind(), realInit, imagInit);
   }
   if (auto refTy = mlir::dyn_cast<fir::ReferenceType>(ty)) {
     if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(refTy.getEleTy())) {
       mlir::Type vecTy =
           mlir::VectorType::get(seqTy.getShape(), seqTy.getEleTy());
       auto shTy = vecTy.cast<mlir::ShapedType>();
       if (seqTy.getEleTy().isIntOrIndex())
         return builder.create<mlir::arith::ConstantOp>(
if (op == mlir::acc::ReductionOperator::AccAdd) {
     TODO(loc, "reduction add type");
   }
 
   if (op == mlir::acc::ReductionOperator::AccMul) {
     if (ty.isIntOrIndex())
       return builder.create<mlir::arith::MulIOp>(loc, value1, value2);
     if (mlir::isa<mlir::FloatType>(ty))
       return builder.create<mlir::arith::MulFOp>(loc, value1, value2);
+    if (mlir::isa<fir::ComplexType>(ty))
+      return builder.create<fir::MulcOp>(loc, value1, value2);
     TODO(loc, "reduction mul type");
   }
 
   if (op == mlir::acc::ReductionOperator::AccMin)
     return fir::genMin(builder, loc, {value1, value2});
 
   if (op == mlir::acc::ReductionOperator::AccMax)
     return fir::genMax(builder, loc, {value1, value2});

flang/test/Lower/OpenACC/acc-reduction.f90

 ! This test checks lowering of OpenACC reduction clause.
 
 ! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
 
+! CHECK-LABEL: acc.reduction.recipe @reduction_mul_z32 : !fir.complex<4> reduction_operator <mul> init {
+! CHECK: ^bb0(%{{.*}}: !fir.complex<4>):
+! CHECK:   %[[REAL:.*]] = arith.constant 1.000000e+00 : f32
+! CHECK:   %[[IMAG:.*]] = arith.constant 0.000000e+00 : f32
+! CHECK:   %[[UNDEF:.*]] = fir.undefined !fir.complex<4>
+! CHECK:   %[[UNDEF1:.*]] = fir.insert_value %[[UNDEF]], %[[REAL]], [0 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
+! CHECK:   %[[UNDEF2:.*]] = fir.insert_value %[[UNDEF1]], %[[IMAG]], [1 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
+! CHECK:   acc.yield %[[UNDEF2]] : !fir.complex<4>
+! CHECK: } combiner {
+! CHECK: ^bb0(%[[ARG0:.*]]: !fir.complex<4>, %[[ARG1:.*]]: !fir.complex<4>):
+! CHECK:   %[[COMBINED:.*]] = fir.mulc %[[ARG0]], %[[ARG1]] : !fir.complex<4>
+! CHECK:   acc.yield %[[COMBINED]] : !fir.complex<4>
+! CHECK: }
+
 ! CHECK-LABEL: acc.reduction.recipe @reduction_add_z32 : !fir.complex<4> reduction_operator <add> init {
 ! CHECK: ^bb0(%{{.*}}: !fir.complex<4>):
-! CHECK:   %[[CST:.*]] = arith.constant 0.000000e+00 : f32
+! CHECK:   %[[REAL:.*]] = arith.constant 0.000000e+00 : f32
+! CHECK:   %[[IMAG:.*]] = arith.constant 0.000000e+00 : f32
 ! CHECK:   %[[UNDEF:.*]] = fir.undefined !fir.complex<4>
-! CHECK:   %[[UNDEF1:.*]] = fir.insert_value %[[UNDEF]], %[[CST]], [0 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
-! CHECK:   %[[UNDEF2:.*]] = fir.insert_value %[[UNDEF1]], %[[CST]], [1 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
+! CHECK:   %[[UNDEF1:.*]] = fir.insert_value %[[UNDEF]], %[[REAL]], [0 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
+! CHECK:   %[[UNDEF2:.*]] = fir.insert_value %[[UNDEF1]], %[[IMAG]], [1 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>
 ! CHECK:   acc.yield %[[UNDEF2]] : !fir.complex<4>
 ! CHECK: } combiner {
 ! CHECK: ^bb0(%[[ARG0:.*]]: !fir.complex<4>, %[[ARG1:.*]]: !fir.complex<4>):
 ! CHECK:   %[[COMBINED:.*]] = fir.addc %[[ARG0]], %[[ARG1]] : !fir.complex<4> 
 ! CHECK:   acc.yield %[[COMBINED]] : !fir.complex<4>
 ! CHECK: }
 
 ! CHECK-LABEL: acc.reduction.recipe @reduction_neqv_l32 : !fir.logical<4> reduction_operator <neqv> init {
subroutine acc_reduction_add_cmplx()
   complex :: c
   !$acc parallel reduction(+:c)
   !$acc end parallel
 end subroutine
 
 ! CHECK-LABEL: func.func @_QPacc_reduction_add_cmplx()
 ! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref<!fir.complex<4>>) -> !fir.ref<!fir.complex<4>> {name = "c"}
 ! CHECK: acc.parallel reduction(@reduction_add_z32 -> %[[RED]] : !fir.ref<!fir.complex<4>>)
+
+subroutine acc_reduction_mul_cmplx()
+  complex :: c
+  !$acc parallel reduction(*:c)
+  !$acc end parallel
+end subroutine
+
+! CHECK-LABEL: func.func @_QPacc_reduction_mul_cmplx()
+! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref<!fir.complex<4>>) -> !fir.ref<!fir.complex<4>> {name = "c"}
+! CHECK: acc.parallel reduction(@reduction_mul_z32 -> %[[RED]] : !fir.ref<!fir.complex<4>>)