[flang][openacc] Support .and. reduction operator

[clementval]

Summary

Add support for the .and. reduction operator
in Flang/OpenACC lowering.

Depends on D154888

[razvanlupusoru]

flang/lib/Lower/OpenACC.cpp

704

What happens if integer type is used with .and. operator? What concerns me here is by checking on type, it assumes that operand is logical type. Maybe it might be better to check for operator, then check for logical type (and generate error if not true).

707

Representation for true is decided by the frontend. Although it is 1 for F18, it seems it would be better to call some fir:: utility to get this value so that it is in a single place.

[clementval]

Address review comments

[clementval]

clang-format

[clementval]

flang/lib/Lower/OpenACC.cpp

704

Switch to check type first and add an assert.

707

Good point. I switched to use builder.createBool which as the logic inside.

[razvanlupusoru]

Thank you for addressing my comments. Looks good now!

flang/lib/Lower/OpenACC.cpp

if constexpr (std::is_same_v<R, int64_t>)
       return value;
   }
   llvm_unreachable("OpenACC reduction unsupported type");
 }
 
 static mlir::Value genReductionInitValue(fir::FirOpBuilder &builder,
                                          mlir::Location loc, mlir::Type ty,
                                          mlir::acc::ReductionOperator op) {
-  if (op != mlir::acc::ReductionOperator::AccAdd &&
-      op != mlir::acc::ReductionOperator::AccMul &&
-      op != mlir::acc::ReductionOperator::AccMin &&
-      op != mlir::acc::ReductionOperator::AccMax &&
-      op != mlir::acc::ReductionOperator::AccIand &&
-      op != mlir::acc::ReductionOperator::AccIor &&
-      op != mlir::acc::ReductionOperator::AccXor)
+  if (op == mlir::acc::ReductionOperator::AccLor &&
+      op == mlir::acc::ReductionOperator::AccEqv &&
+      op == mlir::acc::ReductionOperator::AccNeqv)
     TODO(loc, "reduction operator");
 
+  if (op == mlir::acc::ReductionOperator::AccLand) {
+    assert(mlir::isa<fir::LogicalType>(ty) && "expect fir.logical type");
+    return builder.createBool(loc, true);
+  }
+
   if (ty.isIntOrIndex())
     return builder.create<mlir::arith::ConstantOp>(
         loc, ty,
         builder.getIntegerAttr(ty, getReductionInitValue<llvm::APInt>(op, ty)));
   if (op == mlir::acc::ReductionOperator::AccMin ||
       op == mlir::acc::ReductionOperator::AccMax) {
     if (mlir::isa<fir::ComplexType>(ty))
       llvm::report_fatal_error(
           "min/max reduction not supported for complex type");
     if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty))
       return builder.create<mlir::arith::ConstantOp>(
           loc, ty,
           builder.getFloatAttr(ty,
                                getReductionInitValue<llvm::APFloat>(op, ty)));
   } else {
     if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty))
if (op == mlir::acc::ReductionOperator::AccIand)
     return builder.create<mlir::arith::AndIOp>(loc, value1, value2);
 
   if (op == mlir::acc::ReductionOperator::AccIor)
     return builder.create<mlir::arith::OrIOp>(loc, value1, value2);
 
   if (op == mlir::acc::ReductionOperator::AccXor)
     return builder.create<mlir::arith::XOrIOp>(loc, value1, value2);
 
+  if (op == mlir::acc::ReductionOperator::AccLand) {
+    mlir::Type i1 = builder.getI1Type();
+    mlir::Value v1 = builder.create<fir::ConvertOp>(loc, i1, value1);
+    mlir::Value v2 = builder.create<fir::ConvertOp>(loc, i1, value2);
+    mlir::Value add = builder.create<mlir::arith::AndIOp>(loc, v1, v2);
+    return builder.create<fir::ConvertOp>(loc, value1.getType(), add);
+  }
+
   TODO(loc, "reduction operator");
 }
 
 mlir::acc::ReductionRecipeOp Fortran::lower::createOrGetReductionRecipe(
     fir::FirOpBuilder &builder, llvm::StringRef recipeName, mlir::Location loc,
     mlir::Type ty, mlir::acc::ReductionOperator op) {
   mlir::ModuleOp mod =
       builder.getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();

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_land_l32 : !fir.logical<4> reduction_operator <land> init {
+! CHECK: ^bb0(%{{.*}}: !fir.logical<4>):
+! CHECK:   %[[CST:.*]] = arith.constant true
+! CHECK:   acc.yield %[[CST]] : i1
+! CHECK: } combiner {
+! CHECK: ^bb0(%[[ARG0:.*]]: !fir.logical<4>, %[[ARG1:.*]]: !fir.logical<4>):
+! CHECK:   %[[V1:.*]] = fir.convert %[[ARG0]] : (!fir.logical<4>) -> i1
+! CHECK:   %[[V2:.*]] = fir.convert %[[ARG1]] : (!fir.logical<4>) -> i1
+! CHECK:   %[[AND:.*]] = arith.andi %[[V1]], %[[V2]] : i1
+! CHECK:   %[[CONV:.*]] = fir.convert %[[AND]] : (i1) -> !fir.logical<4>
+! CHECK:   acc.yield %[[CONV]] : !fir.logical<4>
+! CHECK: }
+
 ! CHECK-LABEL: acc.reduction.recipe @reduction_xor_i32 : i32 reduction_operator <xor> init {
 ! CHECK: ^bb0(%{{.*}}: i32):
 ! CHECK:   %[[CST:.*]] = arith.constant 0 : i32
 ! CHECK:   acc.yield %[[CST]] : i32
 ! CHECK: } combiner {
 ! CHECK: ^bb0(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32):
 ! CHECK:   %[[COMBINED:.*]] = arith.xori %[[ARG0]], %[[ARG1]] : i32
 ! CHECK:   acc.yield %[[COMBINED]] : i32
subroutine acc_reduction_ieor()
   integer :: i
   !$acc parallel reduction(ieor:i)
   !$acc end parallel
 end subroutine
 
 ! CHECK-LABEL: func.func @_QPacc_reduction_ieor()
 ! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref<i32>) -> !fir.ref<i32> {name = "i"}
 ! CHECK: acc.parallel reduction(@reduction_xor_i32 -> %[[RED]] : !fir.ref<i32>)
+
+subroutine acc_reduction_and()
+  logical :: l
+  !$acc parallel reduction(.and.:l)
+  !$acc end parallel
+end subroutine
+
+! CHECK-LABEL: func.func @_QPacc_reduction_and()
+! CHECK: %[[RED:.*]] = acc.reduction varPtr(%0 : !fir.ref<!fir.logical<4>>) -> !fir.ref<!fir.logical<4>> {name = "l"}
+! CHECK: acc.parallel reduction(@reduction_land_l32 -> %[[RED]] : !fir.ref<!fir.logical<4>>)