[tosa] Add option to disable tosa.apply_scale lowering in TosaToStandard

[rsuderman]

Summary

Apply scale should be optionally disabled when lowering via TosaToStandard.
In most cases it should persist until the lowering to specific backend.

[jpienaar]

mlir/include/mlir/Conversion/Passes.td

781

s/standard/arith/? Or are there other ones along? (I was mentioning to Mehdi I don't know how to rename the ShapeToStandard pass with Standard exploding :)) [you can also defer if this is multiple dialects being lowered to]

mlir/lib/Conversion/TosaToStandard/TosaToStandardPass.cpp

41

Could we add a comment somewhere in code (perhaps in pass description so that it makes it into the generated docs) as to the why.

mlir/test/Conversion/TosaToArith/tosa-to-arith.mlir

1–2

Test with it false? (don't have to repeat all CHECK's, just a spot check)

[rsuderman]

Split TosaToStandard split to TosaToArith and TosaToTensor

[rsuderman]

Added the additional comments in.

[rsuderman]

mlir/include/mlir/Conversion/Passes.td

781

I split everything between TosaToArith and TosaToTensor as each defines a different party of the work.

mlir/lib/Conversion/TosaToStandard/TosaToStandardPass.cpp

41

Added details to the Passes.td file for while the ApplyScale is optionally included.

[jpienaar]

mlir/include/mlir/Conversion/Passes.td

714

Up to you, but I'd just drop ops and have everything on one line (or drop tosa. as this is a tosa-to-arith pass so the dialect is implicit for me)

mlir/include/mlir/Conversion/TosaToArith/TosaToArith.h

21

This and addTosaToArithPasses seem to overlap quite a bit, when would one use one vs the other?

mlir/include/mlir/Conversion/TosaToTensor/TosaToTensor.h

1

optimization pass? TOSA to Tensor legalization pass ?

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

2

Tensor

10

Tensor

mlir/lib/Conversion/TosaToTensor/TosaToTensorPass.cpp

1

Tensor

mlir/test/Conversion/TosaToTensor/tosa-to-tensor.mlir

2

verify-diagnostics doesn't seem needed here

[rsuderman]

Updated for cleanup comments.

mlir/include/mlir/Conversion/Passes.h

 #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
 #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
 #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
 #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
 #include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h"
+#include "mlir/Conversion/TosaToArith/TosaToArith.h"
 #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
 #include "mlir/Conversion/TosaToSCF/TosaToSCF.h"
-#include "mlir/Conversion/TosaToStandard/TosaToStandard.h"
+#include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
 #include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Conversion/VectorToROCDL/VectorToROCDL.h"
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 #include "mlir/Conversion/VectorToSPIRV/VectorToSPIRVPass.h"
 
 namespace mlir {
 
 /// Generate the code for registering conversion passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Conversion/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_PASSES_H

mlir/include/mlir/Conversion/Passes.td

let options = [
     Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "bool", /*default=*/"true",
            "Emulate non-32-bit scalar types with 32-bit ones if "
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
+// TosaToArith
+//===----------------------------------------------------------------------===//
+
+def TosaToArith : Pass<"tosa-to-arith"> {
+  let summary = "Lower TOSA to the Arith dialect";
+  let dependentDialects = [
+    "arith::ArithmeticDialect",
+  ];
+  let description = [{
+    Pass that converts TOSA operations to the equivalent operations using the
+    operations in the Arith dialect. The ApplyScale operator is optionally
+    included as it is often preserved until the final invocation.
+  }];
+
+  let options = [
+    Option<"includeApplyRescale", "include-apply-rescale",
+           "bool", /*default=*/"false",
+           "Whether to include the lowering for tosa.apply_rescale to arith">
+  ];
+
+  let constructor = "tosa::createTosaToArith()";
+}
+
+//===----------------------------------------------------------------------===//
 // TosaToLinalg
 //===----------------------------------------------------------------------===//
 
 def TosaToLinalg
     : InterfacePass<"tosa-to-linalg", "FunctionOpInterface"> {
   let summary = "Lower TOSA to LinAlg on tensors";
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
let description = [{
     Pass that converts TOSA's control flow operations to the equivalent SCF
     operations.
   }];
 
   let constructor = "tosa::createTosaToSCF()";
 }
 
 //===----------------------------------------------------------------------===//
-// TosaToStandard
+// TosaToTensor
 //===----------------------------------------------------------------------===//
 
-def TosaToStandard : Pass<"tosa-to-standard"> {
-  let summary = "Lower TOSA to the Standard dialect";
+def TosaToTensor : Pass<"tosa-to-tensor"> {
+  let summary = "Lower TOSA to the Tensor dialect";
   let dependentDialects = [
-    "arith::ArithmeticDialect",
     "tensor::TensorDialect",
   ];
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
-    operations in the Standard dialect.
+    operations in the Tensor dialect.
   }];
 
-  let constructor = "tosa::createTosaToStandard()";
+  let constructor = "tosa::createTosaToTensor()";
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToGPU
 //===----------------------------------------------------------------------===//
 
 def ConvertVectorToGPU : Pass<"convert-vector-to-gpu"> {
   let summary = "Lower the operations from the vector dialect into the GPU "
                 "dialect";
   let constructor = "mlir::createConvertVectorToGPUPass()";
   let dependentDialects = [

mlir/include/mlir/Conversion/TosaToArith/TosaToArith.h

+//===-- TosaToArith.h - TOSA optimization pass declarations --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the passes for the TOSA to Standard Dialect conversion.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CONVERSION_TOSATOARITH_TOSATOARITH_H
+#define MLIR_CONVERSION_TOSATOARITH_TOSATOARITH_H
+
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace tosa {
+
+std::unique_ptr<Pass> createTosaToArith();
+
+void populateTosaToArithConversionPatterns(RewritePatternSet *patterns);
+
+void populateTosaRescaleToArithConversionPatterns(RewritePatternSet *patterns);
+
+} // namespace tosa
+} // namespace mlir
+
+#endif // MLIR_CONVERSION_TOSATOARITH_TOSATOARITH_H

mlir/include/mlir/Conversion/TosaToTensor/TosaToTensor.h

-//===-- TosaToStandard.h - TOSA optimization pass declarations --*- C++ -*-===//
+//===-- TosaToTensor.h - TOSA to Tensor legalization ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the passes for the TOSA to Standard Dialect conversion.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_CONVERSION_TOSATOSTANDARD_TOSATOSTANDARD_H
-#define MLIR_CONVERSION_TOSATOSTANDARD_TOSATOSTANDARD_H
+#ifndef MLIR_CONVERSION_TOSATOTENSOR_TOSATOTENSOR_H
+#define MLIR_CONVERSION_TOSATOTENSOR_TOSATOTENSOR_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace tosa {
 
-std::unique_ptr<Pass> createTosaToStandard();
+std::unique_ptr<Pass> createTosaToTensor();
 
-void populateTosaToStandardConversionPatterns(RewritePatternSet *patterns);
-
-void populateTosaRescaleToStandardConversionPatterns(
-    RewritePatternSet *patterns);
-
-/// Populates passes to convert from TOSA to Standard.
-void addTosaToStandardPasses(OpPassManager &pm);
+void populateTosaToTensorConversionPatterns(RewritePatternSet *patterns);
 
 } // namespace tosa
 } // namespace mlir
 
-#endif // MLIR_CONVERSION_TOSATOSTANDARD_TOSATOSTANDARD_H
+#endif // MLIR_CONVERSION_TOSATOTENSOR_TOSATOTENSOR_H

mlir/lib/Conversion/CMakeLists.txt

 add_subdirectory(ReconcileUnrealizedCasts)
 add_subdirectory(SCFToControlFlow)
 add_subdirectory(SCFToGPU)
 add_subdirectory(SCFToOpenMP)
 add_subdirectory(SCFToSPIRV)
 add_subdirectory(ShapeToStandard)
 add_subdirectory(SPIRVToLLVM)
 add_subdirectory(TensorToSPIRV)
+add_subdirectory(TosaToArith)
 add_subdirectory(TosaToLinalg)
 add_subdirectory(TosaToSCF)
-add_subdirectory(TosaToStandard)
+add_subdirectory(TosaToTensor)
 add_subdirectory(VectorToROCDL)
 add_subdirectory(VectorToLLVM)
 add_subdirectory(VectorToGPU)
 add_subdirectory(VectorToSCF)
 add_subdirectory(VectorToSPIRV)

mlir/lib/Conversion/TosaToArith/CMakeLists.txt

-add_mlir_conversion_library(MLIRTosaToStandard
-  TosaToStandard.cpp
-  TosaToStandardPass.cpp
+add_mlir_conversion_library(MLIRTosaToArith
+  TosaToArith.cpp
+  TosaToArithPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
 
   DEPENDS
   MLIRConversionPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRArithmetic
   MLIRIR
   MLIRPass
   MLIRTosa
   MLIRTosaTransforms
   MLIRSupport
   )

mlir/lib/Conversion/TosaToArith/TosaToArith.cpp

-//===- TosaToStandard.cpp - Lowering Tosa to Standard Dialect -------------===//
+//===- TosaToArith.cpp - Lowering Tosa to Arith Dialect -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// These rewriters lower from the Tosa to the Standard dialect.
+// These rewriters lower from the Tosa to the Arith dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Conversion/TosaToStandard/TosaToStandard.h"
+#include "mlir/Conversion/TosaToArith/TosaToArith.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 using namespace tosa;
 
 namespace {
 
 class ConstOpConverter : public OpRewritePattern<tosa::ConstOp> {
 public:
   using OpRewritePattern<tosa::ConstOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(tosa::ConstOp op,
                                 PatternRewriter &rewriter) const final {
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(op, op.value());
     return success();
   }
 };
 
-class SliceOpConverter : public OpRewritePattern<tosa::SliceOp> {
-public:
-  using OpRewritePattern<tosa::SliceOp>::OpRewritePattern;
-
-  LogicalResult matchAndRewrite(tosa::SliceOp sliceOp,
-                                PatternRewriter &rewriter) const final {
-    Value input = sliceOp.input();
-    SmallVector<int64_t> strides;
-    strides.resize(sliceOp.getType().template cast<ShapedType>().getRank(), 1);
-
-    rewriter.replaceOpWithNewOp<tensor::ExtractSliceOp>(
-        sliceOp, sliceOp.getType(), input, ValueRange({}), ValueRange({}),
-        ValueRange({}), sliceOp.start(), sliceOp.size(),
-        rewriter.getI64ArrayAttr(strides));
-    return success();
-  }
-};
-
 Type matchContainerType(Type element, Type container) {
   if (auto shapedTy = container.dyn_cast<ShapedType>())
     return shapedTy.clone(element);
 
   return element;
 }
 
 Attribute getConstantAttr(Type type, int64_t value, PatternRewriter &rewriter) {
LogicalResult matchAndRewrite(tosa::ApplyScaleOp op,
 
     rewriter.replaceOp(op, result32);
     return success();
   }
 };
 
 } // namespace
 
-void mlir::tosa::populateTosaToStandardConversionPatterns(
+void mlir::tosa::populateTosaToArithConversionPatterns(
     RewritePatternSet *patterns) {
-  patterns->add<ApplyScaleOpConverter, ConstOpConverter, SliceOpConverter>(
-      patterns->getContext());
+  patterns->add<ConstOpConverter>(patterns->getContext());
 }
 
-void mlir::tosa::populateTosaRescaleToStandardConversionPatterns(
+void mlir::tosa::populateTosaRescaleToArithConversionPatterns(
     RewritePatternSet *patterns) {
   patterns->add<ApplyScaleOpConverter>(patterns->getContext());
 }

mlir/lib/Conversion/TosaToArith/TosaToArithPass.cpp

-//===- TosaToStandardPass.cpp - Lowering Tosa to Linalg Dialect -----------===//
+//===- TosaToArithPass.cpp - Lowering Tosa to Linalg Dialect -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This transformation pass legalizes Tosa operations to the Standard dialect.
+// This transformation pass legalizes Tosa operations to the Arith dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
-#include "mlir/Conversion/TosaToStandard/TosaToStandard.h"
+#include "mlir/Conversion/TosaToArith/TosaToArith.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 using namespace tosa;
 
 namespace {
-struct TosaToStandard : public TosaToStandardBase<TosaToStandard> {
+struct TosaToArith : public TosaToArithBase<TosaToArith> {
 public:
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addIllegalOp<tosa::ConstOp>();
-    target.addIllegalOp<tosa::SliceOp>();
-    target.addIllegalOp<tosa::ApplyScaleOp>();
     target.addLegalDialect<arith::ArithmeticDialect>();
-    target.addLegalDialect<tensor::TensorDialect>();
 
-    mlir::tosa::populateTosaToStandardConversionPatterns(&patterns);
+    mlir::tosa::populateTosaToArithConversionPatterns(&patterns);
+
+    if (this->includeApplyRescale) {
+      mlir::tosa::populateTosaRescaleToArithConversionPatterns(&patterns);
+      target.addIllegalOp<tosa::ApplyScaleOp>();
+    }
+
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<Pass> mlir::tosa::createTosaToStandard() {
-  return std::make_unique<TosaToStandard>();
-}
-
-void mlir::tosa::addTosaToStandardPasses(OpPassManager &pm) {
-  pm.addNestedPass<FuncOp>(createTosaToStandard());
+std::unique_ptr<Pass> mlir::tosa::createTosaToArith() {
+  return std::make_unique<TosaToArith>();
 }

mlir/lib/Conversion/TosaToTensor/CMakeLists.txt

-add_mlir_conversion_library(MLIRTosaToStandard
-  TosaToStandard.cpp
-  TosaToStandardPass.cpp
+add_mlir_conversion_library(MLIRTosaToTensor
+  TosaToTensor.cpp
+  TosaToTensorPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Tosa
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
 
   DEPENDS
   MLIRConversionPassIncGen
 
   LINK_LIBS PUBLIC
-  MLIRArithmetic
+  MLIRTensor
   MLIRIR
   MLIRPass
   MLIRTosa
   MLIRTosaTransforms
   MLIRSupport
   )

mlir/lib/Conversion/TosaToTensor/TosaToTensor.cpp

+//===- TosaToTensor.cpp - Lowering Tosa to Tensor Dialect -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// These rewriters lower from the Tosa to the Tensor dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
+#include "mlir/Dialect/Tensor/IR/Tensor.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+
+using namespace mlir;
+using namespace tosa;
+
+namespace {
+
+class SliceOpConverter : public OpRewritePattern<tosa::SliceOp> {
+public:
+  using OpRewritePattern<tosa::SliceOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(tosa::SliceOp sliceOp,
+                                PatternRewriter &rewriter) const final {
+    Value input = sliceOp.input();
+    SmallVector<int64_t> strides;
+    strides.resize(sliceOp.getType().template cast<ShapedType>().getRank(), 1);
+
+    rewriter.replaceOpWithNewOp<tensor::ExtractSliceOp>(
+        sliceOp, sliceOp.getType(), input, ValueRange({}), ValueRange({}),
+        ValueRange({}), sliceOp.start(), sliceOp.size(),
+        rewriter.getI64ArrayAttr(strides));
+    return success();
+  }
+};
+
+} // namespace
+
+void mlir::tosa::populateTosaToTensorConversionPatterns(
+    RewritePatternSet *patterns) {
+  patterns->add<SliceOpConverter>(patterns->getContext());
+}

mlir/lib/Conversion/TosaToTensor/TosaToTensorPass.cpp

-//===- TosaToStandardPass.cpp - Lowering Tosa to Linalg Dialect -----------===//
+//===- TosaToTensorPass.cpp - Lowering Tosa to Tensor Dialect -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This transformation pass legalizes Tosa operations to the Standard dialect.
+// This transformation pass legalizes Tosa operations to the Tensor dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
-#include "mlir/Conversion/TosaToStandard/TosaToStandard.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 using namespace tosa;
 
 namespace {
-struct TosaToStandard : public TosaToStandardBase<TosaToStandard> {
+struct TosaToTensor : public TosaToTensorBase<TosaToTensor> {
 public:
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
-    target.addIllegalOp<tosa::ConstOp>();
     target.addIllegalOp<tosa::SliceOp>();
-    target.addIllegalOp<tosa::ApplyScaleOp>();
-    target.addLegalDialect<arith::ArithmeticDialect>();
     target.addLegalDialect<tensor::TensorDialect>();
 
-    mlir::tosa::populateTosaToStandardConversionPatterns(&patterns);
+    mlir::tosa::populateTosaToTensorConversionPatterns(&patterns);
+
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<Pass> mlir::tosa::createTosaToStandard() {
-  return std::make_unique<TosaToStandard>();
-}
-
-void mlir::tosa::addTosaToStandardPasses(OpPassManager &pm) {
-  pm.addNestedPass<FuncOp>(createTosaToStandard());
+std::unique_ptr<Pass> mlir::tosa::createTosaToTensor() {
+  return std::make_unique<TosaToTensor>();
 }

mlir/test/Conversion/TosaToArith/tosa-to-arith.mlir

-// RUN: mlir-opt --split-input-file --tosa-to-standard %s -verify-diagnostics -o -| FileCheck %s
+// RUN: mlir-opt --split-input-file --tosa-to-arith="include-apply-rescale=true" %s -verify-diagnostics -o -| FileCheck %s
+// RUN: mlir-opt --split-input-file --tosa-to-arith="include-apply-rescale=false" %s -verify-diagnostics -o -| FileCheck --check-prefix="SCALE" %s
 
 // CHECK-LABEL: func @const_test
 func @const_test() -> (tensor<i32>) {
   // CHECK: [[C3:%.+]] = arith.constant dense<3> : tensor<i32>
   %0 = "tosa.const"() {value = dense<3> : tensor<i32>} : () -> tensor<i32>
 
   // CHECK: return [[C3]]
   return %0 : tensor<i32>
 }
 
 // -----
 
-func @slice(%arg0: tensor<6xf32>) ->() {
-  // CHECK: [[SLICE:%.+]] = tensor.extract_slice %arg0[2] [1] [1]
-  %0 = "tosa.slice"(%arg0) {start = [2], size = [1]} : (tensor<6xf32>)  -> (tensor<1xf32>)
-  return
-}
-
-// -----
-
 // CHECK-LABEL: @apply_scale_test_i32
 func @apply_scale_test_i32(%arg0 : i32, %arg1 : i32, %arg2 : i8) -> (i32) {
   // CHECK-DAG: [[C1_8:%.+]] = arith.constant 1 : i8
   // CHECK-DAG: [[C1_32:%.+]] = arith.constant 1 : i32
   // CHECK-DAG: [[C1_64:%.+]] = arith.constant 1 : i64
   // CHECK-DAG: [[SHIFT_MINUS_ONE_8:%.+]] = arith.subi %arg2, [[C1_8]]
 
   // CHECK-DAG: [[SHIFT_32:%.+]] = arith.extsi %arg2 : i8 to i32
func @apply_scale_test_i32(%arg0 : i32, %arg1 : i32, %arg2 : i8) -> (i32) {
   // CHECK-DAG: [[VAL_64:%.+]] = arith.extsi %arg0 : i32 to i64
   // CHECK-DAG: [[MULTIPLY_64:%.+]] = arith.extsi %arg1 : i32 to i64
   // CHECK-DAG: [[SHIFT_64:%.+]] = arith.extsi %arg2 : i8 to i64
   // CHECK-DAG: [[SCALED:%.+]] = arith.muli [[VAL_64]], [[MULTIPLY_64]]
   // CHECK-DAG: [[BIASED:%.+]] = arith.addi [[SCALED]], [[ROUND]]
   // CHECK-DAG: [[DOWNSHIFTED:%.+]] = arith.shrsi [[BIASED]], [[SHIFT_64]]
   // CHECK: [[TRUNCATED:%.+]] = arith.trunci [[DOWNSHIFTED]]
 
+  // SCALE: "tosa.apply_scale"
   %0 = "tosa.apply_scale"(%arg0, %arg1, %arg2) {double_round = true} : (i32, i32, i8) -> i32
   return %0 : i32
 }
 
 // -----
 
 // CHECK-LABEL: @apply_scale_test_vector
 func @apply_scale_test_vector(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>, %arg2 : vector<4xi8>) -> (vector<4xi32>) {

mlir/test/Conversion/TosaToTensor/tosa-to-tensor.mlir

+// RUN: mlir-opt --split-input-file --tosa-to-tensor %s -o -| FileCheck %s
+
+// CHECK-LABLE: func @slice
+func @slice(%arg0: tensor<6xf32>) ->() {
+  // CHECK: [[SLICE:%.+]] = tensor.extract_slice %arg0[2] [1] [1]
+  %0 = "tosa.slice"(%arg0) {start = [2], size = [1]} : (tensor<6xf32>)  -> (tensor<1xf32>)
+  return
+}

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

deps = [
         ":ReconcileUnrealizedCasts",
         ":SCFToGPUPass",
         ":SCFToOpenMP",
         ":SCFToSPIRV",
         ":SCFToStandard",
         ":SPIRVToLLVM",
         ":ShapeToStandard",
         ":TensorToSPIRV",
+        ":TosaToArith",
         ":TosaToLinalg",
         ":TosaToSCF",
-        ":TosaToStandard",
+        ":TosaToTensor",
         ":VectorToGPU",
         ":VectorToLLVM",
         ":VectorToROCDL",
         ":VectorToSCF",
         ":VectorToSPIRV",
     ],
 )
 
deps = [
         ":TosaInterfacesIncGen",
         ":TosaPassIncGen",
         ":TransformUtils",
         "//llvm:Support",
     ],
 )
 
 cc_library(
+    name = "TosaToArith",
+    srcs = glob([
+        "lib/Conversion/TosaToArith/*.cpp",
+        "lib/Conversion/TosaToArith/*.h",
+    ]) + [":ConversionPassDetail"],
+    hdrs = glob([
+        "include/mlir/Conversion/TosaToArith/*.h",
+    ]),
+    includes = [
+        "include",
+        "lib/Conversion/TosaToArith",
+    ],
+    deps = [
+        ":ArithmeticDialect",
+        ":ConversionPassIncGen",
+        ":FuncDialect",
+        ":IR",
+        ":Pass",
+        ":TosaDialect",
+        ":Transforms",
+    ],
+)
+
+cc_library(
     name = "TosaToLinalg",
     srcs = glob([
         "lib/Conversion/TosaToLinalg/*.cpp",
         "lib/Conversion/TosaToLinalg/*.h",
     ]) + [":ConversionPassDetail"],
     hdrs = glob([
         "include/mlir/Conversion/TosaToLinalg/*.h",
     ]),
deps = [
         ":SCFDialect",
         ":TensorDialect",
         ":TosaDialect",
         ":Transforms",
     ],
 )
 
 cc_library(
-    name = "TosaToStandard",
+    name = "TosaToTensor",
     srcs = glob([
-        "lib/Conversion/TosaToStandard/*.cpp",
-        "lib/Conversion/TosaToStandard/*.h",
+        "lib/Conversion/TosaToTensor/*.cpp",
+        "lib/Conversion/TosaToTensor/*.h",
     ]) + [":ConversionPassDetail"],
     hdrs = glob([
-        "include/mlir/Conversion/TosaToStandard/*.h",
+        "include/mlir/Conversion/TosaToTensor/*.h",
     ]),
     includes = [
         "include",
-        "lib/Conversion/TosaToStandard",
+        "lib/Conversion/TosaToTensor",
     ],
     deps = [
-        ":ArithmeticDialect",
         ":ConversionPassIncGen",
         ":FuncDialect",
         ":IR",
         ":Pass",
         ":TensorDialect",
         ":TosaDialect",
         ":Transforms",
     ],