Inline createIntOrIndexConstant

Author: htyu

mlir/include/mlir/Dialect/Arith/Utils/Utils.h

@@ -94,11 +94,6 @@ Value createScalarOrSplatConstant(OpBuilder &builder, Location loc, Type type,
 Value createScalarOrSplatConstant(OpBuilder &builder, Location loc, Type type,
                                   const APFloat &value);
 
-/// Create a constant of type `type` at location `loc` whose value is `value`.
-/// This works for integer type or the index type only.
-Value createIntOrIndexConstant(OpBuilder &builder, Location loc, Type type,
-                               int64_t value);
-
 /// Returns the int type of the integer in ofr.
 /// Other attribute types are not supported.
 Type getType(OpFoldResult ofr);

mlir/lib/Dialect/Arith/Utils/Utils.cpp

@@ -302,13 +302,6 @@ Value mlir::createScalarOrSplatConstant(OpBuilder &builder, Location loc,
   return builder.createOrFold<arith::ConstantOp>(loc, type, splat);
 }
 
-Value mlir::createIntOrIndexConstant(OpBuilder &b, Location loc, Type type,
-                                     int64_t value) {
-  assert(type.isIntOrIndex() &&
-         "unexpected type other than integers and index");
-  return b.create<arith::ConstantOp>(loc, b.getIntegerAttr(type, value));
-}
-
 Type mlir::getType(OpFoldResult ofr) {
   if (auto value = dyn_cast_if_present<Value>(ofr))
     return value.getType();

mlir/lib/Dialect/SCF/Utils/Utils.cpp

@@ -267,10 +267,10 @@ static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,
   assert(dividend.getType().isIntOrIndex() &&
          "expected integer or index-typed value");
 
-  Value divisorMinusOneCst =
-      createIntOrIndexConstant(builder, loc, dividend.getType(), divisor - 1);
-  Value divisorCst =
-      createIntOrIndexConstant(builder, loc, dividend.getType(), divisor);
+  Value divisorMinusOneCst = builder.create<arith::ConstantOp>(
+      loc, builder.getIntegerAttr(dividend.getType(), divisor - 1));
+  Value divisorCst = builder.create<arith::ConstantOp>(
+      loc, builder.getIntegerAttr(dividend.getType(), divisor));
   Value sum = builder.create<arith::AddIOp>(loc, dividend, divisorMinusOneCst);
   return builder.create<arith::DivUIOp>(loc, sum, divisorCst);
 }
@@ -283,7 +283,8 @@ static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,
                              Value divisor) {
   assert(dividend.getType().isIntOrIndex() &&
          "expected integer or index-typed value");
-  Value cstOne = createIntOrIndexConstant(builder, loc, dividend.getType(), 1);
+  Value cstOne = builder.create<arith::ConstantOp>(
+      loc, builder.getOneAttr(dividend.getType()));
   Value divisorMinusOne = builder.create<arith::SubIOp>(loc, divisor, cstOne);
   Value sum = builder.create<arith::AddIOp>(loc, dividend, divisorMinusOne);
   return builder.create<arith::DivUIOp>(loc, sum, divisor);
@@ -390,18 +391,18 @@ LogicalResult mlir::loopUnrollByFactor(
     // Create constant for 'upperBoundUnrolled' and set epilogue loop flag.
     generateEpilogueLoop = upperBoundUnrolledCst < ubCst;
     if (generateEpilogueLoop)
-      upperBoundUnrolled = createIntOrIndexConstant(
-          boundsBuilder, loc, forOp.getUpperBound().getType(),
-          upperBoundUnrolledCst);
+      upperBoundUnrolled = boundsBuilder.create<arith::ConstantOp>(
+          loc, boundsBuilder.getIntegerAttr(forOp.getUpperBound().getType(),
+                                            upperBoundUnrolledCst));
     else
       upperBoundUnrolled = forOp.getUpperBound();
 
     // Create constant for 'stepUnrolled'.
-    stepUnrolled =
-        stepCst == stepUnrolledCst
-            ? step
-            : createIntOrIndexConstant(boundsBuilder, loc, step.getType(),
-                                       stepUnrolledCst);
+    stepUnrolled = stepCst == stepUnrolledCst
+                       ? step
+                       : boundsBuilder.create<arith::ConstantOp>(
+                             loc, boundsBuilder.getIntegerAttr(
+                                      step.getType(), stepUnrolledCst));
   } else {
     // Dynamic loop bounds computation.
     // TODO: Add dynamic asserts for negative lb/ub/step, or
@@ -411,8 +412,8 @@ LogicalResult mlir::loopUnrollByFactor(
     Value diff =
         boundsBuilder.create<arith::SubIOp>(loc, upperBound, lowerBound);
     Value tripCount = ceilDivPositive(boundsBuilder, loc, diff, step);
-    Value unrollFactorCst = createIntOrIndexConstant(
-        boundsBuilder, loc, tripCount.getType(), unrollFactor);
+    Value unrollFactorCst = boundsBuilder.create<arith::ConstantOp>(
+        loc, boundsBuilder.getIntegerAttr(tripCount.getType(), unrollFactor));
     Value tripCountRem =
         boundsBuilder.create<arith::RemSIOp>(loc, tripCount, unrollFactorCst);
     // Compute tripCountEvenMultiple = tripCount - (tripCount % unrollFactor)
@@ -459,7 +460,9 @@ LogicalResult mlir::loopUnrollByFactor(
       [&](unsigned i, Value iv, OpBuilder b) {
         // iv' = iv + step * i;
         auto stride = b.create<arith::MulIOp>(
-            loc, step, createIntOrIndexConstant(b, loc, iv.getType(), i));
+            loc, step,
+            b.create<arith::ConstantOp>(loc,
+                                        b.getIntegerAttr(iv.getType(), i)));
         return b.create<arith::AddIOp>(loc, iv, stride);
       },
       annotateFn, iterArgs, yieldedValues);