[MLIR][TOSA] Drop "OnTensors" suffix

[GMNGeoffrey]

Summary

This is the only lowering to Linalg Tosa has, so it's needlessly
verbose. Likely this was a carry over from IREE's usage where we
originally lowered to linalg on buffers (the only linalg that existed at
the time), so the everything on tensors needed the suffix. We're dropping
it in IREE also, having transitioned entirely to using Linalg on
tensors.

mlir/include/mlir/Conversion/Passes.td

Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToLinalg
 //===----------------------------------------------------------------------===//
 
-def TosaToLinalgOnTensors : FunctionPass<"tosa-to-linalg-on-tensors"> {
+def TosaToLinalg : FunctionPass<"tosa-to-linalg"> {
   let summary = "Lower TOSA to LinAlg on tensors";
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     tensor operations in LinAlg.
   }];
 
-  let constructor = "tosa::createTosaToLinalgOnTensors()";
+  let constructor = "tosa::createTosaToLinalg()";
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToSCF
 //===----------------------------------------------------------------------===//
 
 def TosaToSCF : Pass<"tosa-to-scf"> {
   let summary = "Lower TOSA to the SCF dialect";

mlir/include/mlir/Conversion/TosaToLinalg/TosaToLinalg.h

 #ifndef MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H
 #define MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace tosa {
 
-std::unique_ptr<Pass> createTosaToLinalgOnTensors();
+std::unique_ptr<Pass> createTosaToLinalg();
 
 /// Populates passes to convert from TOSA to Linalg on buffers. At the end of
 /// the pass, the function will only contain linalg ops or standard ops if the
 /// pipeline succeeds.
-void addTosaToLinalgOnTensorsPasses(OpPassManager &pm);
+void addTosaToLinalgPasses(OpPassManager &pm);
 
 /// Populates conversion passes from TOSA dialect to Linalg dialect.
-void populateTosaToLinalgOnTensorsConversionPatterns(
-    RewritePatternSet *patterns);
+void populateTosaToLinalgConversionPatterns(RewritePatternSet *patterns);
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

LogicalResult matchAndRewrite(tosa::AvgPool2dOp op,
 
     rewriter.replaceOp(op, genericOp.getResult(0));
     return success();
   }
 };
 
 } // namespace
 
-void mlir::tosa::populateTosaToLinalgOnTensorsConversionPatterns(
+void mlir::tosa::populateTosaToLinalgConversionPatterns(
     RewritePatternSet *patterns) {
   patterns->add<
       // clang-format off
       PointwiseConverter<tosa::AddOp>,
       PointwiseConverter<tosa::SubOp>,
       PointwiseConverter<tosa::MulOp>,
       PointwiseConverter<tosa::DivOp>,
       PointwiseConverter<tosa::NegateOp>,

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgPass.cpp

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
-struct TosaToLinalgOnTensors
-    : public TosaToLinalgOnTensorsBase<TosaToLinalgOnTensors> {
+struct TosaToLinalg : public TosaToLinalgBase<TosaToLinalg> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, linalg::LinalgDialect,
                     math::MathDialect, StandardOpsDialect,
                     tensor::TensorDialect, scf::SCFDialect>();
   }
 
   void runOnFunction() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addLegalDialect<linalg::LinalgDialect, StandardOpsDialect,
                            tensor::TensorDialect, scf::SCFDialect>();
     target.addIllegalDialect<tosa::TosaDialect>();
 
     // Not every TOSA op can be legalized to linalg.
     target.addLegalOp<tosa::ApplyScaleOp>();
     target.addLegalOp<tosa::IfOp>();
     target.addLegalOp<tosa::ConstOp>();
     target.addLegalOp<tosa::WhileOp>();
 
     target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
 
     FuncOp func = getFunction();
-    mlir::tosa::populateTosaToLinalgOnTensorsConversionPatterns(&patterns);
+    mlir::tosa::populateTosaToLinalgConversionPatterns(&patterns);
     if (failed(applyFullConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<Pass> mlir::tosa::createTosaToLinalgOnTensors() {
-  return std::make_unique<TosaToLinalgOnTensors>();
+std::unique_ptr<Pass> mlir::tosa::createTosaToLinalg() {
+  return std::make_unique<TosaToLinalg>();
 }
 
-void mlir::tosa::addTosaToLinalgOnTensorsPasses(OpPassManager &pm) {
+void mlir::tosa::addTosaToLinalgPasses(OpPassManager &pm) {
   pm.addNestedPass<FuncOp>(createTosaMakeBroadcastablePass());
-  pm.addNestedPass<FuncOp>(createTosaToLinalgOnTensors());
+  pm.addNestedPass<FuncOp>(createTosaToLinalg());
 }

mlir/test/Conversion/TosaToLinalg/tosa-to-linalg.mlir

-// RUN: mlir-opt --split-input-file --tosa-to-linalg-on-tensors %s -verify-diagnostics -o -| FileCheck %s
+// RUN: mlir-opt --split-input-file --tosa-to-linalg %s -verify-diagnostics -o -| FileCheck %s
 
 // CHECK: #[[$MAP0:.*]] = affine_map<() -> ()>
 
 // CHECK-LABEL: @test_abs
 func @test_abs(%arg0: tensor<f32>) -> tensor<f32> {
   // CHECK: [[INIT:%.+]] = linalg.init_tensor [] : tensor<f32>
   // CHECK: [[GENERIC:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP0]]], iterator_types = []} ins(%arg0 : tensor<f32>) outs([[INIT]] : tensor<f32>) {
   // CHECK: ^bb0(%arg1: f32, %arg2: f32):