[mlir][OpFormatGen] Format enum attribute cases as keywords when possible

In the overwhelmingly common case, enum attribute case strings represent valid identifiers in MLIR syntax. This revision updates the format generator to format as a keyword in these cases, removing the need to wrap values in a string. The parser still retains the ability to parse the string form, but the printer will use the keyword form when applicable. Differential Revision: https://reviews.llvm.org/D94575

Author: River707

mlir/integration_test/Dialect/Linalg/CPU/matmul-vs-matvec.mlir

@@ -55,7 +55,7 @@ func @main() {
  scf.for %j = %c0 to %n step %c1 {
  %e1 = load %C1[%i, %j] : memref<?x?xf32>
  %e2 = load %C2[%i, %j] : memref<?x?xf32>
- %c = cmpf "oeq", %e1, %e2 : f32
+ %c = cmpf oeq, %e1, %e2 : f32
  assert %c, "Matmul does not produce same output as matvec"
  }
  }

mlir/test/Analysis/test-dominance.mlir

@@ -51,7 +51,7 @@ func @func_condBranch(%cond : i1) {
 func @func_loop(%arg0 : i32, %arg1 : i32) {
  br ^loopHeader(%arg0 : i32)
 ^loopHeader(%counter : i32):
- %lessThan = cmpi "slt", %counter, %arg1 : i32
+ %lessThan = cmpi slt, %counter, %arg1 : i32
  cond_br %lessThan, ^loopBody, ^exit
 ^loopBody:
  %const0 = constant 1 : i32
@@ -155,7 +155,7 @@ func @func_loop_nested_region(
  %arg4 : index) {
  br ^loopHeader(%arg0 : i32)
 ^loopHeader(%counter : i32):
- %lessThan = cmpi "slt", %counter, %arg1 : i32
+ %lessThan = cmpi slt, %counter, %arg1 : i32
  cond_br %lessThan, ^loopBody, ^exit
 ^loopBody:
  %const0 = constant 1 : i32

mlir/test/Analysis/test-liveness.mlir

@@ -84,7 +84,7 @@ func @func_loop(%arg0 : i32, %arg1 : i32) -> i32 {
  // CHECK-NEXT: %2 = cmpi
  // CHECK-NEXT: cond_br
  // CHECK-NEXT: EndLiveness
- %lessThan = cmpi "slt", %counter, %arg1 : i32
+ %lessThan = cmpi slt, %counter, %arg1 : i32
  cond_br %lessThan, ^loopBody(%i : i32), ^exit(%i : i32)
 ^loopBody(%val : i32):
  // CHECK: Block: 2

mlir/test/Conversion/AffineToStandard/lower-affine.mlir

@@ -159,7 +159,7 @@ func private @get_idx() -> (index)
 // CHECK-NEXT: %[[v1:.*]] = muli %[[v0]], %[[cm1]] : index
 // CHECK-NEXT: %[[c20:.*]] = constant 20 : index
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v1]], %[[c20]] : index
-// CHECK-NEXT: %[[v3:.*]] = cmpi "sge", %[[v2]], %[[c0]] : index
+// CHECK-NEXT: %[[v3:.*]] = cmpi sge, %[[v2]], %[[c0]] : index
 // CHECK-NEXT: if %[[v3]] {
 // CHECK-NEXT: call @body(%[[v0:.*]]) : (index) -> ()
 // CHECK-NEXT: }
@@ -180,7 +180,7 @@ func @if_only() {
 // CHECK-NEXT: %[[v1:.*]] = muli %[[v0]], %[[cm1]] : index
 // CHECK-NEXT: %[[c20:.*]] = constant 20 : index
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v1]], %[[c20]] : index
-// CHECK-NEXT: %[[v3:.*]] = cmpi "sge", %[[v2]], %[[c0]] : index
+// CHECK-NEXT: %[[v3:.*]] = cmpi sge, %[[v2]], %[[c0]] : index
 // CHECK-NEXT: if %[[v3]] {
 // CHECK-NEXT: call @body(%[[v0:.*]]) : (index) -> ()
 // CHECK-NEXT: } else {
@@ -205,20 +205,20 @@ func @if_else() {
 // CHECK-NEXT: %[[v1:.*]] = muli %[[v0]], %[[cm1]] : index
 // CHECK-NEXT: %[[c20:.*]] = constant 20 : index
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v1]], %[[c20]] : index
-// CHECK-NEXT: %[[v3:.*]] = cmpi "sge", %[[v2]], %[[c0]] : index
+// CHECK-NEXT: %[[v3:.*]] = cmpi sge, %[[v2]], %[[c0]] : index
 // CHECK-NEXT: if %[[v3]] {
 // CHECK-NEXT: %[[c0_0:.*]] = constant 0 : index
 // CHECK-NEXT: %[[cm10:.*]] = constant -10 : index
 // CHECK-NEXT: %[[v4:.*]] = addi %[[v0]], %[[cm10]] : index
-// CHECK-NEXT: %[[v5:.*]] = cmpi "sge", %[[v4]], %[[c0_0]] : index
+// CHECK-NEXT: %[[v5:.*]] = cmpi sge, %[[v4]], %[[c0_0]] : index
 // CHECK-NEXT: if %[[v5]] {
 // CHECK-NEXT: call @body(%[[v0:.*]]) : (index) -> ()
 // CHECK-NEXT: }
 // CHECK-NEXT: } else {
 // CHECK-NEXT: %[[c0_0:.*]] = constant 0 : index
 // CHECK-NEXT: %[[cm10:.*]] = constant -10 : index
 // CHECK-NEXT: %{{.*}} = addi %[[v0]], %[[cm10]] : index
-// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %[[c0_0]] : index
+// CHECK-NEXT: %{{.*}} = cmpi sge, %{{.*}}, %[[c0_0]] : index
 // CHECK-NEXT: if %{{.*}} {
 // CHECK-NEXT: call @mid(%[[v0:.*]]) : (index) -> ()
 // CHECK-NEXT: }
@@ -249,22 +249,22 @@ func @nested_ifs() {
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v1]], %{{.*}} : index
 // CHECK-NEXT: %[[c1:.*]] = constant 1 : index
 // CHECK-NEXT: %[[v3:.*]] = addi %[[v2]], %[[c1]] : index
-// CHECK-NEXT: %[[v4:.*]] = cmpi "sge", %[[v3]], %[[c0]] : index
+// CHECK-NEXT: %[[v4:.*]] = cmpi sge, %[[v3]], %[[c0]] : index
 // CHECK-NEXT: %[[cm1_0:.*]] = constant -1 : index
 // CHECK-NEXT: %[[v5:.*]] = addi %{{.*}}, %[[cm1_0]] : index
-// CHECK-NEXT: %[[v6:.*]] = cmpi "sge", %[[v5]], %[[c0]] : index
+// CHECK-NEXT: %[[v6:.*]] = cmpi sge, %[[v5]], %[[c0]] : index
 // CHECK-NEXT: %[[v7:.*]] = and %[[v4]], %[[v6]] : i1
 // CHECK-NEXT: %[[cm1_1:.*]] = constant -1 : index
 // CHECK-NEXT: %[[v8:.*]] = addi %{{.*}}, %[[cm1_1]] : index
-// CHECK-NEXT: %[[v9:.*]] = cmpi "sge", %[[v8]], %[[c0]] : index
+// CHECK-NEXT: %[[v9:.*]] = cmpi sge, %[[v8]], %[[c0]] : index
 // CHECK-NEXT: %[[v10:.*]] = and %[[v7]], %[[v9]] : i1
 // CHECK-NEXT: %[[cm1_2:.*]] = constant -1 : index
 // CHECK-NEXT: %[[v11:.*]] = addi %{{.*}}, %[[cm1_2]] : index
-// CHECK-NEXT: %[[v12:.*]] = cmpi "sge", %[[v11]], %[[c0]] : index
+// CHECK-NEXT: %[[v12:.*]] = cmpi sge, %[[v11]], %[[c0]] : index
 // CHECK-NEXT: %[[v13:.*]] = and %[[v10]], %[[v12]] : i1
 // CHECK-NEXT: %[[cm42:.*]] = constant -42 : index
 // CHECK-NEXT: %[[v14:.*]] = addi %{{.*}}, %[[cm42]] : index
-// CHECK-NEXT: %[[v15:.*]] = cmpi "eq", %[[v14]], %[[c0]] : index
+// CHECK-NEXT: %[[v15:.*]] = cmpi eq, %[[v14]], %[[c0]] : index
 // CHECK-NEXT: %[[v16:.*]] = and %[[v13]], %[[v15]] : i1
 // CHECK-NEXT: if %[[v16]] {
 // CHECK-NEXT: call @body(%[[v0:.*]]) : (index) -> ()
@@ -292,7 +292,7 @@ func @if_for() {
 // CHECK-NEXT: %[[v1:.*]] = muli %[[v0]], %[[cm1]] : index
 // CHECK-NEXT: %[[c20:.*]] = constant 20 : index
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v1]], %[[c20]] : index
-// CHECK-NEXT: %[[v3:.*]] = cmpi "sge", %[[v2]], %[[c0]] : index
+// CHECK-NEXT: %[[v3:.*]] = cmpi sge, %[[v2]], %[[c0]] : index
 // CHECK-NEXT: if %[[v3]] {
 // CHECK-NEXT: %[[c0:.*]]{{.*}} = constant 0 : index
 // CHECK-NEXT: %[[c42:.*]]{{.*}} = constant 42 : index
@@ -301,7 +301,7 @@ func @if_for() {
 // CHECK-NEXT: %[[c0_:.*]]{{.*}} = constant 0 : index
 // CHECK-NEXT: %[[cm10:.*]] = constant -10 : index
 // CHECK-NEXT: %[[v4:.*]] = addi %{{.*}}, %[[cm10]] : index
-// CHECK-NEXT: %[[v5:.*]] = cmpi "sge", %[[v4]], %[[c0_:.*]]{{.*}} : index
+// CHECK-NEXT: %[[v5:.*]] = cmpi sge, %[[v4]], %[[c0_:.*]]{{.*}} : index
 // CHECK-NEXT: if %[[v5]] {
 // CHECK-NEXT: call @body2(%[[v0]], %{{.*}}) : (index, index) -> ()
  affine.if #set1(%i) {
@@ -318,7 +318,7 @@ func @if_for() {
 // CHECK-NEXT: %[[c0:.*]]{{.*}} = constant 0 : index
 // CHECK-NEXT: %[[cm10:.*]]{{.*}} = constant -10 : index
 // CHECK-NEXT: %{{.*}} = addi %{{.*}}, %[[cm10:.*]]{{.*}} : index
-// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %[[c0:.*]]{{.*}} : index
+// CHECK-NEXT: %{{.*}} = cmpi sge, %{{.*}}, %[[c0:.*]]{{.*}} : index
 // CHECK-NEXT: if %{{.*}} {
 // CHECK-NEXT: %[[c0_:.*]]{{.*}} = constant 0 : index
 // CHECK-NEXT: %[[c42_:.*]]{{.*}} = constant 42 : index
@@ -346,11 +346,11 @@ func @if_for() {
 // CHECK-NEXT: %[[cm1:.*]] = constant -1 : index
 // CHECK-NEXT: %[[a:.*]] = muli %{{.*}}, %[[cm1]] : index
 // CHECK-NEXT: %[[b:.*]] = addi %[[a]], %{{.*}} : index
-// CHECK-NEXT: %[[c:.*]] = cmpi "sgt", %{{.*}}, %[[b]] : index
+// CHECK-NEXT: %[[c:.*]] = cmpi sgt, %{{.*}}, %[[b]] : index
 // CHECK-NEXT: %[[d:.*]] = select %[[c]], %{{.*}}, %[[b]] : index
 // CHECK-NEXT: %[[c10:.*]] = constant 10 : index
 // CHECK-NEXT: %[[e:.*]] = addi %{{.*}}, %[[c10]] : index
-// CHECK-NEXT: %[[f:.*]] = cmpi "slt", %{{.*}}, %[[e]] : index
+// CHECK-NEXT: %[[f:.*]] = cmpi slt, %{{.*}}, %[[e]] : index
 // CHECK-NEXT: %[[g:.*]] = select %[[f]], %{{.*}}, %[[e]] : index
 // CHECK-NEXT: %[[c1_0:.*]] = constant 1 : index
 // CHECK-NEXT: for %{{.*}} = %[[d]] to %[[g]] step %[[c1_0]] {
@@ -370,22 +370,22 @@ func @loop_min_max(%N : index) {
 
 #map_7_values = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)>
 
-// Check that the "min" (cmpi "slt" + select) reduction sequence is emitted
+// Check that the "min" (cmpi slt + select) reduction sequence is emitted
 // correctly for an affine map with 7 results.
 
 // CHECK-LABEL: func @min_reduction_tree
 // CHECK-NEXT: %[[c0:.*]] = constant 0 : index
-// CHECK-NEXT: %[[c01:.+]] = cmpi "slt", %{{.*}}, %{{.*}} : index
+// CHECK-NEXT: %[[c01:.+]] = cmpi slt, %{{.*}}, %{{.*}} : index
 // CHECK-NEXT: %[[r01:.+]] = select %[[c01]], %{{.*}}, %{{.*}} : index
-// CHECK-NEXT: %[[c012:.+]] = cmpi "slt", %[[r01]], %{{.*}} : index
+// CHECK-NEXT: %[[c012:.+]] = cmpi slt, %[[r01]], %{{.*}} : index
 // CHECK-NEXT: %[[r012:.+]] = select %[[c012]], %[[r01]], %{{.*}} : index
-// CHECK-NEXT: %[[c0123:.+]] = cmpi "slt", %[[r012]], %{{.*}} : index
+// CHECK-NEXT: %[[c0123:.+]] = cmpi slt, %[[r012]], %{{.*}} : index
 // CHECK-NEXT: %[[r0123:.+]] = select %[[c0123]], %[[r012]], %{{.*}} : index
-// CHECK-NEXT: %[[c01234:.+]] = cmpi "slt", %[[r0123]], %{{.*}} : index
+// CHECK-NEXT: %[[c01234:.+]] = cmpi slt, %[[r0123]], %{{.*}} : index
 // CHECK-NEXT: %[[r01234:.+]] = select %[[c01234]], %[[r0123]], %{{.*}} : index
-// CHECK-NEXT: %[[c012345:.+]] = cmpi "slt", %[[r01234]], %{{.*}} : index
+// CHECK-NEXT: %[[c012345:.+]] = cmpi slt, %[[r01234]], %{{.*}} : index
 // CHECK-NEXT: %[[r012345:.+]] = select %[[c012345]], %[[r01234]], %{{.*}} : index
-// CHECK-NEXT: %[[c0123456:.+]] = cmpi "slt", %[[r012345]], %{{.*}} : index
+// CHECK-NEXT: %[[c0123456:.+]] = cmpi slt, %[[r012345]], %{{.*}} : index
 // CHECK-NEXT: %[[r0123456:.+]] = select %[[c0123456]], %[[r012345]], %{{.*}} : index
 // CHECK-NEXT: %[[c1:.*]] = constant 1 : index
 // CHECK-NEXT: for %{{.*}} = %[[c0]] to %[[r0123456]] step %[[c1]] {
@@ -478,7 +478,7 @@ func @affine_apply_mod(%arg0 : index) -> (index) {
 // CHECK-NEXT: %[[c42:.*]] = constant 42 : index
 // CHECK-NEXT: %[[v0:.*]] = remi_signed %{{.*}}, %[[c42]] : index
 // CHECK-NEXT: %[[c0:.*]] = constant 0 : index
-// CHECK-NEXT: %[[v1:.*]] = cmpi "slt", %[[v0]], %[[c0]] : index
+// CHECK-NEXT: %[[v1:.*]] = cmpi slt, %[[v0]], %[[c0]] : index
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v0]], %[[c42]] : index
 // CHECK-NEXT: %[[v3:.*]] = select %[[v1]], %[[v2]], %[[v0]] : index
  %0 = affine.apply #mapmod (%arg0)
@@ -497,7 +497,7 @@ func @affine_apply_floordiv(%arg0 : index) -> (index) {
 // CHECK-NEXT: %[[c42:.*]] = constant 42 : index
 // CHECK-NEXT: %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT: %[[cm1:.*]] = constant -1 : index
-// CHECK-NEXT: %[[v0:.*]] = cmpi "slt", %{{.*}}, %[[c0]] : index
+// CHECK-NEXT: %[[v0:.*]] = cmpi slt, %{{.*}}, %[[c0]] : index
 // CHECK-NEXT: %[[v1:.*]] = subi %[[cm1]], %{{.*}} : index
 // CHECK-NEXT: %[[v2:.*]] = select %[[v0]], %[[v1]], %{{.*}} : index
 // CHECK-NEXT: %[[v3:.*]] = divi_signed %[[v2]], %[[c42]] : index
@@ -519,7 +519,7 @@ func @affine_apply_ceildiv(%arg0 : index) -> (index) {
 // CHECK-NEXT: %[[c42:.*]] = constant 42 : index
 // CHECK-NEXT: %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT: %[[c1:.*]] = constant 1 : index
-// CHECK-NEXT: %[[v0:.*]] = cmpi "sle", %{{.*}}, %[[c0]] : index
+// CHECK-NEXT: %[[v0:.*]] = cmpi sle, %{{.*}}, %[[c0]] : index
 // CHECK-NEXT: %[[v1:.*]] = subi %[[c0]], %{{.*}} : index
 // CHECK-NEXT: %[[v2:.*]] = subi %{{.*}}, %[[c1]] : index
 // CHECK-NEXT: %[[v3:.*]] = select %[[v0]], %[[v1]], %[[v2]] : index
@@ -624,7 +624,7 @@ func @affine_min(%arg0: index, %arg1: index) -> index{
  // CHECK: %[[Cm2:.*]] = constant -1
  // CHECK: %[[neg2:.*]] = muli %[[ARG0]], %[[Cm2:.*]]
  // CHECK: %[[second:.*]] = addi %[[ARG1]], %[[neg2]]
- // CHECK: %[[cmp:.*]] = cmpi "slt", %[[first]], %[[second]]
+ // CHECK: %[[cmp:.*]] = cmpi slt, %[[first]], %[[second]]
  // CHECK: select %[[cmp]], %[[first]], %[[second]]
  %0 = affine.min affine_map<(d0,d1) -> (d0 - d1, d1 - d0)>(%arg0, %arg1)
  return %0 : index
@@ -639,7 +639,7 @@ func @affine_max(%arg0: index, %arg1: index) -> index{
  // CHECK: %[[Cm2:.*]] = constant -1
  // CHECK: %[[neg2:.*]] = muli %[[ARG0]], %[[Cm2:.*]]
  // CHECK: %[[second:.*]] = addi %[[ARG1]], %[[neg2]]
- // CHECK: %[[cmp:.*]] = cmpi "sgt", %[[first]], %[[second]]
+ // CHECK: %[[cmp:.*]] = cmpi sgt, %[[first]], %[[second]]
  // CHECK: select %[[cmp]], %[[first]], %[[second]]
  %0 = affine.max affine_map<(d0,d1) -> (d0 - d1, d1 - d0)>(%arg0, %arg1)
  return %0 : index

mlir/test/Conversion/LinalgToSPIRV/linalg-to-spirv.mlir

@@ -32,7 +32,7 @@ module attributes {
 // CHECK: %[[ADD:.+]] = spv.GroupNonUniformIAdd "Subgroup" "Reduce" %[[VAL]] : i32
 
 // CHECK: %[[OUTPTR:.+]] = spv.AccessChain %[[OUTPUT]][%[[ZERO]], %[[ZERO]]]
-// CHECK: %[[ELECT:.+]] = spv.GroupNonUniformElect "Subgroup" : i1
+// CHECK: %[[ELECT:.+]] = spv.GroupNonUniformElect Subgroup : i1
 
 // CHECK: spv.selection {
 // CHECK: spv.BranchConditional %[[ELECT]], ^bb1, ^bb2

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

@@ -11,7 +11,7 @@ func @branch_loop() {
  // CHECK-NEXT: ^[[BB1]](%[[ARG1:[0-9]+]]: i64, %[[ARG2:[0-9]+]]: i64):{{.*}}
  ^bb1(%0: index, %1: index):
  // CHECK-NEXT: %[[CMP:[0-9]+]] = llvm.icmp "slt" %[[ARG1]], %[[ARG2]] : i64
- %2 = cmpi "slt", %0, %1 : index
+ %2 = cmpi slt, %0, %1 : index
  // CHECK-NEXT: llvm.cond_br %[[CMP]], ^[[BB2:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64), ^[[BB3:.*]]
  cond_br %2, ^bb2(%end, %end : index, index), ^bb3
  // CHECK-NEXT: ^[[BB2]](%[[ARG3:[0-9]+]]: i64, %[[ARG4:[0-9]+]]: i64):

mlir/test/Conversion/SCFToGPU/parallel_loop.mlir

@@ -284,10 +284,10 @@ module {
 // CHECK: [[VAL_43:%.*]] = affine.min #[[$MAP4]]([[VAL_29]]){{\[}}[[VAL_42]]]
 // CHECK: [[VAL_44:%.*]] = subview [[VAL_2]]{{\[}}[[VAL_28]], [[VAL_29]]] {{\[}}[[VAL_41]], [[VAL_43]]] {{\[}}%[[C1]], %[[C1]]] : memref<?x?xf32, #[[$MAP0]]> to memref<?x?xf32, #[[$MAP5]]>
 // CHECK: [[VAL_45:%.*]] = affine.apply #[[$MAP2]]([[VAL_22]]){{\[}}%[[C1]], %[[C0]]]
-// CHECK: [[VAL_46:%.*]] = cmpi "slt", [[VAL_45]], [[VAL_31_SQUARED]] : index
+// CHECK: [[VAL_46:%.*]] = cmpi slt, [[VAL_45]], [[VAL_31_SQUARED]] : index
 // CHECK: scf.if [[VAL_46]] {
 // CHECK: [[VAL_47:%.*]] = affine.apply #[[$MAP2]]([[VAL_23]]){{\[}}%[[C1]], %[[C0]]]
-// CHECK: [[VAL_48:%.*]] = cmpi "slt", [[VAL_47]], [[VAL_33]] : index
+// CHECK: [[VAL_48:%.*]] = cmpi slt, [[VAL_47]], [[VAL_33]] : index
 // CHECK: scf.if [[VAL_48]] {
 // CHECK: [[VAL_49:%.*]] = load [[VAL_34]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
 // CHECK: [[VAL_50:%.*]] = load [[VAL_39]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>

mlir/test/Conversion/SCFToStandard/convert-to-cfg.mlir

@@ -3,7 +3,7 @@
 // CHECK-LABEL: func @simple_std_for_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 // CHECK-NEXT: br ^bb1(%{{.*}} : index)
 // CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb2
-// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
+// CHECK-NEXT: %{{.*}} = cmpi slt, %{{.*}}, %{{.*}} : index
 // CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb3
 // CHECK-NEXT: ^bb2: // pred: ^bb1
 // CHECK-NEXT: %{{.*}} = constant 1 : index
@@ -21,13 +21,13 @@ func @simple_std_for_loop(%arg0 : index, %arg1 : index, %arg2 : index) {
 // CHECK-LABEL: func @simple_std_2_for_loops(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 // CHECK-NEXT: br ^bb1(%{{.*}} : index)
 // CHECK-NEXT: ^bb1(%[[ub0:.*]]: index): // 2 preds: ^bb0, ^bb5
-// CHECK-NEXT: %[[cond0:.*]] = cmpi "slt", %[[ub0]], %{{.*}} : index
+// CHECK-NEXT: %[[cond0:.*]] = cmpi slt, %[[ub0]], %{{.*}} : index
 // CHECK-NEXT: cond_br %[[cond0]], ^bb2, ^bb6
 // CHECK-NEXT: ^bb2: // pred: ^bb1
 // CHECK-NEXT: %{{.*}} = constant 1 : index
 // CHECK-NEXT: br ^bb3(%{{.*}} : index)
 // CHECK-NEXT: ^bb3(%[[ub1:.*]]: index): // 2 preds: ^bb2, ^bb4
-// CHECK-NEXT: %[[cond1:.*]] = cmpi "slt", %{{.*}}, %{{.*}} : index
+// CHECK-NEXT: %[[cond1:.*]] = cmpi slt, %{{.*}}, %{{.*}} : index
 // CHECK-NEXT: cond_br %[[cond1]], ^bb4, ^bb5
 // CHECK-NEXT: ^bb4: // pred: ^bb3
 // CHECK-NEXT: %{{.*}} = constant 1 : index
@@ -111,7 +111,7 @@ func @simple_std_2_ifs(%arg0: i1) {
 // CHECK-LABEL: func @simple_std_for_loop_with_2_ifs(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: i1) {
 // CHECK-NEXT: br ^bb1(%{{.*}} : index)
 // CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb7
-// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
+// CHECK-NEXT: %{{.*}} = cmpi slt, %{{.*}}, %{{.*}} : index
 // CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb8
 // CHECK-NEXT: ^bb2: // pred: ^bb1
 // CHECK-NEXT: %{{.*}} = constant 1 : index
@@ -230,12 +230,12 @@ func @nested_if_yield(%arg0: i1) -> (index) {
 // CHECK: [[VAL_5:%.*]] = constant 1 : index
 // CHECK: br ^bb1([[VAL_0]] : index)
 // CHECK: ^bb1([[VAL_6:%.*]]: index):
-// CHECK: [[VAL_7:%.*]] = cmpi "slt", [[VAL_6]], [[VAL_2]] : index
+// CHECK: [[VAL_7:%.*]] = cmpi slt, [[VAL_6]], [[VAL_2]] : index
 // CHECK: cond_br [[VAL_7]], ^bb2, ^bb6
 // CHECK: ^bb2:
 // CHECK: br ^bb3([[VAL_1]] : index)
 // CHECK: ^bb3([[VAL_8:%.*]]: index):
-// CHECK: [[VAL_9:%.*]] = cmpi "slt", [[VAL_8]], [[VAL_3]] : index
+// CHECK: [[VAL_9:%.*]] = cmpi slt, [[VAL_8]], [[VAL_3]] : index
 // CHECK: cond_br [[VAL_9]], ^bb4, ^bb5
 // CHECK: ^bb4:
 // CHECK: [[VAL_10:%.*]] = constant 1 : index
@@ -265,7 +265,7 @@ func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
 // CHECK: br ^[[COND:.*]](%[[LB]], %[[INIT0]], %[[INIT1]] : index, f32, f32)
 //
 // CHECK: ^[[COND]](%[[ITER:.*]]: index, %[[ITER_ARG0:.*]]: f32, %[[ITER_ARG1:.*]]: f32):
-// CHECK: %[[CMP:.*]] = cmpi "slt", %[[ITER]], %[[UB]] : index
+// CHECK: %[[CMP:.*]] = cmpi slt, %[[ITER]], %[[UB]] : index
 // CHECK: cond_br %[[CMP]], ^[[BODY:.*]], ^[[CONTINUE:.*]]
 //
 // CHECK: ^[[BODY]]:
@@ -330,7 +330,7 @@ func @simple_parallel_reduce_loop(%arg0: index, %arg1: index,
  // Condition branch takes as arguments the current value of the iteration
  // variable and the current partially reduced value.
  // CHECK: ^[[COND]](%[[ITER:.*]]: index, %[[ITER_ARG:.*]]: f32
- // CHECK: %[[COMP:.*]] = cmpi "slt", %[[ITER]], %[[UB]]
+ // CHECK: %[[COMP:.*]] = cmpi slt, %[[ITER]], %[[UB]]
  // CHECK: cond_br %[[COMP]], ^[[BODY:.*]], ^[[CONTINUE:.*]]
 
  // Bodies of scf.reduce operations are folded into the main loop body. The
@@ -551,7 +551,7 @@ func @nested_while_ops(%arg0: f32) -> i64 {
 func @ifs_in_parallel(%arg1: index, %arg2: index, %arg3: index, %arg4: i1, %arg5: i1) {
  // CHECK: br ^[[LOOP_LATCH:.*]](%[[ARG0]] : index)
  // CHECK: ^[[LOOP_LATCH]](%[[LOOP_IV:.*]]: index):
- // CHECK: %[[LOOP_COND:.*]] = cmpi "slt", %[[LOOP_IV]], %[[ARG1]] : index
+ // CHECK: %[[LOOP_COND:.*]] = cmpi slt, %[[LOOP_IV]], %[[ARG1]] : index
  // CHECK: cond_br %[[LOOP_COND]], ^[[LOOP_BODY:.*]], ^[[LOOP_CONT:.*]]
  // CHECK: ^[[LOOP_BODY]]:
  // CHECK: cond_br %[[ARG3]], ^[[IF1_THEN:.*]], ^[[IF1_CONT:.*]]