[mlir] Clean up typos in FileCheck directives in various tests.

mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir

func.func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
   %7 = memref.view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4>
 
   return
 }
 
 // -----
 
-// CHECK-LABL: func @view_empty_memref(
+// CHECK-LABEL: func @view_empty_memref(
 // CHECK:        %[[ARG0:.*]]: index,
 // CHECK:        %[[ARG1:.*]]: memref<0xi8>)
 func.func @view_empty_memref(%offset: index, %mem: memref<0xi8>) {
 
   // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(0 : index) : i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
   // CHECK: llvm.mlir.constant(4 : index) : i64

mlir/test/Dialect/Affine/SuperVectorize/vector_utils.mlir

func.func @vector_add_2d(%arg0: index, %arg1: index) -> f32 {
   // CHECK:matched: {{.*}} arith.constant dense{{.*}} with shape ratio: 2, 32
   %cst_1 = arith.constant dense<1.000000e+00> : vector<8x256xf32>
   // CHECK:matched: {{.*}} arith.constant dense{{.*}} with shape ratio: 1, 3, 7, 2, 1
   %cst_a = arith.constant dense<1.000000e+00> : vector<1x3x7x8x8xf32>
   // CHECK-NOT:matched: {{.*}} arith.constant dense{{.*}} with shape ratio: 1, 3, 7, 1{{.*}}
   %cst_b = arith.constant dense<1.000000e+00> : vector<1x3x7x4x4xf32>
   // TEST-3x4x5x8:matched: {{.*}} arith.constant dense{{.*}} with shape ratio: 3, 2, 1, 4
   %cst_c = arith.constant dense<1.000000e+00> : vector<3x4x5x8xf32>
-  // TEST-3x4x4x8-NOT:matched: {{.*}} arith.constant dense{{.*}} with shape ratio{{.*}}
+  // TEST-3x4x5x8-NOT:matched: {{.*}} arith.constant dense{{.*}} with shape ratio{{.*}}
   %cst_d = arith.constant dense<1.000000e+00> : vector<3x4x4x8xf32>
-  // TEST-3x4x4x8:matched: {{.*}} arith.constant dense{{.*}} with shape ratio: 1, 1, 2, 16
+  // TEST-3x4x5x8:matched: {{.*}} arith.constant dense{{.*}} with shape ratio: 1, 1, 2, 16
   %cst_e = arith.constant dense<1.000000e+00> : vector<1x2x10x32xf32>
 
   // Nothing should be matched in this last block.
   // CHECK-NOT:matched: {{.*}} = arith.constant 7{{.*}}
   // CHECK-NOT:matched: {{.*}} = arith.constant 42{{.*}}
   // CHECK-NOT:matched: {{.*}} = memref.load{{.*}}
   // CHECK-NOT:matched: return {{.*}}
   %c7 = arith.constant 7 : index

mlir/test/Dialect/Arith/test-emulate-wide-int-pass.mlir

 // CHECK-SAME:    ([[ARG:%.+]]: i64) -> i64 {
 // CHECK-NEXT:    [[BCAST0:%.+]]   = llvm.bitcast [[ARG]] : i64 to vector<2xi32>
 // CHECK-NEXT:    [[LOW0:%.+]]     = vector.extract [[BCAST0]][0] : vector<2xi32>
 // CHECK-NEXT:    [[HIGH0:%.+]]    = vector.extract [[BCAST0]][1] : vector<2xi32>
 // CHECK-NEXT:    [[LOW1:%.+]]     = vector.extract [[BCAST0]][0] : vector<2xi32>
 // CHECK-NEXT:    [[HIGH1:%.+]]    = vector.extract [[BCAST0]][1] : vector<2xi32>
 // CHECK-NEXT:    {{%.+}}, {{%.+}} = arith.addui_extended [[LOW0]], [[LOW1]] : i32, i1
 // CHECK:         [[RES:%.+]]      = llvm.bitcast {{%.+}} : vector<2xi32> to i64
-// CHECK-NEXt:    return [[RES]] : i64
+// CHECK-NEXT:    return [[RES]] : i64
 func.func @emulate_me_please(%x : i64) -> i64 {
   %r = arith.addi %x, %x : i64
   return %r : i64
 }
 
 // CHECK-LABEL: func.func @foo
 // CHECK-SAME:    ([[ARG:%.+]]: i64) -> i64 {
 // CHECK-NEXT:    [[RES:%.+]] = arith.addi [[ARG]], [[ARG]] : i64
 // CHECK-NEXT:    return [[RES]] : i64
 func.func @foo(%x : i64) -> i64 {
   %r = arith.addi %x, %x : i64
   return %r : i64
 }

mlir/test/Dialect/Bufferization/Transforms/one-shot-module-bufferize-allow-return-allocs.mlir

func.func @return_arg(%A: tensor<?xf32>) -> tensor<?xf32> {
   func.return %A : tensor<?xf32>
 }
 // CHECK-LABEL: func @return_arg
 // CHECK-SAME:      %[[A:.*]]: memref<?xf32
 //  CHECK-NOT:    return %[[A]]
 
 // NO-DROP-LABEL: func @return_arg
 //  NO-DROP-SAME:     %[[A:.*]]: memref<?xf32
-//       No_DROP:   return %[[A]]
+//       NO-DROP:   return %[[A]]

mlir/test/Dialect/OpenMP/ops.mlir

func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memref<i32>, %linear_var : i32, %chunk_var : i32) -> () {
   // CHECK-SAME: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   "omp.wsloop" (%lb, %ub, %step) ({
     ^bb0(%iv: index):
       omp.yield
   }) {operand_segment_sizes = array<i32: 1,1,1,0,0,0,0>, ordered_val = 1} :
     (index, index, index) -> ()
 
   // CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>) schedule(static)
-  // CHECK-SAMe: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
+  // CHECK-SAME: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   "omp.wsloop" (%lb, %ub, %step, %data_var, %linear_var) ({
     ^bb0(%iv: index):
       omp.yield
   }) {operand_segment_sizes = array<i32: 1,1,1,1,1,0,0>, schedule_val = #omp<schedulekind static>} :
     (index, index, index, memref<i32>, i32) -> ()
 
   // CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>, %{{.*}} = %{{.*}} : memref<i32>) schedule(static)
   // CHECK-SAME: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})

mlir/test/Dialect/Tosa/ops.mlir

 // -----
 // CHECK-LABEL: max_pool2d
 func.func @test_max_pool2d(%arg0: tensor<1x32x32x8xf32>) -> tensor<1x32x32x8xf32> {
   %0 = "tosa.max_pool2d"(%arg0) {kernel = [1, 1], pad = [0, 0, 0, 0], stride = [1, 1]} : (tensor<1x32x32x8xf32>) -> tensor<1x32x32x8xf32>
   return %0 : tensor<1x32x32x8xf32>
 }
 
 // -----
-/// CHECK-LABEL: transpose_conv2d
+// CHECK-LABEL: transpose_conv2d
 func.func @test_transpose_conv2d(%arg0: tensor<1x32x32x8xf32>, %arg1: tensor<16x1x1x8xf32>, %arg2: tensor<16xf32>) -> tensor<1x32x32x16xf32> {
   %0 = "tosa.transpose_conv2d"(%arg0, %arg1, %arg2) {out_pad = [0, 0, 0, 0], out_shape = [1, 32, 32, 16], stride = [1, 1]} : (tensor<1x32x32x8xf32>, tensor<16x1x1x8xf32>, tensor<16xf32>) -> tensor<1x32x32x16xf32>
   return %0 : tensor<1x32x32x16xf32>
 }
 
 // -----
 // CHECK-LABEL: clamp
 func.func @test_clamp(%arg0: tensor<13x21x3xf32>) -> tensor<13x21x3xf32> {

mlir/test/Dialect/Tosa/tosa-infer-shapes.mlir

func.func @test_dynamic_mixed_matmul(%arg0 : tensor<?x3x?xi32>, %arg1 : tensor<?x?x5xi32>) -> () {
   // CHECK: "tosa.matmul"(%arg0, %arg1) : (tensor<?x3x?xi32>, tensor<?x?x5xi32>) -> tensor<?x3x5xi32>
   %0 = "tosa.matmul"(%arg0, %arg1) : (tensor<?x3x?xi32>, tensor<?x?x5xi32>) -> tensor<?x?x?xi32>
 
   return
 }
 
 // -----
 
-// CHECK-LABLE: @test_table_static
+// CHECK-LABEL: @test_table_static
 func.func @test_table_static(%arg0 : tensor<4x5xi16>, %arg1 : tensor<513xi16>) -> () {
   // CHECK:"tosa.table"(%arg0, %arg1) : (tensor<4x5xi16>, tensor<513xi16>) -> tensor<4x5xi16>
   %0 = "tosa.table"(%arg0, %arg1) : (tensor<4x5xi16>, tensor<513xi16>) -> tensor<?x?xi16>
   return
 }
 
 // -----
 
-// CHECK-LABLE: @test_table_dynamic
+// CHECK-LABEL: @test_table_dynamic
 func.func @test_table_dynamic(%arg0 : tensor<4x?xi16>, %arg1 : tensor<513xi16>) -> () {
   // CHECK:"tosa.table"(%arg0, %arg1) : (tensor<4x?xi16>, tensor<513xi16>) -> tensor<4x?xi16>
   %0 = "tosa.table"(%arg0, %arg1) : (tensor<4x?xi16>, tensor<513xi16>) -> tensor<?x?xi16>
   return
 }
 
 // -----
 

mlir/test/Dialect/Vector/vector-contract-transforms.mlir

 // CHECK:      return %[[A]] : vector<16xf32>
 
 func.func @nop_shape_cast(%arg0: vector<16xf32>) -> vector<16xf32> {
   %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<16xf32>
   return %0 : vector<16xf32>
 }
 
 // CHECK-LABEL: func @cancel_shape_cast
-// FIXME: PR49590
-// HECK-SAME: %[[A:.*]]: vector<16xf32>
-// HECK:      return %[[A]] : vector<16xf32>
+// CHECK-SAME: %[[A:.*]]: vector<16xf32>
+// CHECK:      return %[[A]] : vector<16xf32>
 
 func.func @cancel_shape_cast(%arg0: vector<16xf32>) -> vector<16xf32> {
   %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32>
   %1 = vector.shape_cast %0 : vector<4x4xf32> to vector<16xf32>
   return %1 : vector<16xf32>
 }
 
 // Shape up and downcasts for 2-D vectors, for supporting conversion to

mlir/test/Target/SPIRV/logical-ops.mlir

spirv.func @cmpf(%arg0 : f32, %arg1 : f32) "None" {
     // CHECK: spirv.FUnordLessThanEqual
     %11 = spirv.FUnordLessThanEqual %arg0, %arg1 : f32
     // CHECK: spirv.FUnordNotEqual
     %12 = spirv.FUnordNotEqual %arg0, %arg1 : f32
     // CHECK: spirv.Ordered
     %13 = spirv.Ordered %arg0, %arg1 : f32
     // CHECK: spirv.Unordered
     %14 = spirv.Unordered %arg0, %arg1 : f32
-    // CHCK: spirv.IsNan
+    // CHECK: spirv.IsNan
     %15 = spirv.IsNan %arg0 : f32
-    // CHCK: spirv.IsInf
+    // CHECK: spirv.IsInf
     %16 = spirv.IsInf %arg1 : f32
     spirv.Return
   }
 }
 
 // -----
 
 spirv.module Logical GLSL450 requires #spirv.vce<v1.0, [Shader], []> {

mlir/test/mlir-cpu-runner/math-polynomial-approx.mlir

func.func @cos() {
   // CHECK: 1
   %zero = arith.constant 0.0 : f32
   call @cos_f32(%zero) : (f32) -> ()
 
   // CHECK: 0.707107
   %pi_over_4 = arith.constant 0.78539816339 : f32
   call @cos_f32(%pi_over_4) : (f32) -> ()
 
-  //// CHECK: 0
+  // CHECK: 0
   %pi_over_2 = arith.constant 1.57079632679 : f32
   call @cos_f32(%pi_over_2) : (f32) -> ()
 
-  /// CHECK: -1
+  // CHECK: -1
   %pi = arith.constant 3.14159265359 : f32
   call @cos_f32(%pi) : (f32) -> ()
 
   // CHECK: 0
   %pi_3_over_2 = arith.constant 4.71238898038 : f32
   call @cos_f32(%pi_3_over_2) : (f32) -> ()
 
   // CHECK: -1, -0.5, 0