[mlir][linalg] Remove RangeOp and RangeType.

[gysit]

Summary

Remove the RangeOp and the RangeType that are not actively used anymore. After removing RangeType, the LinalgTypes header only includes the generated dialect header.

mlir/docs/Dialects/Linalg/_index.md

 A set of ops that manipulate metadata but do not move memory. These ops take
 `view` operands + extra attributes and return new `view`s. The returned `view`s
 generally alias the operand `view`. At the moment the existing ops are:
 
 ```
 * `memref.view`,
 * `memref.subview`,
 * `memref.transpose`.
-* `linalg.range`,
 * `linalg.slice`,
 * `linalg.reshape`,
 ```
 
 Future ops are added on a per-need basis but should include:
 
 ```
 * `linalg.tile`,

mlir/include/mlir/Dialect/Linalg/IR/LinalgBase.td

let extraClassDeclaration = [{
     RegionBuilderFunType getRegionBuilder(StringRef name) {
       return namedStructuredOpRegionBuilders.lookup(name);
     }
     private:
       llvm::StringMap<RegionBuilderFunType> namedStructuredOpRegionBuilders;
   }];
 }
 
-// Whether a type is a RangeType.
-def LinalgIsRangeTypePred : CPred<"$_self.isa<RangeType>()">;
-def Range : DialectType<Linalg_Dialect, LinalgIsRangeTypePred, "range">;
-
 #endif // LINALG_BASE

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

OpBuilder<(ins "Type":$resultType, "Value":$source,
       CArg<"bool", "false">:$nofold,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
-def Linalg_RangeOp :
-    Linalg_Op<"range", [NoSideEffect]>,
-    Arguments<(ins Index:$min, Index:$max, Index:$step)>,
-    Results<(outs Range)> {
-  let summary = "Create a `range` type value, used to create `view`s";
-  let description = [{
-    The `linalg.range` op creates a `!linalg.range` from 3 values of type
-    `index` that represent the min, max and step values of the `range`. This
-    type does not pass function boundaries at the moment.
-
-    Example:
-
-    ```mlir
-    %3 = linalg.range %0:%1:%2 : !linalg.range
-    ````
-  }];
-  let builders = [
-    OpBuilder<(ins "Value":$min, "Value":$max, "Value":$step),
-    [{
-      auto rangeType = RangeType::get($_builder.getContext());
-      build($_builder, $_state, rangeType, min, max, step);
-    }]>];
-
-  // Fully specified by traits.
-  let verifier = ?;
-  let assemblyFormat = "$min `:` $max `:` $step attr-dict `:` type(results)";
-}
-
 def Linalg_YieldOp : Linalg_Op<"yield", [NoSideEffect, ReturnLike, Terminator]>,
     Arguments<(ins Variadic<AnyType>:$values)> {
   let summary = "Linalg yield operation";
   let description = [{
     `linalg.yield` is a special terminator operation for blocks inside regions
     in `linalg` generic ops. It returns values to the immediately enclosing
     `linalg` generic op.
 

mlir/include/mlir/Dialect/Linalg/IR/LinalgTypes.h

 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/StringMap.h"
 
 #include "mlir/Dialect/Linalg/IR/LinalgOpsDialect.h.inc"
 
-namespace mlir {
-class MLIRContext;
-
-namespace linalg {
-
-/// A RangeType represents a minimal range abstraction (min, max, step).
-/// It is constructed by calling the linalg.range op with three values index of
-/// index type:
-///
-/// ```mlir
-///    func @foo(%arg0 : index, %arg1 : index, %arg2 : index) {
-///      %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
-///    }
-/// ```
-class RangeType : public Type::TypeBase<RangeType, Type, TypeStorage> {
-public:
-  // Used for generic hooks in TypeBase.
-  using Base::Base;
-};
-
-} // namespace linalg
-} // namespace mlir
-
 #endif // MLIR_DIALECT_LINALG_LINALGTYPES_H_

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 using namespace mlir::linalg;
 
 template <typename T>
 static Type getPtrToElementType(T containerType, LLVMTypeConverter &lowering) {
   return LLVMPointerType::get(
       lowering.convertType(containerType.getElementType()));
 }
 
-/// Convert the given range descriptor type to the LLVMIR dialect.
-/// Range descriptor contains the range bounds and the step as 64-bit integers.
-///
-/// struct {
-///   int64_t min;
-///   int64_t max;
-///   int64_t step;
-/// };
-static Type convertRangeType(RangeType t, LLVMTypeConverter &converter) {
-  auto *context = t.getContext();
-  auto int64Ty = converter.convertType(IntegerType::get(context, 64));
-  return LLVMStructType::getLiteral(context, {int64Ty, int64Ty, int64Ty});
-}
-
 namespace {
-// RangeOp creates a new range descriptor.
-class RangeOpConversion : public ConvertOpToLLVMPattern<RangeOp> {
-public:
-  using ConvertOpToLLVMPattern<RangeOp>::ConvertOpToLLVMPattern;
-
-  LogicalResult
-  matchAndRewrite(RangeOp rangeOp, OpAdaptor adaptor,
-                  ConversionPatternRewriter &rewriter) const override {
-    auto rangeDescriptorTy = convertRangeType(
-        rangeOp.getType().cast<RangeType>(), *getTypeConverter());
-
-    ImplicitLocOpBuilder b(rangeOp->getLoc(), rewriter);
-
-    // Fill in an aggregate value of the descriptor.
-    Value desc = b.create<LLVM::UndefOp>(rangeDescriptorTy);
-    desc = b.create<LLVM::InsertValueOp>(desc, adaptor.min(),
-                                         rewriter.getI64ArrayAttr(0));
-    desc = b.create<LLVM::InsertValueOp>(desc, adaptor.max(),
-                                         rewriter.getI64ArrayAttr(1));
-    desc = b.create<LLVM::InsertValueOp>(desc, adaptor.step(),
-                                         rewriter.getI64ArrayAttr(2));
-    rewriter.replaceOp(rangeOp, desc);
-    return success();
-  }
-};
-
-
 // YieldOp produces and LLVM::ReturnOp.
 class YieldOpConversion : public ConvertOpToLLVMPattern<linalg::YieldOp> {
 public:
   using ConvertOpToLLVMPattern<linalg::YieldOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(linalg::YieldOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 /// Populate the given list with patterns that convert from Linalg to LLVM.
 void mlir::populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                   RewritePatternSet &patterns) {
-  patterns.add<RangeOpConversion, YieldOpConversion>(converter);
-
-  // Populate the type conversions for the linalg types.
-  converter.addConversion(
-      [&](RangeType type) { return convertRangeType(type, converter); });
+  patterns.add<YieldOpConversion>(converter);
 }
 
 namespace {
 struct ConvertLinalgToLLVMPass
     : public ConvertLinalgToLLVMBase<ConvertLinalgToLLVMPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertLinalgToLLVMPass::runOnOperation() {
   auto module = getOperation();
 
   // Convert to the LLVM IR dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   LLVMTypeConverter converter(&getContext());
   populateLinalgToLLVMConversionPatterns(converter, patterns);
   populateMemRefToLLVMConversionPatterns(converter, patterns);
 
   LLVMConversionTarget target(getContext());
-  target.addIllegalOp<RangeOp>();
   target.addLegalOp<ModuleOp>();
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertLinalgToLLVMPass() {
   return std::make_unique<ConvertLinalgToLLVMPass>();
 }

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

 } // namespace
 
 void ConvertLinalgToStandardPass::runOnOperation() {
   auto module = getOperation();
   ConversionTarget target(getContext());
   target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
                          memref::MemRefDialect, scf::SCFDialect,
                          StandardOpsDialect>();
-  target.addLegalOp<ModuleOp, FuncOp, ReturnOp, linalg::RangeOp>();
+  target.addLegalOp<ModuleOp, FuncOp, ReturnOp>();
   RewritePatternSet patterns(&getContext());
   populateLinalgToStandardConversionPatterns(patterns);
   if (failed(applyFullConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertLinalgToStandardPass() {
   return std::make_unique<ConvertLinalgToStandardPass>();
 }

mlir/lib/Dialect/Linalg/IR/LinalgTypes.cpp

 template <typename... OpTypes>
 void addNamedOpBuilders(
     llvm::StringMap<LinalgDialect::RegionBuilderFunType> &map) {
   (void)std::initializer_list<int>{0,
                                    (addNamedOpBuilderImpl<OpTypes>(map), 0)...};
 }
 
 void mlir::linalg::LinalgDialect::initialize() {
-  addTypes<RangeType>();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc"
       >();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
       >();
 
   // Fill the Linalg-specific OpName to RegionBuilder map.
   addNamedOpBuilders<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
       >(namedStructuredOpRegionBuilders);
 
   addInterfaces<LinalgInlinerInterface>();
 }
 
-Type mlir::linalg::LinalgDialect::parseType(DialectAsmParser &parser) const {
-  // Parse the main keyword for the type.
-  StringRef keyword;
-  if (parser.parseKeyword(&keyword))
-    return Type();
-  MLIRContext *context = getContext();
-
-  // Handle 'range' types.
-  if (keyword == "range")
-    return RangeType::get(context);
-
-  parser.emitError(parser.getNameLoc(), "unknown Linalg type: " + keyword);
-  return Type();
-}
-
-/// RangeType prints as just "range".
-static void print(RangeType rt, DialectAsmPrinter &os) { os << "range"; }
-
-void mlir::linalg::LinalgDialect::printType(Type type,
-                                            DialectAsmPrinter &os) const {
-  print(type.cast<RangeType>(), os);
-}
-
 LogicalResult LinalgDialect::verifyOperationAttribute(Operation *op,
                                                       NamedAttribute attr) {
   using comprehensive_bufferize::BufferizableOpInterface;
 
   if (attr.getName() == BufferizableOpInterface::kInplaceableAttrName) {
     if (!attr.getValue().isa<BoolAttr>()) {
       return op->emitError()
              << "'" << BufferizableOpInterface::kInplaceableAttrName

mlir/test/Dialect/Linalg/invalid.mlir

 // autogenerated op in the future, alleviating the issue.
 // func @conv_rank_limit(%arg0: memref<?xf32>, %arg1: memref<?xf32>, %arg2: memref<?xf32>) {
 //   // DISABLED_expected -error @+1 {{expects memref ranks to be greater than 2}}
 //   linalg.conv(%arg0, %arg1, %arg2) : memref<?xf32>, memref<?xf32>, memref<?xf32>
 // }
 //
 // // -----
 
-// expected-error @+1 {{unknown Linalg type}}
-!invalid_type = type !linalg.unknown
-
-// -----
-
-// expected-error @+1 {{expected valid keyword}}
-!invalid_type = type !linalg<"?">
-
-// -----
-
 func @named_ops(%a3: memref<?x?x?xf32>, %b3: memref<?x?xf32>, %c3: memref<?x?x?xf32>) {
   // expected-error @+1 {{expected operand rank (2) to match the result rank of indexing_map #1 (3)}}
   linalg.batch_matmul ins(%a3, %b3: memref<?x?x?xf32>, memref<?x?xf32>)
                      outs(%c3 : memref<?x?x?xf32>)
   return
 }
 
 // -----

mlir/test/Dialect/Linalg/llvm.mlir

-// RUN: mlir-opt %s -convert-linalg-to-llvm | FileCheck %s
-
-func @range(%arg0: index) {
-  %c0 = arith.constant 0 : index
-  %c1 = arith.constant 1 : index
-  %R = linalg.range %c0:%arg0:%c1 : !linalg.range
-  return
-}
-// CHECK-LABEL: func @range
-//       CHECK:   arith.constant 0 : index
-//       CHECK:   arith.constant 1 : index
-//       CHECK:   llvm.mlir.undef : !llvm.struct<(i64, i64, i64)>
-//       CHECK:   llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(i64, i64, i64)>
-//       CHECK:   llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(i64, i64, i64)>
-//       CHECK:   llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(i64, i64, i64)>

mlir/test/Dialect/Linalg/roundtrip.mlir

 //  CHECK-SAME: %[[UB1:[a-zA-Z0-9_]*]]
 //       CHECK:   linalg.pad_tensor %[[ARG0]]
 //  CHECK-SAME:     low[0, 0]
 //  CHECK-SAME:     high[%[[UB0]], %[[UB1]]]
 //       CHECK:    : tensor<?x?xf32> to tensor<2x3xf32>
 
 // -----
 
-func @range(%arg0: index, %arg1: index, %arg2: index) {
-  %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
-  return
-}
-// CHECK-LABEL: func @range(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
-//  CHECK-NEXT:  linalg.range %{{.*}} : %{{.*}} : %{{.*}} : !linalg.range
-
-// -----
-
-func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index) {
+func @views(%arg0: index) {
   %c0 = arith.constant 0 : index
   %0 = arith.muli %arg0, %arg0 : index
   %1 = memref.alloc (%0) : memref<?xi8>
-  %2 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
   %3 = memref.view %1[%c0][%arg0, %arg0] : memref<?xi8> to memref<?x?xf32>
   %4 = memref.view %1[%c0][%arg0, %arg0] : memref<?xi8> to memref<?x?xvector<4x4xf32>>
   memref.dealloc %1 : memref<?xi8>
   return
 }
 // CHECK-LABEL: func @views
 //  CHECK:  arith.muli %{{.*}}, %{{.*}} : index
 //  CHECK-NEXT:  memref.alloc(%{{.*}}) : memref<?xi8>
-//  CHECK-NEXT:  range
 //  CHECK-NEXT:  memref.view %{{.*}}[%{{.*}}][%{{.*}}] :
 //  CHECK-SAME:     memref<?xi8> to memref<?x?xf32>
 //  CHECK-NEXT:  memref.view %{{.*}}[%{{.*}}][%{{.*}}] :
 //  CHECK-SAME:     memref<?xi8> to memref<?x?xvector<4x4xf32>>
 //  CHECK-NEXT:  memref.dealloc %{{.*}} : memref<?xi8>
 
 // -----