refactor interface

Author: Hardcode84

mlir/include/mlir/Dialect/Arith/IR/ArithOps.td

@@ -1687,7 +1687,7 @@ class BooleanConditionOrMatchingShape<string condition, string result> :
 def SelectOp : Arith_Op<"select", [Pure,
     AllTypesMatch<["true_value", "false_value", "result"]>,
     BooleanConditionOrMatchingShape<"condition", "result">,
-    DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRangesOrPoison"]>,
+    DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRangesFromOptional"]>,
     DeclareOpInterfaceMethods<SelectLikeOpInterface>]> {
   let summary = "select operation";
   let description = [{

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

@@ -843,7 +843,7 @@ def Vector_FromElementsOp : Vector_Op<"from_elements", [
 
 def Vector_InsertOp :
   Vector_Op<"insert", [Pure,
-     DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRangesOrPoison"]>,
+     DeclareOpInterfaceMethods<InferIntRangeInterface, ["inferResultRangesFromOptional"]>,
      PredOpTrait<"source operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      AllTypesMatch<["dest", "result"]>]> {

mlir/include/mlir/IR/Matchers.h

@@ -129,7 +129,7 @@ struct infer_int_range_op_binder {
       *bind_value = argRanges;
       matched = true;
     };
-    inferIntRangeOp.inferResultRangesOrPoison(argRanges, setResultRanges);
+    inferIntRangeOp.inferResultRangesFromOptional(argRanges, setResultRanges);
     return matched;
   }
 };

mlir/include/mlir/Interfaces/InferIntRangeInterface.h

@@ -199,12 +199,6 @@ void defaultInferResultRangesFromOptional(InferIntRangeInterface interface,
                                           ArrayRef<ConstantIntRanges> argRanges,
                                           SetIntRangeFn setResultRanges);
 
-/// Default implementation of `inferResultRangesOrPoison` which propagates
-/// poison and dispatches to the `inferResultRangesFromOptional`.
-void defaultInferResultRangesOrPoison(InferIntRangeInterface interface,
-                                      ArrayRef<IntegerValueRange> argRanges,
-                                      SetIntLatticeFn setResultRanges);
-
 } // end namespace intrange::detail
 } // end namespace mlir
 

mlir/include/mlir/Interfaces/InferIntRangeInterface.td

@@ -63,8 +63,9 @@ def InferIntRangeInterface : OpInterface<"InferIntRangeInterface"> {
       as an argument. When implemented, `setValueRange` should be called on
       all result values for the operation.
 
-      If any of the operands have poison ranges, they will be propagated to the
-      results automatically after the metdod returns.
+      Unlike `inferResultRanges` this method does not automatically propagate
+      poison from the inputs. This allows more precise poison semantics
+      control.
 
       This method allows for more precise implementations when operations
       want to reason about inputs which may be undefined during the analysis.
@@ -78,30 +79,6 @@ def InferIntRangeInterface : OpInterface<"InferIntRangeInterface"> {
       ::mlir::intrange::detail::defaultInferResultRanges($_op,
                                                          argRanges,
                                                          setResultRanges);
-    }]>,
-
-    InterfaceMethod<[{
-      Infer the bounds on the results of this op given the lattice representation
-      of the bounds for its arguments. For each result value or block argument
-      (that isn't a branch argument, since the dataflow analysis handles
-      those case), the method should call `setValueRange` with that `Value`
-      as an argument. When implemented, `setValueRange` should be called on
-      all result values for the operation.
-
-      Unlike `inferResultRanges`/`inferResultRangesFromOptional` this method
-      does not automatically propagate poison from the inputs. This allows more
-      precise poison semantics implementation.
-    }],
-    /*retTy=*/"void",
-    /*methodName=*/"inferResultRangesOrPoison",
-    /*args=*/(ins "::llvm::ArrayRef<::mlir::IntegerValueRange>":$argRanges,
-                  "::mlir::SetIntLatticeFn":$setResultRanges),
-    /*methodBody=*/"",
-    /*defaultImplementation=*/[{
-      ::mlir::intrange::detail::defaultInferResultRangesOrPoison(
-        $_op,
-        argRanges,
-        setResultRanges);
     }]>
   ];
 }

mlir/lib/Analysis/DataFlow/IntegerRangeAnalysis.cpp

@@ -133,7 +133,7 @@ LogicalResult IntegerRangeAnalysis::visitOperation(
     propagateIfChanged(lattice, changed);
   };
 
-  inferrable.inferResultRangesOrPoison(argRanges, joinCallback);
+  inferrable.inferResultRangesFromOptional(argRanges, joinCallback);
   return success();
 }
 
@@ -176,7 +176,7 @@ void IntegerRangeAnalysis::visitNonControlFlowArguments(
       propagateIfChanged(lattice, changed);
     };
 
-    inferrable.inferResultRangesOrPoison(argRanges, joinCallback);
+    inferrable.inferResultRangesFromOptional(argRanges, joinCallback);
     return;
   }
 

mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp

@@ -312,7 +312,7 @@ void arith::CmpIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
 // SelectOp
 //===----------------------------------------------------------------------===//
 
-void arith::SelectOp::inferResultRangesOrPoison(
+void arith::SelectOp::inferResultRangesFromOptional(
     ArrayRef<IntegerValueRange> argRanges, SetIntLatticeFn setResultRange) {
   std::optional<APInt> mbCondVal =
       argRanges[0].isUninitialized()

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

@@ -3211,7 +3211,7 @@ void ShuffleOp::getCanonicalizationPatterns(RewritePatternSet &results,
 // InsertOp
 //===----------------------------------------------------------------------===//
 
-void vector::InsertOp::inferResultRangesOrPoison(
+void vector::InsertOp::inferResultRangesFromOptional(
     ArrayRef<IntegerValueRange> argRanges, SetIntLatticeFn setResultRanges) {
   if (argRanges[0].isUninitialized() || argRanges[1].isUninitialized())
     return;

mlir/lib/Interfaces/InferIntRangeInterface.cpp

@@ -229,62 +229,42 @@ void mlir::intrange::detail::defaultInferResultRanges(
   llvm::SmallVector<ConstantIntRanges> unpacked;
   unpacked.reserve(argRanges.size());
 
-  for (const IntegerValueRange &range : argRanges) {
-    if (range.isUninitialized())
-      return;
-    unpacked.push_back(range.getValue());
-  }
-
-  interface.inferResultRanges(
-      unpacked,
-      [&setResultRanges](Value value, const ConstantIntRanges &argRanges) {
-        setResultRanges(value, IntegerValueRange{argRanges});
-      });
-}
-
-void mlir::intrange::detail::defaultInferResultRangesFromOptional(
-    InferIntRangeInterface interface, ArrayRef<ConstantIntRanges> argRanges,
-    SetIntRangeFn setResultRanges) {
-  auto ranges = llvm::to_vector_of<IntegerValueRange>(argRanges);
-  interface.inferResultRangesFromOptional(
-      ranges,
-      [&setResultRanges](Value value, const IntegerValueRange &argRanges) {
-        if (!argRanges.isUninitialized())
-          setResultRanges(value, argRanges.getValue());
-      });
-}
-
-void mlir::intrange::detail::defaultInferResultRangesOrPoison(
-    InferIntRangeInterface interface, ArrayRef<IntegerValueRange> argRanges,
-    SetIntLatticeFn setResultRanges) {
-
   bool signedPoison = false;
   bool unsignedPoison = false;
   for (const IntegerValueRange &range : argRanges) {
     if (range.isUninitialized())
-      continue;
+      return;
 
     const ConstantIntRanges &value = range.getValue();
+    unpacked.push_back(value);
     signedPoison = signedPoison || value.isSignedPoison();
     unsignedPoison = unsignedPoison || value.isUnsignedPoison();
   }
 
-  auto visitor = [&](Value value, const IntegerValueRange &range) {
-    if (range.isUninitialized())
-      return;
-
+  auto visitor = [&](Value value, const ConstantIntRanges &range) {
     if (!signedPoison && !unsignedPoison)
       return setResultRanges(value, range);
 
-    const ConstantIntRanges &origRange = range.getValue();
-    auto poison = ConstantIntRanges::poison(origRange.getBitWidth());
-    APInt umin = unsignedPoison ? poison.umin() : origRange.umin();
-    APInt umax = unsignedPoison ? poison.umax() : origRange.umax();
-    APInt smin = signedPoison ? poison.smin() : origRange.smin();
-    APInt smax = signedPoison ? poison.smax() : origRange.smax();
+    auto poison = ConstantIntRanges::poison(range.getBitWidth());
+    APInt umin = unsignedPoison ? poison.umin() : range.umin();
+    APInt umax = unsignedPoison ? poison.umax() : range.umax();
+    APInt smin = signedPoison ? poison.smin() : range.smin();
+    APInt smax = signedPoison ? poison.smax() : range.smax();
 
     setResultRanges(value, ConstantIntRanges(umin, umax, smin, smax));
   };
 
-  interface.inferResultRangesFromOptional(argRanges, visitor);
+  interface.inferResultRanges(unpacked, visitor);
+}
+
+void mlir::intrange::detail::defaultInferResultRangesFromOptional(
+    InferIntRangeInterface interface, ArrayRef<ConstantIntRanges> argRanges,
+    SetIntRangeFn setResultRanges) {
+  auto ranges = llvm::to_vector_of<IntegerValueRange>(argRanges);
+  interface.inferResultRangesFromOptional(
+      ranges,
+      [&setResultRanges](Value value, const IntegerValueRange &argRanges) {
+        if (!argRanges.isUninitialized())
+          setResultRanges(value, argRanges.getValue());
+      });
 }