[mlir][sparse] cleanup some pass documentation

[aartbik]

removed TABs

[aartbik]

remove one last TAB

mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.td

#matvec = {
         affine_map<(i,j) -> (i)>    // x (out)
       ],
       iterator_types = ["parallel", "reduction"],
       doc = "X(i) += A(i,j) * B(j)"
     }
 
     // Multiply a sparse matrix A with a dense vector b into a dense vector x.
     func.func @kernel_matvec(%arga: tensor<?x?xf64, #SparseMatrix>,
                              %argb: tensor<?xf64>,
                              %argx: tensor<?xf64>) -> tensor<?xf64> {
       %0 = linalg.generic #matvec
         ins(%arga, %argb: tensor<?x?xf64, #SparseMatrix>, tensor<?xf64>)
         outs(%argx: tensor<?xf64>) {
         ^bb(%a: f64, %b: f64, %x: f64):
           %0 = arith.mulf %a, %b : f64
           %1 = arith.addf %x, %0 : f64
           linalg.yield %1 : f64
       } -> tensor<?xf64>
let description = [{
     the conversion relatively simple, but at the expense of IR opacity,
     which obscures opportunities for subsequent optimization of the IR.
     An alternative is provided by the SparseTensorCodegen pass.
 
     Example of the conversion:
 
     ```mlir
       Before:
-        %c1 = arith.constant 1 : index
-        %0 = sparse_tensor.pointers %arg0, %c1
-          : tensor<8x8xf32, #sparse_tensor.encoding<{
-              dimLevelType = [ "dense", "compressed" ],
-              pointerBitWidth = 0,
-              indexBitWidth = 0
-            }>> to memref<?xindex>
+        func.func @foo(%arg0: tensor<8x8xf32, #CSR>) -> memref<?xindex> {
+          %0 = sparse_tensor.pointers %arg0 {dimension = 1 : index}
+             : tensor<8x8xf32, #CSR> to memref<?xindex>
+          return %0 : memref<?xindex>
+        }
 
       After:
+        func.func @foo(%arg0: !llvm.ptr<i8>) -> memref<?xindex> {
           %c1 = arith.constant 1 : index
-        %0 = call @sparsePointers(%arg0, %c1) : (!llvm.ptr<i8>, index) -> memref<?xindex>
+          %0 = call @sparsePointers0(%arg0, %c1)
+             : (!llvm.ptr<i8>, index) -> memref<?xindex>
+          return %0 : memref<?xindex>
+        }
     ```
   }];
   let constructor = "mlir::createSparseTensorConversionPass()";
   let dependentDialects = [
     "arith::ArithDialect",
     "bufferization::BufferizationDialect",
     "LLVM::LLVMDialect",
     "linalg::LinalgDialect",
let description = [{
     This pass provides an alternative to the SparseTensorConversion pass,
     eliminating the dependence on a runtime support library, and providing
     much more opportunities for subsequent compiler optimization of the
     generated code.
 
     Example of the conversion:
 
     ```mlir
-    TBD
+      Before:
+        func.func @foo(%arg0: tensor<8x8xf32, #CSR>) -> memref<?xindex> {
+          %0 = sparse_tensor.pointers %arg0 {dimension = 1 : index}
+             : tensor<8x8xf32, #CSR> to memref<?xindex>
+          return %0 : memref<?xindex>
+        }
+
+      After:
+        func.func @foo(%arg0: memref<2xindex>,
+                       %arg1: memref<3xindex>,
+                       %arg2: memref<?xindex>,
+                       %arg3: memref<?xindex>,
+                       %arg4: memref<?xf32>) -> memref<?xindex> {
+          return %arg2 : memref<?xindex>
+        }
     ```
   }];
   let constructor = "mlir::createSparseTensorCodegenPass()";
   let dependentDialects = [
     "arith::ArithDialect",
     "bufferization::BufferizationDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",