[MLIR] : Add integer mul in scf to openmp conversion

[kiranchandramohan]

Summary

Add conversion for integer multiplication in scf reductions in the
SCF to OpenMP dialect conversion.

[kiranchandramohan]

Fixes one of the issues in https://github.com/llvm/llvm-project/issues/61342.

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

static omp::ReductionDeclareOp declareReduction(PatternRewriter &builder,
 
   // Match simple binary reductions that cannot be expressed with atomicrmw.
   // TODO: add atomic region using cmpxchg (which needs atomic load to be
   // available as an op).
   if (matchSimpleReduction<arith::MulFOp, LLVM::FMulOp>(reduction)) {
     return createDecl(builder, symbolTable, reduce,
                       builder.getFloatAttr(type, 1.0));
   }
+  if (matchSimpleReduction<arith::MulIOp, LLVM::MulOp>(reduction)) {
+    return createDecl(builder, symbolTable, reduce,
+                      builder.getIntegerAttr(type, 1));
+  }
 
   // Match select-based min/max reductions.
   bool isMin;
   if (matchSelectReduction<arith::CmpFOp, arith::SelectOp>(
           reduction, {arith::CmpFPredicate::OLT, arith::CmpFPredicate::OLE},
           {arith::CmpFPredicate::OGT, arith::CmpFPredicate::OGE}, isMin) ||
       matchSelectReduction<LLVM::FCmpOp, LLVM::SelectOp>(
           reduction, {LLVM::FCmpPredicate::olt, LLVM::FCmpPredicate::ole},

mlir/test/Conversion/SCFToOpenMP/reductions.mlir

^bb0(%lhs : f32, %rhs: f32):
       scf.reduce.return %res : f32
     }
   }
   return
 }
 
 // -----
 
+// Check the generation of declaration for arith.muli.
+// Mostly, the same check as above, except for the types,
+// the name of the op and the init value.
+
+// CHECK: omp.reduction.declare @[[$REDI:.*]] : i32
+
+// CHECK: init
+// CHECK: %[[INIT:.*]] = llvm.mlir.constant(1 : i32)
+// CHECK: omp.yield(%[[INIT]] : i32)
+
+// CHECK: combiner
+// CHECK: ^{{.*}}(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32)
+// CHECK: %[[RES:.*]] = arith.muli %[[ARG0]], %[[ARG1]]
+// CHECK: omp.yield(%[[RES]] : i32)
+
+// CHECK-NOT: atomic
+
+// CHECK-LABEL: @reduction_muli
+func.func @reduction_muli(%arg0 : index, %arg1 : index, %arg2 : index,
+                 %arg3 : index, %arg4 : index) {
+  %step = arith.constant 1 : index
+  %one = arith.constant 1 : i32
+  scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
+                            step (%arg4, %step) init (%one) -> (i32) {
+    // CHECK: omp.reduction
+    %pow2 = arith.constant 2 : i32
+    scf.reduce(%pow2) : i32 {
+    ^bb0(%lhs : i32, %rhs: i32):
+      %res = arith.muli %lhs, %rhs : i32
+      scf.reduce.return %res : i32
+    }
+  }
+  return
+}
+
+// -----
+
 // Only check the declaration here, the rest is same as above.
 // CHECK: omp.reduction.declare @{{.*}} : f32
 
 // CHECK: init
 // CHECK: %[[INIT:.*]] = llvm.mlir.constant(-3.4
 // CHECK: omp.yield(%[[INIT]] : f32)
 
 // CHECK: combiner