[mlir][tosa] Use math.ctlz intrinsic for tosa.clz

[rsuderman]

Summary

We were custom counting per bit for the clz instruction. Math dialect
now has an intrinsic to do this in one instruction. Migrated to this
instruction and fixed a minor bug math-to-llvm for the intrinsic.

[rsuderman]

Removed the old implementation.

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

matchAndRewrite(MathOp op, typename MathOp::Adaptor adaptor,
     if (!vectorType)
       return failure();
 
     return LLVM::detail::handleMultidimensionalVectors(
         op.getOperation(), adaptor.getOperands(), *this->getTypeConverter(),
         [&](Type llvm1DVectorTy, ValueRange operands) {
           LLVM::ConstantOp zero =
               rewriter.create<LLVM::ConstantOp>(loc, boolType, boolZero);
-          return rewriter.replaceOpWithNewOp<LLVMOp>(op, llvm1DVectorTy,
-                                                     operands[0], zero);
+          return rewriter.create<LLVMOp>(loc, llvm1DVectorTy, operands[0],
+                                         zero);
         },
         rewriter);
   }
 };
 
 using CountLeadingZerosOpLowering =
     CountOpLowering<math::CountLeadingZerosOp, LLVM::CountLeadingZerosOp>;
 using CountTrailingZerosOpLowering =

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

auto shouldRound = rewriter.create<arith::AndIOp>(
         loc, i1Ty, shiftValueGreaterThanZero, isInputOdd);
     auto extended =
         rewriter.create<arith::ExtUIOp>(loc, resultTypes, shouldRound);
     return rewriter.create<arith::AddIOp>(loc, resultTypes, result, extended);
   }
 
   // tosa::ClzOp
   if (isa<tosa::ClzOp>(op) && elementTy.isa<IntegerType>()) {
+    return rewriter.create<math::CountLeadingZerosOp>(loc, elementTy, args[0]);
+    /*
     int bitWidth = elementTy.getIntOrFloatBitWidth();
     auto zero =
         rewriter.create<arith::ConstantOp>(loc, IntegerAttr::get(elementTy, 0));
     auto leadingZeros = rewriter.create<arith::ConstantOp>(
         loc, IntegerAttr::get(elementTy, bitWidth));
 
     SmallVector<Value> operands = {args[0], leadingZeros, zero};
     SmallVector<Type> types = {elementTy, elementTy, elementTy};
// The body of the while loop: shift right until reaching a value of 0.
 
       rewriter.create<scf::YieldOp>(
           loc,
           ValueRange({shifted, leadingZerosMinusOne, after->getArgument(2)}));
     }
 
     rewriter.setInsertionPointAfter(whileOp);
     return whileOp->getResult(1);
+    */
   }
 
   // tosa::LogicalAnd
   if (isa<tosa::LogicalAndOp>(op) && elementTy.isInteger(1))
     return rewriter.create<arith::AndIOp>(loc, resultTypes, args);
 
   // tosa::LogicalNot
   if (isa<tosa::LogicalNotOp>(op) && elementTy.isInteger(1)) {

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

func.func @test_simple_i32(%arg0: tensor<1xi32>) -> () {
   // CHECK: arith.shrsi
   // CHECK: arith.trunci
   // CHECK: and
   // CHECK: and
   // CHECK: arith.extui
   // CHECK: arith.addi
   %12 = "tosa.arithmetic_right_shift"(%arg0, %arg0) {round = 1 : i1} : (tensor<1xi32>, tensor<1xi32>) -> tensor<1xi32>
 
-  // CHECK: scf.while
-  // CHECK: arith.cmpi ne
-  // CHECK: scf.condition
-  // CHECK: arith.shrui
-  // CHECK: arith.subi
-  // CHECK: scf.yield
+  // CHECK: math.ctlz
   %13 = "tosa.clz"(%arg0) : (tensor<1xi32>) -> tensor<1xi32>
 
   // CHECK: linalg.generic
   // CHECK: arith.cmpi
   %14 = "tosa.greater"(%0, %1) : (tensor<1xi32>, tensor<1xi32>) -> tensor<1xi1>
 
   // CHECK: linalg.generic
   // CHECK: arith.cmpi