[flang][openacc] Support iand reduction operator

[clementval]

Summary

Add support for iand reduction operator in
OpenACC lowering.

[razvanlupusoru]

Looks great!

flang/lib/Lower/OpenACC.cpp

if constexpr (std::is_same_v<R, llvm::APInt>) {
       return llvm::APInt::getSignedMinValue(ty.getIntOrFloatBitWidth());
     }
     if constexpr (std::is_same_v<R, llvm::APFloat>) {
       auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty);
       assert(floatTy && "expect float type");
       return llvm::APFloat::getSmallest(floatTy.getFloatSemantics(),
                                         /*negative=*/true);
     }
+  } else if (op == mlir::acc::ReductionOperator::AccIand) {
+    if constexpr (std::is_same_v<R, llvm::APInt>) {
+      assert(ty.isIntOrIndex() && "expect integer type");
+      unsigned bits = ty.getIntOrFloatBitWidth();
+      return llvm::APInt::getAllOnes(bits);
+    }
   } else {
     // +, ior, ieor init value -> 0
     // * init value -> 1
     int64_t value = (op == mlir::acc::ReductionOperator::AccMul) ? 1 : 0;
     if constexpr (std::is_same_v<R, llvm::APInt>) {
       assert(ty.isIntOrIndex() && "expect integer or index type");
       return llvm::APInt(ty.getIntOrFloatBitWidth(), value, true);
     }

 }
 
 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::AccMax &&
+      op != mlir::acc::ReductionOperator::AccIand)
     TODO(loc, "reduction operator");
 
   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) {
static mlir::Value genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
   }
 
   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});
 
+  if (op == mlir::acc::ReductionOperator::AccIand)
+    return builder.create<mlir::arith::AndIOp>(loc, value1, value2);
+
   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_iand_i32 : i32 reduction_operator <iand> init {
+! CHECK: ^bb0(%{{.*}}: i32):
+! CHECK:   %[[CST:.*]] = arith.constant -1 : i32
+! CHECK:   acc.yield %[[CST]] : i32
+! CHECK: } combiner {
+! CHECK: ^bb0(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32):
+! CHECK:   %[[COMBINED:.*]] = arith.andi %[[ARG0]], %[[ARG1]] : i32
+! CHECK:   acc.yield %[[COMBINED]] : i32
+! CHECK: }
+
 ! CHECK-LABEL: acc.reduction.recipe @reduction_max_ref_100xf32 : !fir.ref<!fir.array<100xf32>> reduction_operator <max> init {
 ! CHECK: ^bb0(%{{.*}}: !fir.ref<!fir.array<100xf32>>):
 ! CHECK:   %[[CST:.*]] = arith.constant dense<-1.401300e-45> : vector<100xf32>
 ! CHECK:   acc.yield %[[CST]] : vector<100xf32>
 ! CHECK: } combiner {
 ! CHECK: ^bb0(%[[ARG0:.*]]: !fir.ref<!fir.array<100xf32>>, %[[ARG1:.*]]: !fir.ref<!fir.array<100xf32>>):
 ! CHECK:   %[[LB0:.*]] = arith.constant 0 : index
 ! CHECK:   %[[UB0:.*]] = arith.constant 99 : index
subroutine acc_reduction_max_float_array1d(a, b)
   end do
 end subroutine
 
 ! CHECK-LABEL: func.func @_QPacc_reduction_max_float_array1d(
 ! CHECK-SAME:  %{{.*}}: !fir.ref<!fir.array<100xf32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<!fir.array<100xf32>> {fir.bindc_name = "b"})
 ! CHECK:       %[[RED_ARG1:.*]] = acc.reduction varPtr(%[[ARG1]] : !fir.ref<!fir.array<100xf32>>) bounds(%{{.*}}) -> !fir.ref<!fir.array<100xf32>> {name = "b"} 
 ! CHECK:       acc.loop reduction(@reduction_max_ref_100xf32 -> %[[RED_ARG1]] : !fir.ref<!fir.array<100xf32>>) {
 
+subroutine acc_reduction_iand()
+  integer :: i
+  !$acc parallel reduction(iand:i)
+  !$acc end parallel
+end subroutine
+
+! CHECK-LABEL: func.func @_QPacc_reduction_iand()
+! CHECK: %[[RED:.*]] = acc.reduction varPtr(%{{.*}} : !fir.ref<i32>)   -> !fir.ref<i32> {name = "i"}
+! CHECK: acc.parallel   reduction(@reduction_iand_i32 -> %[[RED]] : !fir.ref<i32>)