[MLIR][Shape] Remove deprecated and unused lowerings

[frgossen]

Summary

This concerns from/to_extent_tensor, size_to_index, index_to_size, and
const_size conversion patterns. The new lowering will work directly on indices
and extent tensors. The shape and size values will allow for error values but
are not yet supported by the dialect conversion.

Depends On D84435

mlir/lib/Conversion/ShapeToStandard/CMakeLists.txt

-set(LLVM_TARGET_DEFINITIONS ShapeToStandardPatterns.td)
-mlir_tablegen(ShapeToStandardPatterns.inc -gen-rewriters)
-add_public_tablegen_target(ShapeToStandardPatternsIncGen)
-
 add_mlir_conversion_library(MLIRShapeToStandard
   ShapeToStandard.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/ShapeToStandard
 
   DEPENDS
   MLIRConversionPassIncGen
-  ShapeToStandardPatternsIncGen
 
   LINK_COMPONENTS
   Core
 
   LINK_LIBS PUBLIC
   MLIREDSC
   MLIRIR
   MLIRShape
   MLIRPass
   MLIRSCF
   MLIRTransforms
   )

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 using namespace mlir::shape;
 
-namespace {
-/// Generated conversion patterns.
-#include "ShapeToStandardPatterns.inc"
-} // namespace
-
 /// Conversion patterns.
 namespace {
 class AnyOpConversion : public OpConversionPattern<AnyOp> {
 public:
   using OpConversionPattern<AnyOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(AnyOp op, ArrayRef<Value> operands,
LogicalResult ShapeOfOpConversion::matchAndRewrite(
   Value staticExtentTensor =
       rewriter.create<TensorFromElementsOp>(loc, dimValues);
   rewriter.replaceOpWithNewOp<TensorCastOp>(op, staticExtentTensor,
                                             op.getType());
   return success();
 }
 
 namespace {
-class ConstSizeOpConverter : public OpConversionPattern<ConstSizeOp> {
-public:
-  using OpConversionPattern<ConstSizeOp>::OpConversionPattern;
-
-  LogicalResult
-  matchAndRewrite(ConstSizeOp op, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const override;
-};
-} // namespace
-
-LogicalResult ConstSizeOpConverter::matchAndRewrite(
-    ConstSizeOp op, ArrayRef<Value> operands,
-    ConversionPatternRewriter &rewriter) const {
-  rewriter.replaceOpWithNewOp<ConstantIndexOp>(op, op.value().getSExtValue());
-  return success();
-}
-
-namespace {
 class GetExtentOpConverter : public OpConversionPattern<GetExtentOp> {
   using OpConversionPattern<GetExtentOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(GetExtentOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
void ConvertShapeToStandardPass::runOnOperation() {
   // Apply conversion.
   auto module = getOperation();
   if (failed(applyFullConversion(module, target, patterns)))
     signalPassFailure();
 }
 
 void mlir::populateShapeToStandardConversionPatterns(
     OwningRewritePatternList &patterns, MLIRContext *ctx) {
-  populateWithGenerated(ctx, &patterns);
   // clang-format off
   patterns.insert<
       AnyOpConversion,
       BinaryOpConversion<AddOp, AddIOp>,
       BinaryOpConversion<MulOp, MulIOp>,
-      ConstSizeOpConverter,
       GetExtentOpConverter,
       RankOpConverter,
       ShapeOfOpConversion>(ctx);
   // clang-format on
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertShapeToStandardPass() {
   return std::make_unique<ConvertShapeToStandardPass>();
 }

mlir/lib/Conversion/ShapeToStandard/ShapeToStandardPatterns.td

-include "mlir/Dialect/Shape/IR/ShapeOps.td"
-include "mlir/Dialect/StandardOps/IR/Ops.td"
-
-// Convert `from_extent_tensor` and `to_extent_tensor` to no-ops as shapes will
-// be represented as extent tensors.
-def FromExtentTensorOpConversion : Pat<
-    (Shape_FromExtentTensorOp $input),
-    (replaceWithValue $input)>;
-def ToExtentTensorOpConversion : Pat<
-    (Shape_ToExtentTensorOp $input),
-    (replaceWithValue $input)>;
-
-// Convert `index_to_size` and `size_to_index` to no-ops as sizes will be
-// represented as indices.
-def IndexToSizeOpConversion : Pat<
-    (Shape_IndexToSizeOp $arg),
-    (replaceWithValue $arg)>;
-def SizeToIndexOpConversion : Pat<
-    (Shape_SizeToIndexOp $arg),
-    (replaceWithValue $arg)>;

mlir/test/Conversion/ShapeToStandard/shape-to-standard.mlir

 // RUN: mlir-opt --split-input-file --convert-shape-to-std --verify-diagnostics %s | FileCheck %s
 
 // Convert `size` to `index` type.
 // CHECK-LABEL: @size_id
 // CHECK-SAME: (%[[SIZE:.*]]: index)
 func @size_id(%size : !shape.size) -> !shape.size {
   // CHECK: return %[[SIZE]] : index
   return %size : !shape.size
 }
 
 // -----
 
-// Lower `size_to_index` conversion to no-op.
-// CHECK-LABEL: @size_to_index
-// CHECK-SAME: (%[[SIZE:.*]]: index) -> index
-func @size_to_index(%size : !shape.size) -> index {
-  // CHECK-NEXT: return %[[SIZE]] : index
-  %index = shape.size_to_index %size
-  return %index : index
-}
-
-// -----
-
-// Lower `index_to_size` conversion to no-op.
-// CHECK-LABEL: @index_to_size
-// CHECK-SAME: (%[[INDEX:.*]]: index) -> index
-func @index_to_size(%index : index) -> !shape.size {
-  // CHECK-NEXT: return %[[INDEX]] : index
-  %size = shape.index_to_size %index
-  return %size : !shape.size
-}
-
-// -----
-
 // Convert `shape` to `tensor<?xindex>` type.
 // CHECK-LABEL: @shape_id
 // CHECK-SAME: (%[[SHAPE:.*]]: tensor<?xindex>)
 func @shape_id(%shape : !shape.shape) -> !shape.shape {
   // CHECK: return %[[SHAPE]] : tensor<?xindex>
   return %shape : !shape.shape
 }
 
 // -----
 
-// Lower `to_extent_tensor` operation to no-op.
-// CHECK-LABEL: @to_extent_tensor
-// CHECK-SAME: (%[[SHAPE:.*]]: tensor<?xindex>) -> tensor<?xindex>
-func @to_extent_tensor(%shape : !shape.shape) -> tensor<?xindex> {
-  // CHECK-NEXT: return %[[SHAPE]] : tensor<?xindex>
-  %tensor = "shape.to_extent_tensor"(%shape) : (!shape.shape) -> tensor<?xindex>
-  return %tensor : tensor<?xindex>
-}
-
-// -----
-
-// Lower `from_extent_tensor` operation to no-op.
-// CHECK-LABEL: @from_extent_tensor
-// CHECK-SAME: (%[[TENSOR:.*]]: tensor<?xindex>) -> tensor<?xindex>
-func @from_extent_tensor(%tensor : tensor<?xindex>) -> !shape.shape {
-  // CHECK-NEXT: return %[[TENSOR]] : tensor<?xindex>
-  %shape = "shape.from_extent_tensor"(%tensor)
-      : (tensor<?xindex>) -> !shape.shape
-  return %shape : !shape.shape
-}
-
-// -----
-
 // Lower binary ops.
 // CHECK-LABEL: @binary_ops
 // CHECK-SAME: (%[[LHS:.*]]: index, %[[RHS:.*]]: index)
 func @binary_ops(%lhs : !shape.size, %rhs : !shape.size) {
   %sum = "shape.add"(%lhs, %rhs) : (!shape.size, !shape.size) -> !shape.size
   // CHECK-NEXT: addi %[[LHS]], %[[RHS]] : index
   %product = shape.mul %lhs, %rhs
   // CHECK-NEXT: muli %[[LHS]], %[[RHS]] : index
   return
 }
 
 // -----
 
-// Convert `const_size` to `constant` op.
-// CHECK-LABEL: @size_const
-func @size_const() -> !shape.size {
-  %c1 = shape.const_size 1
-  return %c1 : !shape.size
-}
-// CHECK: %[[C1:.*]] = constant 1 : index
-// CHECK: return %[[C1]] : index
-// -----
-
 // Lower `shape_of` for statically shaped tensor.
 // CHECK-LABEL: @shape_of_stat
 // CHECK-SAME: (%[[ARG:.*]]: tensor<1x2x3xf32>)
 func @shape_of_stat(%arg : tensor<1x2x3xf32>) {
   // CHECK-DAG: %[[C1:.*]] = constant 1 : index
   // CHECK-DAG: %[[C2:.*]] = constant 2 : index
   // CHECK-DAG: %[[C3:.*]] = constant 3 : index
   // CHECK-DAG: %[[SHAPE_UNCASTED:.*]] = tensor_from_elements(%[[C1]], %[[C2]], %[[C3]]) : tensor<3xindex>