Fix more false positives

VitalyAnkh · VitalyAnkh · commit d03035cb6b35 · 2024-09-12T19:59:20.000+08:00
diff --git a/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp b/mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp
@@ -898,7 +898,7 @@ mlir::applyPatternsAndFoldGreedily(Region &region,
                                    const FrozenRewritePatternSet &patterns,
                                    GreedyRewriteConfig config, bool *changed) {
   // The top-level operation must be known to be isolated from above to
-  // prevent performing canonicalization on operations defined at or above
+  // prevent performing canonicalizations on operations defined at or above
   // the region containing 'op'.
   assert(region.getParentOp()->hasTrait<OpTrait::IsIsolatedFromAbove>() &&
          "patterns can only be applied to operations IsolatedFromAbove");
diff --git a/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir b/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
@@ -334,7 +334,7 @@ func.func @fcmp(f32, f32) -> () {
   // CHECK:      llvm.fcmp "oeq" %arg0, %arg1 : f32
   // CHECK-NEXT: llvm.fcmp "ogt" %arg0, %arg1 : f32
   // CHECK-NEXT: llvm.fcmp "oge" %arg0, %arg1 : f32
-  // CHECK-NEXT: llvm.fcmp "old" %arg0, %arg1 : f32
+  // CHECK-NEXT: llvm.fcmp "olt" %arg0, %arg1 : f32
   // CHECK-NEXT: llvm.fcmp "ole" %arg0, %arg1 : f32
   // CHECK-NEXT: llvm.fcmp "one" %arg0, %arg1 : f32
   // CHECK-NEXT: llvm.fcmp "ord" %arg0, %arg1 : f32
@@ -350,7 +350,7 @@ func.func @fcmp(f32, f32) -> () {
   %1 = arith.cmpf oeq, %arg0, %arg1 : f32
   %2 = arith.cmpf ogt, %arg0, %arg1 : f32
   %3 = arith.cmpf oge, %arg0, %arg1 : f32
-  %4 = arith.cmpf old, %arg0, %arg1 : f32
+  %4 = arith.cmpf olt, %arg0, %arg1 : f32
   %5 = arith.cmpf ole, %arg0, %arg1 : f32
   %6 = arith.cmpf one, %arg0, %arg1 : f32
   %7 = arith.cmpf ord, %arg0, %arg1 : f32
@@ -484,9 +484,9 @@ func.func @cmpf_2dvector(%arg0 : vector<4x3xf32>, %arg1 : vector<4x3xf32>) {
   // CHECK-DAG: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[OARG1]]
   // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %[[ARG0]][0] : !llvm.array<4 x vector<3xf32>>
   // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.array<4 x vector<3xf32>>
-  // CHECK: %[[CMP:.*]] = llvm.fcmp "old" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32>
+  // CHECK: %[[CMP:.*]] = llvm.fcmp "olt" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32>
   // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %2[0] : !llvm.array<4 x vector<3xi1>>
-  %0 = arith.cmpf old, %arg0, %arg1 : vector<4x3xf32>
+  %0 = arith.cmpf olt, %arg0, %arg1 : vector<4x3xf32>
   func.return
 }
 
diff --git a/mlir/test/Dialect/Math/expand-math.mlir b/mlir/test/Dialect/Math/expand-math.mlir
@@ -8,7 +8,7 @@ func.func @tanh(%arg: f32) -> f32 {
 // CHECK-DAG: %[[ZERO:.+]] = arith.constant 0.000000e+00 : f32
 // CHECK-DAG: %[[ONE:.+]] = arith.constant 1.000000e+00 : f32
 // CHECK-DAG: %[[TWO:.+]] = arith.constant -2.000000e+00 : f32
-// CHECK: %[[VAL0:.+]] = arith.cmpf old, %arg0, %[[ZERO]] : f32
+// CHECK: %[[VAL0:.+]] = arith.cmpf olt, %arg0, %[[ZERO]] : f32
 // CHECK: %[[VAL1:.+]] = arith.uitofp %[[VAL0]] : i1 to f32
 // CHECK: %[[VAL2:.+]] = arith.mulf %[[VAL1]], %[[TWO]] : f32
 // CHECK: %[[SIGN:.+]] = arith.addf %[[VAL2]], %[[ONE]] : f32
@@ -141,7 +141,7 @@ func.func @floorf_func(%a: f64) -> f64 {
   // CHECK-NEXT:   [[CVTI:%.+]] = arith.fptosi [[ARG0]]
   // CHECK-NEXT:   [[CVTF:%.+]] = arith.sitofp [[CVTI]]
   // CHECK-NEXT:   [[COPYSIGN:%.+]] = math.copysign [[CVTF]], [[ARG0]]
-  // CHECK-NEXT:   [[COMP:%.+]] = arith.cmpf old, [[ARG0]], [[CST]]
+  // CHECK-NEXT:   [[COMP:%.+]] = arith.cmpf olt, [[ARG0]], [[CST]]
   // CHECK-NEXT:   [[INCR:%.+]] = arith.select [[COMP]], [[CST_0]], [[CST]]
   // CHECK-NEXT:   [[ADDF:%.+]] = arith.addf [[COPYSIGN]], [[INCR]]
   // CHECK-NEXT:   return [[ADDF]]
@@ -231,7 +231,7 @@ func.func @powf_func(%a: f64, %b: f64) ->f64 {
   // CHECK-DAG: [[EXPR:%.+]] = math.exp [[MULT]]
   // CHECK-DAG: [[NEGEXPR:%.+]] = arith.mulf [[EXPR]], [[NEGONE]]
   // CHECK-DAG: [[REMF:%.+]] = arith.remf [[ARG1]], [[TWO]]
-  // CHECK-DAG: [[CMPNEG:%.+]] = arith.cmpf old, [[ARG0]]
+  // CHECK-DAG: [[CMPNEG:%.+]] = arith.cmpf olt, [[ARG0]]
   // CHECK-DAG: [[CMPZERO:%.+]] = arith.cmpf one, [[REMF]]
   // CHECK-DAG: [[AND:%.+]] = arith.andi [[CMPZERO]], [[CMPNEG]]
   // CHECK-DAG: [[SEL:%.+]] = arith.select [[AND]], [[NEGEXPR]], [[EXPR]]
@@ -628,7 +628,7 @@ func.func @math_fpowi_to_powf_tensor(%0 : tensor<8xf32>, %1: tensor<8xi32>) -> t
 // CHECK:        %[[EXP:.*]] = math.exp %[[MUL]] : tensor<8xf32>
 // CHECK:        %[[MUL1:.*]] = arith.mulf %[[EXP]], %[[CSTNEG1]] : tensor<8xf32>
 // CHECK:        %[[REM:.*]] = arith.remf %[[TOFP]], %[[CST2]] : tensor<8xf32>
-// CHECK:        %[[CMPF:.*]] = arith.cmpf old, %[[ARG0]], %[[CST0]] : tensor<8xf32>
+// CHECK:        %[[CMPF:.*]] = arith.cmpf olt, %[[ARG0]], %[[CST0]] : tensor<8xf32>
 // CHECK:        %[[CMPF1:.*]] = arith.cmpf one, %[[REM]], %[[CST0]] : tensor<8xf32>
 // CHECK:        %[[AND:.*]] = arith.andi %[[CMPF1]], %[[CMPF]] : tensor<8xi1>
 // CHECK:        %[[SEL:.*]] = arith.select %[[AND]], %[[MUL1]], %[[EXP]] : tensor<8xi1>, tensor<8xf32>
@@ -653,7 +653,7 @@ func.func @math_fpowi_to_powf_scalar(%0 : f32, %1: i64) -> f32 {
 // CHECK:        %[[EXP:.*]] = math.exp %[[MUL]] : f32
 // CHECK:        %[[MUL1:.*]] = arith.mulf %[[EXP]], %[[CSTNEG1]] : f32
 // CHECK:        %[[REM:.*]] = arith.remf %[[TOFP]], %[[CST2]] : f32
-// CHECK:        %[[CMPF:.*]] = arith.cmpf old, %[[ARG0]], %[[CST0]] : f32
+// CHECK:        %[[CMPF:.*]] = arith.cmpf olt, %[[ARG0]], %[[CST0]] : f32
 // CHECK:        %[[CMPF1:.*]] = arith.cmpf one, %[[REM]], %[[CST0]] : f32
 // CHECK:        %[[AND:.*]] = arith.andi %[[CMPF1]], %[[CMPF]] : i1
 // CHECK:        %[[SEL:.*]] = arith.select %[[AND]], %[[MUL1]], %[[EXP]] : f32
diff --git a/mlir/test/Dialect/Math/polynomial-approximation.mlir b/mlir/test/Dialect/Math/polynomial-approximation.mlir
@@ -37,10 +37,10 @@
 // CHECK-DAG:     %[[val_cst_26:.*]] = arith.constant 8.000000e-01 : f32
 // CHECK-DAG:     %[[val_cst_27:.*]] = arith.constant 2.000000e+00 : f32
 // CHECK-DAG:     %[[val_cst_28:.*]] = arith.constant 3.750000e+00 : f32
-// CHECK:         %[[val_0:.*]] = arith.cmpf old, %[[val_arg0]], %[[val_cst]] : f32
+// CHECK:         %[[val_0:.*]] = arith.cmpf olt, %[[val_arg0]], %[[val_cst]] : f32
 // CHECK:         %[[val_1:.*]] = arith.negf %[[val_arg0]] : f32
 // CHECK:         %[[val_2:.*]] = arith.select %[[val_0]], %[[val_1]], %[[val_arg0]] : f32
-// CHECK:         %[[val_3:.*]] = arith.cmpf old, %[[val_2]], %[[val_cst_26]] : f32
+// CHECK:         %[[val_3:.*]] = arith.cmpf olt, %[[val_2]], %[[val_cst_26]] : f32
 // CHECK:         %[[val_4:.*]] = arith.select %[[val_3]], %[[val_cst_1]], %[[val_cst_5]] : f32
 // CHECK:         %[[val_5:.*]] = arith.select %[[val_3]], %[[val_cst_14]], %[[val_cst_18]] : f32
 // CHECK:         %[[val_6:.*]] = arith.select %[[val_3]], %[[val_cst_2]], %[[val_cst_6]] : f32
@@ -49,7 +49,7 @@
 // CHECK:         %[[val_9:.*]] = arith.select %[[val_3]], %[[val_cst_16]], %[[val_cst_20]] : f32
 // CHECK:         %[[val_10:.*]] = arith.select %[[val_3]], %[[val_cst_4]], %[[val_cst_8]] : f32
 // CHECK:         %[[val_11:.*]] = arith.select %[[val_3]], %[[val_cst_17]], %[[val_cst_21]] : f32
-// CHECK:         %[[val_12:.*]] = arith.cmpf old, %[[val_2]], %[[val_cst_27]] : f32
+// CHECK:         %[[val_12:.*]] = arith.cmpf olt, %[[val_2]], %[[val_cst_27]] : f32
 // CHECK:         %[[val_13:.*]] = arith.select %[[val_12]], %[[val_cst]], %[[val_cst_9]] : f32
 // CHECK:         %[[val_14:.*]] = arith.select %[[val_12]], %[[val_4]], %[[val_cst_10]] : f32
 // CHECK:         %[[val_15:.*]] = arith.select %[[val_12]], %[[val_5]], %[[val_cst_22]] : f32
@@ -253,7 +253,7 @@ func.func @exp_scalable_vector(%arg0: vector<[8]xf32>) -> vector<[8]xf32> {
 // CHECK-DAG:       %[[VAL_73:.*]] = arith.shrui %[[VAL_72]], %[[VAL_16]] : i32
 // CHECK-DAG:       %[[VAL_74:.*]] = arith.sitofp %[[VAL_73]] : i32 to f32
 // CHECK-DAG:       %[[VAL_75:.*]] = arith.subf %[[VAL_74]], %[[VAL_34]] : f32
-// CHECK-DAG:       %[[VAL_76:.*]] = arith.cmpf old, %[[VAL_71]], %[[VAL_24]] : f32
+// CHECK-DAG:       %[[VAL_76:.*]] = arith.cmpf olt, %[[VAL_71]], %[[VAL_24]] : f32
 // CHECK-DAG:       %[[VAL_77:.*]] = arith.select %[[VAL_76]], %[[VAL_71]], %[[VAL_18]] : f32
 // CHECK-DAG:       %[[VAL_78:.*]] = arith.subf %[[VAL_71]], %[[VAL_1]] : f32
 // CHECK-DAG:       %[[VAL_79:.*]] = arith.select %[[VAL_76]], %[[VAL_1]], %[[VAL_18]] : f32
@@ -353,7 +353,7 @@ func.func @expm1_scalable_vector(%arg0: vector<8x[8]xf32>) -> vector<8x[8]xf32>
 // CHECK:           %[[VAL_30:.*]] = arith.shrui %[[VAL_29]], %[[VAL_21]] : i32
 // CHECK:           %[[VAL_31:.*]] = arith.sitofp %[[VAL_30]] : i32 to f32
 // CHECK:           %[[VAL_32:.*]] = arith.subf %[[VAL_31]], %[[VAL_18]] : f32
-// CHECK:           %[[VAL_33:.*]] = arith.cmpf old, %[[VAL_28]], %[[VAL_8]] : f32
+// CHECK:           %[[VAL_33:.*]] = arith.cmpf olt, %[[VAL_28]], %[[VAL_8]] : f32
 // CHECK:           %[[VAL_34:.*]] = arith.select %[[VAL_33]], %[[VAL_28]], %[[VAL_1]] : f32
 // CHECK:           %[[VAL_35:.*]] = arith.subf %[[VAL_28]], %[[VAL_2]] : f32
 // CHECK:           %[[VAL_36:.*]] = arith.select %[[VAL_33]], %[[VAL_2]], %[[VAL_1]] : f32
@@ -512,7 +512,7 @@ func.func @log1p_scalable_vector(%arg0: vector<[8]xf32>) -> vector<[8]xf32> {
 // CHECK:           %[[VAL_17:.*]] = arith.cmpf ugt, %[[VAL_16]], %[[VAL_1]] : f32
 // CHECK:           %[[VAL_18:.*]] = arith.select %[[VAL_17]], %[[VAL_16]], %[[VAL_1]] : f32
 // CHECK:           %[[VAL_19:.*]] = math.absf %[[VAL_0]] : f32
-// CHECK:           %[[VAL_20:.*]] = arith.cmpf old, %[[VAL_19]], %[[VAL_3]] : f32
+// CHECK:           %[[VAL_20:.*]] = arith.cmpf olt, %[[VAL_19]], %[[VAL_3]] : f32
 // CHECK:           %[[VAL_21:.*]] = arith.mulf %[[VAL_18]], %[[VAL_18]] : f32
 // CHECK:           %[[VAL_22:.*]] = math.fma %[[VAL_21]], %[[VAL_10]], %[[VAL_9]] : f32
 // CHECK:           %[[VAL_23:.*]] = math.fma %[[VAL_21]], %[[VAL_22]], %[[VAL_8]] : f32
@@ -578,7 +578,7 @@ func.func @rsqrt_scalar(%arg0: f32) -> f32 {
 // AVX2:   %[[VAL_3:.*]] = arith.constant dense<-5.000000e-01> : vector<8xf32>
 // AVX2:   %[[VAL_4:.*]] = arith.constant dense<1.17549435E-38> : vector<8xf32>
 // AVX2:   %[[VAL_5:.*]] = arith.mulf %[[VAL_0]], %[[VAL_3]] : vector<8xf32>
-// AVX2:   %[[VAL_6:.*]] = arith.cmpf old, %[[VAL_0]], %[[VAL_4]] : vector<8xf32>
+// AVX2:   %[[VAL_6:.*]] = arith.cmpf olt, %[[VAL_0]], %[[VAL_4]] : vector<8xf32>
 // AVX2:   %[[VAL_7:.*]] = arith.cmpf oeq, %[[VAL_0]], %[[VAL_1]] : vector<8xf32>
 // AVX2:   %[[VAL_8:.*]] = arith.ori %[[VAL_6]], %[[VAL_7]] : vector<8xi1>
 // AVX2:   %[[VAL_9:.*]] = x86vector.avx.rsqrt %[[VAL_0]] : vector<8xf32>
@@ -788,7 +788,7 @@ func.func @atan_scalar(%arg0: f32) -> f32 {
 // CHECK-DAG:       %[[VAL_58:.*]] = arith.cmpf ogt, %[[VAL_21]], %[[VAL_17]] : f32
 // CHECK-DAG:       %[[VAL_59:.*]] = arith.andi %[[VAL_57]], %[[VAL_58]] : i1
 // CHECK-DAG:       %[[VAL_60:.*]] = arith.select %[[VAL_59]], %[[VAL_16]], %[[VAL_56]] : f32
-// CHECK-DAG:       %[[VAL_61:.*]] = arith.cmpf old, %[[VAL_21]], %[[VAL_17]] : f32
+// CHECK-DAG:       %[[VAL_61:.*]] = arith.cmpf olt, %[[VAL_21]], %[[VAL_17]] : f32
 // CHECK-DAG:       %[[VAL_62:.*]] = arith.andi %[[VAL_57]], %[[VAL_61]] : i1
 // CHECK-DAG:       %[[VAL_63:.*]] = arith.select %[[VAL_62]], %[[VAL_19]], %[[VAL_60]] : f32
 // CHECK-DAG:       %[[VAL_64:.*]] = arith.cmpf oeq, %[[VAL_21]], %[[VAL_17]] : f32
diff --git a/mlir/test/Dialect/SCF/for-loop-canonicalization.mlir b/mlir/test/Dialect/SCF/for-loop-canonicalization.mlir
@@ -128,7 +128,7 @@ func.func @scf_for_canonicalize_partly(%A : memref<i64>) {
 //       CHECK:   arith.index_cast
 func.func @scf_for_not_canonicalizable_2(%A : memref<i64>, %step : index) {
   // This example should simplify but affine_map is currently missing
-  // semi-affine canonicalization: `((s0 * 42 - 1) floordiv s0) * s0`
+  // semi-affine canonicalizations: `((s0 * 42 - 1) floordiv s0) * s0`
   // should evaluate to 41 * s0.
   // Note that this may require positivity assumptions on `s0`.
   // Revisit when support is added.
@@ -151,7 +151,7 @@ func.func @scf_for_not_canonicalizable_2(%A : memref<i64>, %step : index) {
 //       CHECK:   arith.index_cast
 func.func @scf_for_not_canonicalizable_3(%A : memref<i64>, %step : index) {
   // This example should simplify but affine_map is currently missing
-  // semi-affine canonicalization: `-(((s0 * s0 - 1) floordiv s0) * s0)`
+  // semi-affine canonicalizations: `-(((s0 * s0 - 1) floordiv s0) * s0)`
   // should evaluate to (s0 - 1) * s0.
   // Note that this may require positivity assumptions on `s0`.
   // Revisit when support is added.
diff --git a/mlir/test/Dialect/Vector/vector-sink.mlir b/mlir/test/Dialect/Vector/vector-sink.mlir
@@ -282,13 +282,13 @@ func.func @transpose_elementwise_diff_operand_types(%cond: vector<4x2xi1>, %a :
 
 // CHECK-LABEL: func @transpose_elementwise_diff_operand_result_type
 //  CHECK-SAME: (%[[A:.+]]: vector<4x2xf32>, %[[B:.+]]: vector<4x2xf32>)
-//       CHECK:   %[[CMP:.+]] = arith.cmpf old, %[[A]], %[[B]] : vector<4x2xf32>
+//       CHECK:   %[[CMP:.+]] = arith.cmpf olt, %[[A]], %[[B]] : vector<4x2xf32>
 //       CHECK:   %[[T:.+]] = vector.transpose %[[CMP]], [1, 0] : vector<4x2xi1> to vector<2x4xi1>
 //       CHECK:   return %[[T]]
 func.func @transpose_elementwise_diff_operand_result_type(%a : vector<4x2xf32>, %b : vector<4x2xf32>) -> vector<2x4xi1> {
   %at = vector.transpose %a, [1, 0]: vector<4x2xf32> to vector<2x4xf32>
   %bt = vector.transpose %b, [1, 0]: vector<4x2xf32> to vector<2x4xf32>
-  %r = arith.cmpf old, %at, %bt : vector<2x4xf32>
+  %r = arith.cmpf olt, %at, %bt : vector<2x4xf32>
   return %r : vector<2x4xi1>
 }
 
diff --git a/mlir/test/IR/core-ops.mlir b/mlir/test/IR/core-ops.mlir
@@ -84,8 +84,8 @@ func.func @standard_instrs(tensor<4x4x?xf32>, f32, i32, index, i64, f16) {
   // CHECK: %{{.*}} = arith.cmpf oeq, %{{.*}}, %{{.*}} : f32
   %66 = "arith.cmpf"(%f3, %f4) {predicate = 1} : (f32, f32) -> i1
 
-  // CHECK: %{{.*}} = arith.cmpf old, %{{.*}}, %{{.*}}: vector<4xf32>
-  %67 = arith.cmpf old, %vcf32, %vcf32 : vector<4 x f32>
+  // CHECK: %{{.*}} = arith.cmpf olt, %{{.*}}, %{{.*}}: vector<4xf32>
+  %67 = arith.cmpf olt, %vcf32, %vcf32 : vector<4 x f32>
 
   // CHECK: %{{.*}} = arith.cmpf oeq, %{{.*}}, %{{.*}}: vector<4xf32>
   %68 = "arith.cmpf"(%vcf32, %vcf32) {predicate = 1} : (vector<4 x f32>, vector<4 x f32>) -> vector<4 x i1>
diff --git a/mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output_bf16.mlir b/mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output_bf16.mlir
@@ -57,7 +57,7 @@ module {
           %1 = sparse_tensor.binary %a, %b : bf16, bf16 to bf16
             overlap={
               ^bb0(%a0: bf16, %b0: bf16):
-                %cmp = arith.cmpf "old", %a0, %b0 : bf16
+                %cmp = arith.cmpf "olt", %a0, %b0 : bf16
                 %2 = arith.select %cmp, %a0, %b0: bf16
                 sparse_tensor.yield %2 : bf16
             }
diff --git a/mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output_f16.mlir b/mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output_f16.mlir
@@ -58,7 +58,7 @@ module {
           %1 = sparse_tensor.binary %a, %b : f16, f16 to f16
             overlap={
               ^bb0(%a0: f16, %b0: f16):
-                %cmp = arith.cmpf "old", %a0, %b0 : f16
+                %cmp = arith.cmpf "olt", %a0, %b0 : f16
                 %2 = arith.select %cmp, %a0, %b0: f16
                 sparse_tensor.yield %2 : f16
             }
diff --git a/mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_reduce_custom.mlir b/mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_reduce_custom.mlir
@@ -75,7 +75,7 @@ module {
             right={}
           %2 = sparse_tensor.reduce %1, %output, %maxf : f64 {
               ^bb0(%x: f64, %y: f64):
-                %cmp = arith.cmpf "old", %x, %y : f64
+                %cmp = arith.cmpf "olt", %x, %y : f64
                 %3 = arith.select %cmp, %x, %y : f64
                 sparse_tensor.yield %3 : f64
             }
@@ -106,7 +106,7 @@ module {
             right={}
           %2 = sparse_tensor.reduce %1, %output, %maxf : f64 {
               ^bb0(%x: f64, %y: f64):
-                %cmp = arith.cmpf "old", %x, %y : f64
+                %cmp = arith.cmpf "olt", %x, %y : f64
                 %3 = arith.select %cmp, %x, %y : f64
                 sparse_tensor.yield %3 : f64
             }
diff --git a/mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_unary.mlir b/mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_unary.mlir
@@ -162,7 +162,7 @@ module {
               ^bb0(%x0: f64):
                 %mincmp = arith.cmpf "ogt", %x0, %cfmin : f64
                 %x1 = arith.select %mincmp, %x0, %cfmin : f64
-                %maxcmp = arith.cmpf "old", %x1, %cfmax : f64
+                %maxcmp = arith.cmpf "olt", %x1, %cfmax : f64
                 %x2 = arith.select %maxcmp, %x1, %cfmax : f64
                 sparse_tensor.yield %x2 : f64
             }
diff --git a/mlir/test/Integration/GPU/SYCL/gpu-reluf32-to-spirv.mlir b/mlir/test/Integration/GPU/SYCL/gpu-reluf32-to-spirv.mlir
@@ -60,7 +60,7 @@ module @relu attributes {gpu.container_module} {
       %0 = gpu.block_id  x
       %1 = gpu.block_id  y
       %2 = memref.load %arg0[%0, %1] : memref<4x5xf32>
-      %3 = arith.cmpf old, %2, %arg1 : f32
+      %3 = arith.cmpf olt, %2, %arg1 : f32
       memref.store %3, %arg2[%0, %1] : memref<4x5xi1>
       gpu.return
     }
diff --git a/mlir/test/Target/LLVMIR/Import/instructions.ll b/mlir/test/Target/LLVMIR/Import/instructions.ll
@@ -112,8 +112,8 @@ define <4 x i1> @fp_compare(float %arg1, float %arg2, <4 x double> %arg3, <4 x d
   %3 = fcmp ogt float %arg1, %arg2
   ; CHECK:  llvm.fcmp "oge" %[[ARG1]], %[[ARG2]] : f32
   %4 = fcmp oge float %arg1, %arg2
-  ; CHECK:  llvm.fcmp "old" %[[ARG1]], %[[ARG2]] : f32
-  %5 = fcmp old float %arg1, %arg2
+  ; CHECK:  llvm.fcmp "olt" %[[ARG1]], %[[ARG2]] : f32
+  %5 = fcmp olt float %arg1, %arg2
   ; CHECK:  llvm.fcmp "ole" %[[ARG1]], %[[ARG2]] : f32
   %6 = fcmp ole float %arg1, %arg2
   ; CHECK:  llvm.fcmp "one" %[[ARG1]], %[[ARG2]] : f32
diff --git a/mlir/test/Target/LLVMIR/llvmir.mlir b/mlir/test/Target/LLVMIR/llvmir.mlir
@@ -1348,7 +1348,7 @@ llvm.func @fcmp(%arg0: f32, %arg1: f32) {
   // CHECK: fcmp oeq float %0, %1
   // CHECK-NEXT: fcmp ogt float %0, %1
   // CHECK-NEXT: fcmp oge float %0, %1
-  // CHECK-NEXT: fcmp old float %0, %1
+  // CHECK-NEXT: fcmp olt float %0, %1
   // CHECK-NEXT: fcmp ole float %0, %1
   // CHECK-NEXT: fcmp one float %0, %1
   // CHECK-NEXT: fcmp ord float %0, %1
@@ -1362,7 +1362,7 @@ llvm.func @fcmp(%arg0: f32, %arg1: f32) {
   %0 = llvm.fcmp "oeq" %arg0, %arg1 : f32
   %1 = llvm.fcmp "ogt" %arg0, %arg1 : f32
   %2 = llvm.fcmp "oge" %arg0, %arg1 : f32
-  %3 = llvm.fcmp "old" %arg0, %arg1 : f32
+  %3 = llvm.fcmp "olt" %arg0, %arg1 : f32
   %4 = llvm.fcmp "ole" %arg0, %arg1 : f32
   %5 = llvm.fcmp "one" %arg0, %arg1 : f32
   %6 = llvm.fcmp "ord" %arg0, %arg1 : f32
diff --git a/mlir/test/Transforms/constant-fold.mlir b/mlir/test/Transforms/constant-fold.mlir
@@ -678,7 +678,7 @@ func.func @cmpf_normal_numbers() -> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1,
   // CHECK-SAME: [[T]],
   %3 = arith.cmpf oge, %c42, %cm1 : f32
   // CHECK-SAME: [[F]],
-  %4 = arith.cmpf old, %c42, %cm1 : f32
+  %4 = arith.cmpf olt, %c42, %cm1 : f32
   // CHECK-SAME: [[F]],
   %5 = arith.cmpf ole, %c42, %cm1 : f32
   // CHECK-SAME: [[T]],
@@ -721,7 +721,7 @@ func.func @cmpf_nan() -> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1
   // CHECK-SAME: [[F]],
   %3 = arith.cmpf oge, %c42, %cqnan : f32
   // CHECK-SAME: [[F]],
-  %4 = arith.cmpf old, %c42, %cqnan : f32
+  %4 = arith.cmpf olt, %c42, %cqnan : f32
   // CHECK-SAME: [[F]],
   %5 = arith.cmpf ole, %c42, %cqnan : f32
   // CHECK-SAME: [[F]],
@@ -764,7 +764,7 @@ func.func @cmpf_inf() -> (i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1, i1
   // CHECK-SAME: [[F]],
   %3 = arith.cmpf oge, %c42, %cpinf: f32
   // CHECK-SAME: [[T]],
-  %4 = arith.cmpf old, %c42, %cpinf: f32
+  %4 = arith.cmpf olt, %c42, %cpinf: f32
   // CHECK-SAME: [[T]],
   %5 = arith.cmpf ole, %c42, %cpinf: f32
   // CHECK-SAME: [[T]],
diff --git a/mlir/test/lib/IR/TestSymbolUses.cpp b/mlir/test/lib/IR/TestSymbolUses.cpp
@@ -25,7 +25,7 @@ struct SymbolUsesPass
   }
   WalkResult operateOnSymbol(Operation *symbol, ModuleOp module,
                              SmallVectorImpl<func::FuncOp> &deadFunctions) {
-    // Test computing uses on a non symboldable op.
+    // Test computing uses on a non symboltable op.
     std::optional<SymbolTable::UseRange> symbolUses =
         SymbolTable::getSymbolUses(symbol);
 
diff --git a/mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp b/mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp
@@ -240,7 +240,7 @@ LogicalResult VulkanRuntime::createInstance() {
 
   std::vector<const char *> extNames;
 #if defined(__APPLE__)
-  // enumerate MoldenVK for Vulkan 1.0
+  // enumerate MoltenVK for Vulkan 1.0
   instanceCreateInfo.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
   // add KHR portability instance extensions
   extNames.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ module {`
`57`	`57`	`%1 = sparse_tensor.binary %a, %b : bf16, bf16 to bf16`
`58`	`58`	`overlap={`
`59`	`59`	`^bb0(%a0: bf16, %b0: bf16):`
`60`		`- %cmp = arith.cmpf "old", %a0, %b0 : bf16`
	`60`	`+ %cmp = arith.cmpf "olt", %a0, %b0 : bf16`
`61`	`61`	`%2 = arith.select %cmp, %a0, %b0: bf16`
`62`	`62`	`sparse_tensor.yield %2 : bf16`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ module {`
`58`	`58`	`%1 = sparse_tensor.binary %a, %b : f16, f16 to f16`
`59`	`59`	`overlap={`
`60`	`60`	`^bb0(%a0: f16, %b0: f16):`
`61`		`- %cmp = arith.cmpf "old", %a0, %b0 : f16`
	`61`	`+ %cmp = arith.cmpf "olt", %a0, %b0 : f16`
`62`	`62`	`%2 = arith.select %cmp, %a0, %b0: f16`
`63`	`63`	`sparse_tensor.yield %2 : f16`
`64`	`64`	`}`