[testsuite] Make testsuite more stable vs canonicalization change. NFC.

[lattner]

This is staging in the mechanical testsuite parts of the canonicalizer change that got reverted in a way that works both before-and-after that change.

[rriddle]

Can you link to the accompanying canonicalizer revision?

mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir

383

Why drop these?

[lattner]

The canonicalizer changes are from this patch (which got reverted):
https://reviews.llvm.org/rGb5d9a3c92358349d5444ab28de8ab5b2bee33a01

I'll reapply them in a follow-on. I'll also address the comments above, thanks!

[lattner]

Fix dropped check lines

mlir/test/Conversion/StandardToSPIRV/legalization.mlir

func @fold_dynamic_stride_subview_with_store(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index, %arg5 : index, %arg6 : index, %arg7 : f32) {
   memref.store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]>
   return
 }
 
 // CHECK-LABEL: @fold_static_stride_subview_with_transfer_read
 // CHECK-SAME: [[ARG0:%.*]]: memref<12x32xf32>, [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index
 func @fold_static_stride_subview_with_transfer_read(%arg0 : memref<12x32xf32>, %arg1 : index, %arg2 : index, %arg3 : index, %arg4 : index) -> vector<4xf32> {
   // CHECK-NOT: memref.subview
-  // CHECK: [[F1:%.*]] = constant 1.000000e+00 : f32
-  // CHECK: [[C2:%.*]] = constant 2 : index
-  // CHECK: [[C3:%.*]] = constant 3 : index
+  // CHECK-DAG: [[F1:%.*]] = constant 1.000000e+00 : f32
+  // CHECK-DAG: [[C2:%.*]] = constant 2 : index
+  // CHECK-DAG: [[C3:%.*]] = constant 3 : index
   // CHECK: [[STRIDE1:%.*]] = muli [[ARG3]], [[C2]] : index
   // CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index
   // CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[C3]] : index
   // CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index
   // CHECK: vector.transfer_read [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}, [[F1]] {masked = [false]}
   %f1 = constant 1.0 : f32
   %0 = memref.subview %arg0[%arg1, %arg2][4, 4][2, 3] : memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [64, 3]>
   %1 = vector.transfer_read %0[%arg3, %arg4], %f1 {masked = [false]} : memref<4x4xf32, offset:?, strides: [64, 3]>, vector<4xf32>

mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir

 //  CHECK-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  CHECK-SAME:   %[[base:[a-zA-Z0-9]+]]: index
 
 // FULL-UNROLL-LABEL: transfer_read_progressive(
 //  FULL-UNROLL-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  FULL-UNROLL-SAME:   %[[base:[a-zA-Z0-9]+]]: index
 
 func @transfer_read_progressive(%A : memref<?x?xf32>, %base: index) -> vector<3x15xf32> {
-  // CHECK: %[[cst:.*]] = constant 7.000000e+00 : f32
   %f7 = constant 7.0: f32
-
+  // CHECK-DAG: %[[C0:.*]] = constant 0 : index
   // CHECK-DAG: %[[splat:.*]] = constant dense<7.000000e+00> : vector<15xf32>
   // CHECK-DAG: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
-  // CHECK-DAG: %[[C0:.*]] = constant 0 : index
   // CHECK-DAG: %[[dim:.*]] = memref.dim %[[A]], %[[C0]] : memref<?x?xf32>
   // CHECK: affine.for %[[I:.*]] = 0 to 3 {
   // CHECK:   %[[add:.*]] = affine.apply #[[$MAP0]](%[[I]])[%[[base]]]
   // CHECK:   %[[cond1:.*]] = cmpi slt, %[[add]], %[[dim]] : index
   // CHECK:   scf.if %[[cond1]] {
-  // CHECK:     %[[vec_1d:.*]] = vector.transfer_read %[[A]][%[[add]], %[[base]]], %[[cst]] : memref<?x?xf32>, vector<15xf32>
+  // CHECK:     %[[vec_1d:.*]] = vector.transfer_read %[[A]][%[[add]], %[[base]]], %cst : memref<?x?xf32>, vector<15xf32>
   // CHECK:     store %[[vec_1d]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>>
   // CHECK:   } else {
   // CHECK:     store %[[splat]], %[[alloc]][%[[I]]] : memref<3xvector<15xf32>>
   // CHECK:   }
   // CHECK: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>>
   // CHECK: %[[cst:.*]] = memref.load %[[vmemref]][] : memref<vector<3x15xf32>>
 
-  // FULL-UNROLL: %[[pad:.*]] = constant 7.000000e+00 : f32
   // FULL-UNROLL: %[[VEC0:.*]] = constant dense<7.000000e+00> : vector<3x15xf32>
   // FULL-UNROLL: %[[C0:.*]] = constant 0 : index
   // FULL-UNROLL: %[[SPLAT:.*]] = constant dense<7.000000e+00> : vector<15xf32>
   // FULL-UNROLL: %[[DIM:.*]] = memref.dim %[[A]], %[[C0]] : memref<?x?xf32>
   // FULL-UNROLL: cmpi slt, %[[base]], %[[DIM]] : index
   // FULL-UNROLL: %[[VEC1:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) {
-  // FULL-UNROLL:   vector.transfer_read %[[A]][%[[base]], %[[base]]], %[[pad]] : memref<?x?xf32>, vector<15xf32>
+  // FULL-UNROLL:   vector.transfer_read %[[A]][%[[base]], %[[base]]], %cst : memref<?x?xf32>, vector<15xf32>
   // FULL-UNROLL:   vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32>
   // FULL-UNROLL:   scf.yield %{{.*}} : vector<3x15xf32>
   // FULL-UNROLL: } else {
   // FULL-UNROLL:   vector.insert %{{.*}}, %[[VEC0]] [0] : vector<15xf32> into vector<3x15xf32>
   // FULL-UNROLL:   scf.yield %{{.*}} : vector<3x15xf32>
   // FULL-UNROLL: }
   // FULL-UNROLL: affine.apply #[[$MAP1]]()[%[[base]]]
   // FULL-UNROLL: cmpi slt, %{{.*}}, %[[DIM]] : index
   // FULL-UNROLL: %[[VEC2:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) {
-  // FULL-UNROLL:   vector.transfer_read %[[A]][%{{.*}}, %[[base]]], %[[pad]] : memref<?x?xf32>, vector<15xf32>
+  // FULL-UNROLL:   vector.transfer_read %[[A]][%{{.*}}, %[[base]]], %cst : memref<?x?xf32>, vector<15xf32>
   // FULL-UNROLL:   vector.insert %{{.*}}, %[[VEC1]] [1] : vector<15xf32> into vector<3x15xf32>
   // FULL-UNROLL:   scf.yield %{{.*}} : vector<3x15xf32>
   // FULL-UNROLL: } else {
   // FULL-UNROLL:   vector.insert %{{.*}}, %[[VEC1]] [1] : vector<15xf32> into vector<3x15xf32>
   // FULL-UNROLL:   scf.yield %{{.*}} : vector<3x15xf32>
   // FULL-UNROLL: }
   // FULL-UNROLL: affine.apply #[[$MAP2]]()[%[[base]]]
   // FULL-UNROLL: cmpi slt, %{{.*}}, %[[DIM]] : index
   // FULL-UNROLL: %[[VEC3:.*]] = scf.if %{{.*}} -> (vector<3x15xf32>) {
-  // FULL-UNROLL:   vector.transfer_read %[[A]][%{{.*}}, %[[base]]], %[[pad]] : memref<?x?xf32>, vector<15xf32>
+  // FULL-UNROLL:   vector.transfer_read %[[A]][%{{.*}}, %[[base]]], %cst : memref<?x?xf32>, vector<15xf32>
   // FULL-UNROLL:   vector.insert %{{.*}}, %[[VEC2]] [2] : vector<15xf32> into vector<3x15xf32>
   // FULL-UNROLL:   scf.yield %{{.*}} : vector<3x15xf32>
   // FULL-UNROLL: } else {
   // FULL-UNROLL:   vector.insert %{{.*}}, %[[VEC2]] [2] : vector<15xf32> into vector<3x15xf32>
   // FULL-UNROLL:   scf.yield %{{.*}} : vector<3x15xf32>
   // FULL-UNROLL: }
 
   %f = vector.transfer_read %A[%base, %base], %f7 :
func @transfer_read_minor_identity(%A : memref<?x?x?x?xf32>) -> vector<3x3xf32> {
   %0 = vector.transfer_read %A[%c0, %c0, %c0, %c0], %f0
     { permutation_map = affine_map<(d0, d1, d2, d3) -> (d2, d3)> }
       : memref<?x?x?x?xf32>, vector<3x3xf32>
   return %0 : vector<3x3xf32>
 }
 
 // CHECK-LABEL: transfer_read_minor_identity(
 //  CHECK-SAME:   %[[A:.*]]: memref<?x?x?x?xf32>) -> vector<3x3xf32>
-//       CHECK:   %[[c0:.*]] = constant 0 : index
-//       CHECK:   %[[cst:.*]] = constant 0.000000e+00 : f32
-//       CHECK:   %[[c2:.*]] = constant 2 : index
-//       CHECK:   %[[cst0:.*]] = constant dense<0.000000e+00> : vector<3xf32>
+//  CHECK-DAG:   %[[c0:.*]] = constant 0 : index
+//  CHECK-DAG:   %cst = constant 0.000000e+00 : f32
+//       CHECK-DAG:   %[[c2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[cst0:.*]] = constant dense<0.000000e+00> : vector<3xf32>
 //       CHECK:   %[[m:.*]] = memref.alloca() : memref<3xvector<3xf32>>
 //       CHECK:   %[[d:.*]] = memref.dim %[[A]], %[[c2]] : memref<?x?x?x?xf32>
 //       CHECK:   affine.for %[[arg1:.*]] = 0 to 3 {
 //       CHECK:      %[[cmp:.*]] = cmpi slt, %[[arg1]], %[[d]] : index
 //       CHECK:      scf.if %[[cmp]] {
-//       CHECK:        %[[tr:.*]] = vector.transfer_read %[[A]][%[[c0]], %[[c0]], %[[arg1]], %[[c0]]], %[[cst]] : memref<?x?x?x?xf32>, vector<3xf32>
+//       CHECK:        %[[tr:.*]] = vector.transfer_read %[[A]][%c0, %c0, %[[arg1]], %c0], %cst : memref<?x?x?x?xf32>, vector<3xf32>
 //       CHECK:        store %[[tr]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>>
 //       CHECK:      } else {
 //       CHECK:        store %[[cst0]], %[[m]][%[[arg1]]] : memref<3xvector<3xf32>>
 //       CHECK:      }
 //       CHECK:    }
 //       CHECK:    %[[cast:.*]] = vector.type_cast %[[m]] : memref<3xvector<3xf32>> to memref<vector<3x3xf32>>
 //       CHECK:    %[[ret:.*]]  = memref.load %[[cast]][] : memref<vector<3x3xf32>>
 //       CHECK:    return %[[ret]] : vector<3x3xf32>
 
 func @transfer_write_minor_identity(%A : vector<3x3xf32>, %B : memref<?x?x?x?xf32>) {
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
   vector.transfer_write %A, %B[%c0, %c0, %c0, %c0]
     { permutation_map = affine_map<(d0, d1, d2, d3) -> (d2, d3)> }
       : vector<3x3xf32>, memref<?x?x?x?xf32>
   return
 }
 
 // CHECK-LABEL: transfer_write_minor_identity(
 //  CHECK-SAME:   %[[A:.*]]: vector<3x3xf32>,
 //  CHECK-SAME:   %[[B:.*]]: memref<?x?x?x?xf32>)
-//       CHECK:   %[[c0:.*]] = constant 0 : index
-//       CHECK:   %[[c2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[c2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[c0:.*]] = constant 0 : index
 //       CHECK:   %[[m:.*]] = memref.alloca() : memref<3xvector<3xf32>>
 //       CHECK:   %[[cast:.*]] = vector.type_cast %[[m]] : memref<3xvector<3xf32>> to memref<vector<3x3xf32>>
 //       CHECK:   store %[[A]], %[[cast]][] : memref<vector<3x3xf32>>
 //       CHECK:   %[[d:.*]] = memref.dim %[[B]], %[[c2]] : memref<?x?x?x?xf32>
 //       CHECK:   affine.for %[[arg2:.*]] = 0 to 3 {
 //       CHECK:      %[[cmp:.*]] = cmpi slt, %[[arg2]], %[[d]] : index
 //       CHECK:      scf.if %[[cmp]] {
 //       CHECK:        %[[tmp:.*]] = memref.load %[[m]][%[[arg2]]] : memref<3xvector<3xf32>>

mlir/test/Dialect/Linalg/sparse_2d.mlir

#trait_scale = {
   ],
   iterator_types = ["parallel", "parallel"],
   doc = "X(i,j) = A(i,j) * SCALE"
 }
 
 // CHECK-LABEL:   func @scale(
 // CHECK-SAME:                %[[VAL_0:.*]]: tensor<?x?xf64>,
 // CHECK-SAME:                %[[VAL_1:.*]]: tensor<?x?xf64>) -> tensor<?x?xf64> {
-// CHECK:           %[[VAL_2:.*]] = constant 2.000000e+00 : f64
-// CHECK:           %[[VAL_3:.*]] = constant 0 : index
-// CHECK:           %[[VAL_4:.*]] = constant 1 : index
+// CHECK-DAG:           %[[VAL_3:.*]] = constant 0 : index
+// CHECK-DAG:           %[[VAL_4:.*]] = constant 1 : index
+// CHECK-DAG:           %[[VAL_2:.*]] = constant 2.000000e+00 : f64
 // CHECK:           %[[VAL_5:.*]] = linalg.sparse_pointers %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex>
 // CHECK:           %[[VAL_6:.*]] = linalg.sparse_indices %[[VAL_0]], %[[VAL_4]] : tensor<?x?xf64> to memref<?xindex>
 // CHECK:           %[[VAL_7:.*]] = linalg.sparse_values %[[VAL_0]] : tensor<?x?xf64> to memref<?xf64>
 // CHECK:           %[[VAL_8:.*]] = memref.dim %[[VAL_1]], %[[VAL_3]] : tensor<?x?xf64>
 // CHECK:           %[[VAL_9:.*]] = memref.dim %[[VAL_1]], %[[VAL_4]] : tensor<?x?xf64>
 // CHECK:           %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_1]] : memref<?x?xf64>
 // CHECK:           %[[VAL_11:.*]] = memref.alloc(%[[VAL_8]], %[[VAL_9]]) : memref<?x?xf64>
 // CHECK:           linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<?x?xf64>, memref<?x?xf64>

mlir/test/Dialect/Quant/convert-const.mlir

func @const_custom_storage_range_i8_fixedpoint() -> tensor<7xf32> {
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies quantization results of all-0.0 tensors are quantized to zero points.
 // CHECK-LABEL: zero_tensors_to_zero_points
 func @zero_tensors_to_zero_points() -> (tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>) {
 
-// CHECK: %[[cst:.*]] = constant dense<-127> : tensor<7xi8>
-// CHECK: %[[cst0:.*]] = constant dense<0> : tensor<7xi8>
-// CHECK: %[[cst1:.*]] = constant dense<1> : tensor<7xi8>
+// CHECK-DAG: %[[cst1:.*]] = constant dense<1> : tensor<7xi8>
+// CHECK-DAG: %[[cst:.*]] = constant dense<-127> : tensor<7xi8>
+// CHECK-DAG: %[[cst0:.*]] = constant dense<0> : tensor<7xi8>
 // CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8:f32, 1.000000e+00>>
 // CHECK: "quant.scast"(%[[cst]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<i8<-127:127>:f32, 1.000000e+00:-127>>
 // CHECK: "quant.scast"(%[[cst0]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8:f32, 1.000000e+00>>
 // CHECK: "quant.scast"(%[[cst1]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>
 
   %cst = constant dense<0.0> : tensor<7xf32>
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8:f32, 1.0>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8:f32, 1.0>>) -> (tensor<7xf32>)
// CHECK: "quant.scast"(%[[cst1]]) : (tensor<7xi8>) -> tensor<7x!quant.uniform<u8<1:255>:f32, 1.000000e+00:1>>
   return %2, %4, %6, %8 : tensor<7xf32>, tensor<7xf32>, tensor<7xf32>, tensor<7xf32>
 }
 
 // -----
 // Verifies per-axis quantization results for dense.
 // CHECK-LABEL: per_axis_dense_quantization
 func @per_axis_dense_quantization() -> (tensor<2x3xf32>, tensor<2x3xf32>) {
 
-// CHECK-NEXT: %[[cst:.*]] = constant dense<{{\[}}[-128, 64, 127], [0, 1, 2]]> : tensor<2x3xi8>
-// CHECK-NEXT: %[[cst0:.*]] = constant dense<{{\[}}[-128, -1, 1], [127, 1, 3]]> : tensor<2x3xi8>
+// CHECK-DAG: %[[cst0:.*]] = constant dense<{{\[}}[-128, -1, 1], [127, 1, 3]]> : tensor<2x3xi8>
+// CHECK-DAG: %[[cst:.*]] = constant dense<{{\[}}[-128, 64, 127], [0, 1, 2]]> : tensor<2x3xi8>
 // CHECK: "quant.scast"(%[[cst]]) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128,1.000000e+00}>>
-// CHECK: "quant.scast"(%cst_0) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128,1.000000e+00,1.000000e+00:1}>>
+// CHECK: "quant.scast"(%[[cst0]]) : (tensor<2x3xi8>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128,1.000000e+00,1.000000e+00:1}>>
 
   %cst = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32>
   %1 = "quant.qcast"(%cst) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>
   %2 = "quant.dcast"(%1) : (tensor<2x3x!quant.uniform<i8:f32:0, {7.812500e-03:128, 1.0}>>) -> (tensor<2x3xf32>)
 
   %cst0 = constant dense<[[-2.0, -0.5, 0.0], [0.0, 1.0, 2.0]]> : tensor<2x3xf32>
   %3 = "quant.qcast"(%cst0) : (tensor<2x3xf32>) -> tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>
   %4 = "quant.dcast"(%3) : (tensor<2x3x!quant.uniform<i8:f32:1, {7.812500e-03:128, 1.0, 1.0:1}>>) -> (tensor<2x3xf32>)
 
   return %2, %4 : tensor<2x3xf32>, tensor<2x3xf32>
 }

mlir/test/Dialect/SCF/canonicalize.mlir

scf.parallel (%i0, %i1, %i2) = (%c0, %c3, %c7) to (%c1, %c6, %c10) step (%c1, %c2, %c3) {
     memref.store %c42, %A[%i0, %i1, %i2] : memref<?x?x?xi32>
     scf.yield
   }
   return
 }
 
 // CHECK-LABEL:   func @single_iteration(
 // CHECK-SAME:                        [[ARG0:%.*]]: memref<?x?x?xi32>) {
-// CHECK:           [[C42:%.*]] = constant 42 : i32
-// CHECK:           [[C0:%.*]] = constant 0 : index
-// CHECK:           [[C2:%.*]] = constant 2 : index
-// CHECK:           [[C3:%.*]] = constant 3 : index
-// CHECK:           [[C6:%.*]] = constant 6 : index
-// CHECK:           [[C7:%.*]] = constant 7 : index
+// CHECK-DAG:           [[C42:%.*]] = constant 42 : i32
+// CHECK-DAG:           [[C7:%.*]] = constant 7 : index
+// CHECK-DAG:           [[C6:%.*]] = constant 6 : index
+// CHECK-DAG:           [[C3:%.*]] = constant 3 : index
+// CHECK-DAG:           [[C2:%.*]] = constant 2 : index
+// CHECK-DAG:           [[C0:%.*]] = constant 0 : index
 // CHECK:           scf.parallel ([[V0:%.*]]) = ([[C3]]) to ([[C6]]) step ([[C2]]) {
 // CHECK:             memref.store [[C42]], [[ARG0]]{{\[}}[[C0]], [[V0]], [[C7]]] : memref<?x?x?xi32>
 // CHECK:             scf.yield
 // CHECK:           }
 // CHECK:           return
 
 // -----
 

mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir

 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.CompositeExtract
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: extract_vector
 func @extract_vector() -> (i32, i32, i32) {
-  // CHECK: spv.Constant 42 : i32
-  // CHECK: spv.Constant -33 : i32
-  // CHECK: spv.Constant 6 : i32
+  // CHECK-DAG: spv.Constant 6 : i32
+  // CHECK-DAG: spv.Constant -33 : i32
+  // CHECK-DAG: spv.Constant 42 : i32
   %0 = spv.Constant dense<[42, -33, 6]> : vector<3xi32>
   %1 = spv.CompositeExtract %0[0 : i32] : vector<3xi32>
   %2 = spv.CompositeExtract %0[1 : i32] : vector<3xi32>
   %3 = spv.CompositeExtract %0[2 : i32] : vector<3xi32>
   return %1, %2, %3 : i32, i32, i32
 }
 
 // -----
 
 // CHECK-LABEL: extract_array_final
 func @extract_array_final() -> (i32, i32) {
-  // CHECK: spv.Constant 4 : i32
-  // CHECK: spv.Constant -5 : i32
+  // CHECK-DAG: spv.Constant -5 : i32
+  // CHECK-DAG: spv.Constant 4 : i32
   %0 = spv.Constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
   %1 = spv.CompositeExtract %0[0 : i32, 0 : i32] : !spv.array<1 x vector<2 x i32>>
   %2 = spv.CompositeExtract %0[0 : i32, 1 : i32] : !spv.array<1 x vector<2 x i32>>
   return %1, %2 : i32, i32
 }
 
 // -----
 
func @iadd_zero(%arg0: i32) -> (i32, i32) {
   return %0, %1: i32, i32
 }
 
 // CHECK-LABEL: @const_fold_scalar_iadd_normal
 func @const_fold_scalar_iadd_normal() -> (i32, i32, i32) {
   %c5 = spv.Constant 5 : i32
   %cn8 = spv.Constant -8 : i32
 
-  // CHECK: spv.Constant 10
-  // CHECK: spv.Constant -16
-  // CHECK: spv.Constant -3
+  // CHECK-DAG: spv.Constant -3
+  // CHECK-DAG: spv.Constant -16
+  // CHECK-DAG: spv.Constant 10
   %0 = spv.IAdd %c5, %c5 : i32
   %1 = spv.IAdd %cn8, %cn8 : i32
   %2 = spv.IAdd %c5, %cn8 : i32
   return %0, %1, %2: i32, i32, i32
 }
 
 // CHECK-LABEL: @const_fold_scalar_iadd_flow
 func @const_fold_scalar_iadd_flow() -> (i32, i32, i32, i32) {
   %c1 = spv.Constant 1 : i32
   %c2 = spv.Constant 2 : i32
   %c3 = spv.Constant 4294967295 : i32  // 2^32 - 1: 0xffff ffff
   %c4 = spv.Constant -2147483648 : i32 // -2^31   : 0x8000 0000
   %c5 = spv.Constant -1 : i32          //         : 0xffff ffff
   %c6 = spv.Constant -2 : i32          //         : 0xffff fffe
 
+  // 0x8000 0000 + 0xffff fffe = 0x1 7fff fffe -> 0x7fff fffe
+  // CHECK-DAG: spv.Constant 2147483646
+  // 0x8000 0000 + 0xffff ffff = 0x1 7fff ffff -> 0x7fff ffff
+  // CHECK-DAG: spv.Constant 2147483647
+  // 0x0000 0002 + 0xffff ffff = 0x1 0000 0001 -> 0x0000 0001
+  // CHECK-DAG: spv.Constant 1
   // 0x0000 0001 + 0xffff ffff = 0x1 0000 0000 -> 0x0000 0000
-  // CHECK: spv.Constant 0
+  // CHECK-DAG: spv.Constant 0
   %0 = spv.IAdd %c1, %c3 : i32
-  // 0x0000 0002 + 0xffff ffff = 0x1 0000 0001 -> 0x0000 0001
-  // CHECK: spv.Constant 1
    %1 = spv.IAdd %c2, %c3 : i32
-  // 0x8000 0000 + 0xffff ffff = 0x1 7fff ffff -> 0x7fff ffff
-  // CHECK: spv.Constant 2147483647
   %2 = spv.IAdd %c4, %c5 : i32
-  // 0x8000 0000 + 0xffff fffe = 0x1 7fff fffe -> 0x7fff fffe
-  // CHECK: spv.Constant 2147483646
   %3 = spv.IAdd %c4, %c6 : i32
   return %0, %1, %2, %3: i32, i32, i32, i32
 }
 
 // CHECK-LABEL: @const_fold_vector_iadd
 func @const_fold_vector_iadd() -> vector<3xi32> {
   %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
   %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>

 }
 
 // CHECK-LABEL: @const_fold_scalar_imul_normal
 func @const_fold_scalar_imul_normal() -> (i32, i32, i32) {
   %c5 = spv.Constant 5 : i32
   %cn8 = spv.Constant -8 : i32
   %c7 = spv.Constant 7 : i32
 
-  // CHECK: spv.Constant 35
-  // CHECK: spv.Constant -40
-  // CHECK: spv.Constant -56
+  // CHECK-DAG: spv.Constant -56
+  // CHECK-DAG: spv.Constant -40
+  // CHECK-DAG: spv.Constant 35
   %0 = spv.IMul %c7, %c5 : i32
   %1 = spv.IMul %c5, %cn8 : i32
   %2 = spv.IMul %cn8, %c7 : i32
   return %0, %1, %2: i32, i32, i32
 }
 
 // CHECK-LABEL: @const_fold_scalar_imul_flow
 func @const_fold_scalar_imul_flow() -> (i32, i32, i32) {
   %c1 = spv.Constant 2 : i32
   %c2 = spv.Constant 4 : i32
   %c3 = spv.Constant 4294967295 : i32  // 2^32 - 1 : 0xffff ffff
   %c4 = spv.Constant 2147483647 : i32  // 2^31 - 1 : 0x7fff ffff
 
+  // (0x7fff ffff << 2) = 0x1 ffff fffc -> 0xffff fffc
+  // CHECK-DAG: %[[CST4:.*]] = spv.Constant -4
+
   // (0xffff ffff << 1) = 0x1 ffff fffe -> 0xffff fffe
-  // CHECK: %[[CST2:.*]] = spv.Constant -2
+  // CHECK-DAG: %[[CST2:.*]] = spv.Constant -2
   %0 = spv.IMul %c1, %c3 : i32
   // (0x7fff ffff << 1) = 0x0 ffff fffe -> 0xffff fffe
   %1 = spv.IMul %c1, %c4 : i32
-  // (0x7fff ffff << 2) = 0x1 ffff fffc -> 0xffff fffc
-  // CHECK: %[[CST4:.*]] = spv.Constant -4
   %2 = spv.IMul %c4, %c2 : i32
   // CHECK: return %[[CST2]], %[[CST2]], %[[CST4]]
   return %0, %1, %2: i32, i32, i32
 }
 
 
 // CHECK-LABEL: @const_fold_vector_imul
 func @const_fold_vector_imul() -> vector<3xi32> {

 }
 
 // CHECK-LABEL: @const_fold_scalar_isub_normal
 func @const_fold_scalar_isub_normal() -> (i32, i32, i32) {
   %c5 = spv.Constant 5 : i32
   %cn8 = spv.Constant -8 : i32
   %c7 = spv.Constant 7 : i32
 
-  // CHECK: spv.Constant 2
-  // CHECK: spv.Constant 13
-  // CHECK: spv.Constant -15
+  // CHECK-DAG: spv.Constant -15
+  // CHECK-DAG: spv.Constant 13
+  // CHECK-DAG: spv.Constant 2
   %0 = spv.ISub %c7, %c5 : i32
   %1 = spv.ISub %c5, %cn8 : i32
   %2 = spv.ISub %cn8, %c7 : i32
   return %0, %1, %2: i32, i32, i32
 }
 
 // CHECK-LABEL: @const_fold_scalar_isub_flow
 func @const_fold_scalar_isub_flow() -> (i32, i32, i32, i32) {
   %c1 = spv.Constant 0 : i32
   %c2 = spv.Constant 1 : i32
   %c3 = spv.Constant 4294967295 : i32  // 2^32 - 1 : 0xffff ffff
   %c4 = spv.Constant 2147483647 : i32  // 2^31     : 0x7fff ffff
   %c5 = spv.Constant -1 : i32          //          : 0xffff ffff
   %c6 = spv.Constant -2 : i32          //          : 0xffff fffe
 
+  // 0xffff ffff - 0x7fff ffff -> 0xffff ffff + 0x8000 0001 = 0x1 8000 0000
+  // CHECK-DAG: spv.Constant -2147483648
+  // 0x0000 0001 - 0xffff ffff -> 0x0000 0001 + 0x0000 0001 = 0x0000 0002
+  // CHECK-DAG: spv.Constant 2
   // 0x0000 0000 - 0xffff ffff -> 0x0000 0000 + 0x0000 0001 = 0x0000 0001
-  // CHECK: spv.Constant 1
+  // CHECK-DAG: spv.Constant 1
+  // 0xffff fffe - 0x7fff ffff -> 0xffff fffe + 0x8000 0001 = 0x1 7fff ffff
+  // CHECK-DAG: spv.Constant 2147483647
   %0 = spv.ISub %c1, %c3 : i32
-  // 0x0000 0001 - 0xffff ffff -> 0x0000 0001 + 0x0000 0001 = 0x0000 0002
-  // CHECK: spv.Constant 2
   %1 = spv.ISub %c2, %c3 : i32
-  // 0xffff ffff - 0x7fff ffff -> 0xffff ffff + 0x8000 0001 = 0x1 8000 0000
-  // CHECK: spv.Constant -2147483648
   %2 = spv.ISub %c5, %c4 : i32
-  // 0xffff fffe - 0x7fff ffff -> 0xffff fffe + 0x8000 0001 = 0x1 7fff ffff
-  // CHECK: spv.Constant 2147483647
   %3 = spv.ISub %c6, %c4 : i32
   return %0, %1, %2, %3: i32, i32, i32, i32
 }
 
 // CHECK-LABEL: @const_fold_vector_isub
 func @const_fold_vector_isub() -> vector<3xi32> {
   %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
   %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>
func @canonicalize_selection_op_vector_type(%cond: i1) -> () {
   ^merge:
     spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
+// CHECK-LABEL: cannot_canonicalize_selection_op_0
+
 // Store to a different variables.
 func @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
   %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
-  // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
+  // CHECK-DAG: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
+  // CHECK-DAG: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
-  // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   // CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
   %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
   // CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
   %4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
 
   // CHECK: spv.mlir.selection {
   spv.mlir.selection {
func @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
   ^merge:
     spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
+// CHECK-LABEL: cannot_canonicalize_selection_op_1
+
 // A conditional block consists of more than 2 operations.
 func @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
   %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   // CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
func @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
   ^merge:
     spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
+// CHECK-LABEL: cannot_canonicalize_selection_op_2
+
 // A control-flow goes into `^then` block from `^else` block.
 func @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
   %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
func @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
   ^merge:
     spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
+// CHECK-LABEL: cannot_canonicalize_selection_op_3
+
 // `spv.Return` as a block terminator.
 func @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
   %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
-  // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
+  // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
   %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
 
   // CHECK: spv.mlir.selection {
   spv.mlir.selection {
     spv.BranchConditional %cond, ^then, ^else
func @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
   ^merge:
     spv.mlir.merge
   }
   spv.Return
 }
 
 // -----
 
+// CHECK-LABEL: cannot_canonicalize_selection_op_4
+
 // Different memory access attributes.
 func @cannot_canonicalize_selection_op_4(%cond: i1) -> () {
   %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
   // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
   // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>

mlir/test/Dialect/Tensor/canonicalize.mlir

 
 // -----
 
 // CHECK-LABEL: func @fold_extract
 func @fold_extract(%arg0 : index) -> (f32, f16, f16, i32) {
   %const_0 = constant 0 : index
   %const_1 = constant 1 : index
   %const_3 = constant 3 : index
+  // CHECK-DAG: [[C64:%.+]] = constant 64 : i32
+  // CHECK-DAG: [[C0:%.+]] = constant 0.{{0*}}e+00 : f16
+  // CHECK-DAG: [[CM2:%.+]] = constant -2.{{0*}}e+00 : f16
 
   // Fold an extract into a splat.
-  // CHECK-NEXT: [[C4:%.+]] = constant 4.{{0*}}e+00 : f32
+  // CHECK-DAG: [[C4:%.+]] = constant 4.{{0*}}e+00 : f32
   %0 = constant dense<4.0> : tensor<4xf32>
   %ext_1 = tensor.extract %0[%arg0] : tensor<4xf32>
 
   // Fold an extract into a sparse with a sparse index.
-  // CHECK-NEXT: [[CM2:%.+]] = constant -2.{{0*}}e+00 : f16
   %1 = constant sparse<[[0, 0, 0], [1, 1, 1]],  [-5.0, -2.0]> : tensor<4x4x4xf16>
   %ext_2 = tensor.extract %1[%const_1, %const_1, %const_1] : tensor<4x4x4xf16>
 
   // Fold an extract into a sparse with a non sparse index.
-  // CHECK-NEXT: [[C0:%.+]] = constant 0.{{0*}}e+00 : f16
   %2 = constant sparse<[[1, 1, 1]],  [-2.0]> : tensor<1x1x1xf16>
   %ext_3 = tensor.extract %2[%const_0, %const_0, %const_0] : tensor<1x1x1xf16>
 
   // Fold an extract into a dense tensor.
-  // CHECK-NEXT: [[C64:%.+]] = constant 64 : i32
    %3 = constant dense<[[[1, -2, 1, 36]], [[0, 2, -1, 64]]]> : tensor<2x1x4xi32>
   %ext_4 = tensor.extract %3[%const_1, %const_0, %const_3] : tensor<2x1x4xi32>
 
   // CHECK-NEXT: return [[C4]], [[CM2]], [[C0]], [[C64]]
   return %ext_1, %ext_2, %ext_3, %ext_4 : f32, f16, f16, i32
 }
 
 // -----
 

mlir/test/Dialect/Vector/canonicalize.mlir

 func @bitcast_folding(%I1: vector<4x8xf32>, %I2: vector<2xi32>) -> (vector<4x8xf32>, vector<2xi32>) {
   %0 = vector.bitcast %I1 : vector<4x8xf32> to vector<4x8xf32>
   %1 = vector.bitcast %I2 : vector<2xi32> to vector<4xi16>
   %2 = vector.bitcast %1 : vector<4xi16> to vector<2xi32>
   return %0, %2 : vector<4x8xf32>, vector<2xi32>
 }
 
 // CHECK-LABEL: func @bitcast_f16_to_f32
-//              bit pattern: 0x00000000
-//       CHECK: %[[CST0:.+]] = constant dense<0.000000e+00> : vector<4xf32>
 //              bit pattern: 0x40004000
-//       CHECK: %[[CST1:.+]] = constant dense<2.00390625> : vector<4xf32>
+//       CHECK-DAG: %[[CST1:.+]] = constant dense<2.00390625> : vector<4xf32>
+//              bit pattern: 0x00000000
+//       CHECK-DAG: %[[CST0:.+]] = constant dense<0.000000e+00> : vector<4xf32>
 //       CHECK: return %[[CST0]], %[[CST1]]
 func @bitcast_f16_to_f32() -> (vector<4xf32>, vector<4xf32>) {
   %cst0 = constant dense<0.0> : vector<8xf16> // bit pattern: 0x0000
   %cst1 = constant dense<2.0> : vector<8xf16> // bit pattern: 0x4000
   %cast0 = vector.bitcast %cst0: vector<8xf16> to vector<4xf32>
   %cast1 = vector.bitcast %cst1: vector<8xf16> to vector<4xf32>
   return %cast0, %cast1: vector<4xf32>, vector<4xf32>
 }
func @broadcast_folding2() -> vector<4x16xi32> {
   %1 = vector.broadcast %0 : i32 to vector<16xi32>
   %2 = vector.broadcast %1 : vector<16xi32> to vector<4x16xi32>
   return %2 : vector<4x16xi32>
 }
 
 // -----
 
 // CHECK-LABEL: shape_cast_constant
-//       CHECK: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<20x2xf32>
-//       CHECK: %[[CST1:.*]] = constant dense<1> : vector<3x4x2xi32>
+//       CHECK-DAG: %[[CST1:.*]] = constant dense<1> : vector<3x4x2xi32>
+//       CHECK-DAG: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<20x2xf32>
 //       CHECK: return %[[CST0]], %[[CST1]] : vector<20x2xf32>, vector<3x4x2xi32>
 func @shape_cast_constant() -> (vector<20x2xf32>, vector<3x4x2xi32>) {
   %cst = constant dense<2.000000e+00> : vector<5x4x2xf32>
   %cst_1 = constant dense<1> : vector<12x2xi32>
   %0 = vector.shape_cast %cst : vector<5x4x2xf32> to vector<20x2xf32>
   %1 = vector.shape_cast %cst_1 : vector<12x2xi32> to vector<3x4x2xi32>
   return %0, %1 : vector<20x2xf32>, vector<3x4x2xi32>
 }
 
 // -----
 
 // CHECK-LABEL: extract_strided_constant
-//       CHECK: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<12x2xf32>
-//       CHECK: %[[CST1:.*]] = constant dense<1> : vector<2x13x3xi32>
+//       CHECK-DAG: %[[CST1:.*]] = constant dense<1> : vector<2x13x3xi32>
+//       CHECK-DAG: %[[CST0:.*]] = constant dense<2.000000e+00> : vector<12x2xf32>
 //       CHECK: return %[[CST0]], %[[CST1]] : vector<12x2xf32>, vector<2x13x3xi32>
 func @extract_strided_constant() -> (vector<12x2xf32>, vector<2x13x3xi32>) {
   %cst = constant dense<2.000000e+00> : vector<29x7xf32>
   %cst_1 = constant dense<1> : vector<4x37x9xi32>
   %0 = vector.extract_strided_slice %cst
     {offsets = [2, 3], sizes = [12, 2], strides = [1, 1]}
       : vector<29x7xf32> to vector<12x2xf32>
   %1 = vector.extract_strided_slice %cst_1

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

 // CHECK:      return %[[A]] : vector<16xf32>
 
 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
-// CHECK-SAME: %[[A:.*]]: vector<16xf32>
-// CHECK:      return %[[A]] : vector<16xf32>
+// FIXME: PR49590
+// HECK-SAME: %[[A:.*]]: vector<16xf32>
+// HECK:      return %[[A]] : vector<16xf32>
 
 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
 // llvm.matrix operations
 // CHECK-LABEL: func @shape_casts
 func @shape_casts(%a: vector<2x2xf32>) -> (vector<4xf32>, vector<2x2xf32>) {
-  // CHECK: %[[cst:.*]] = constant dense<0.000000e+00> : vector<4xf32>
-  // CHECK: %[[cst22:.*]] = constant dense<0.000000e+00> : vector<2x2xf32>
+  // CHECK-DAG: %[[cst22:.*]] = constant dense<0.000000e+00> : vector<2x2xf32>
+  // CHECK-DAG: %[[cst:.*]] = constant dense<0.000000e+00> : vector<4xf32>
   // CHECK: %[[ex0:.*]] = vector.extract %{{.*}}[0] : vector<2x2xf32>
   //
   // CHECK: %[[in0:.*]] = vector.insert_strided_slice %[[ex0]], %[[cst]]
   // CHECK-SAME: {offsets = [0], strides = [1]} : vector<2xf32> into vector<4xf32>
   //
   // CHECK: %[[ex1:.*]] = vector.extract %{{.*}}[1] : vector<2x2xf32>
   //
   // CHECK: %[[in2:.*]] = vector.insert_strided_slice %[[ex1]], %[[in0]]

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

 func @transpose44_44(%arg0: vector<4x4xf32>) -> vector<4x4xf32> {
   %0 = vector.transpose %arg0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
   return %0 : vector<4x4xf32>
 }
 
 // Folds preceding shape cast as expected,
 // no following shape cast folding expected.
 //
+// FIXME: PR49590 - shape_cast not stable.
+//
 // CHECK-LABEL: func @transpose16_44(
 // CHECK-SAME:  %[[A:.*]]: vector<16xf32>
-// CHECK:       %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
-// CHECK:       %[[T1:.*]] = vector.extract_strided_slice %[[T0]] {offsets = [0], sizes = [4], strides = [1]} : vector<16xf32> to vector<4xf32>
+// HECK:       %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
+// HECK:       %[[T1:.*]] = vector.extract_strided_slice %[[T0]] {offsets = [0], sizes = [4], strides = [1]} : vector<16xf32> to vector<4xf32>
 //
 func @transpose16_44(%arg0: vector<16xf32>) -> vector<4x4xf32> {
   %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32>
   %1 = vector.transpose %0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
   return %1 : vector<4x4xf32>
 }
 
 // No preceding shape cast folding expected,
 // but FAILS to fold following cast.
 //
 // CHECK-LABEL: func @transpose44_16(
 // CHECK-SAME:  %[[A:.*]]: vector<4x4xf32>
 // CHECK:       %[[T0:.*]] = vector.extract %[[A]][0] : vector<4x4xf32>
 // CHECK:       %[[T8:.*]] = vector.flat_transpose %{{.*}} {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
 func @transpose44_16(%arg0: vector<4x4xf32>) -> vector<16xf32> {
   %0 = vector.transpose %arg0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
   %1 = vector.shape_cast %0 : vector<4x4xf32> to vector<16xf32>
   return %1 : vector<16xf32>
 }
 
 // Folds preceding shape cast as expected,
 // but FAILS to fold following cast.
 //
+// FIXME: PR49590 - shape_cast not stable.
+//
 // CHECK-LABEL: func @transpose16_16(
 // CHECK-SAME:  %[[A:.*]]: vector<16xf32>
-// CHECK:       %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
+// HECK:       %[[T0:.*]] = vector.flat_transpose %[[A]] {columns = 4 : i32, rows = 4 : i32} : vector<16xf32> -> vector<16xf32>
 //
 func @transpose16_16(%arg0: vector<16xf32>) -> vector<16xf32> {
   %0 = vector.shape_cast %arg0 : vector<16xf32> to vector<4x4xf32>
   %1 = vector.transpose %0, [1, 0] : vector<4x4xf32> to vector<4x4xf32>
   %2 = vector.shape_cast %1 : vector<4x4xf32> to vector<16xf32>
   return %2 : vector<16xf32>
 }

mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir

 // LINALG-LABEL: split_vector_transfer_read_2d(
 //  LINALG-SAME: %[[A:[a-zA-Z0-9]*]]: memref
 //  LINALG-SAME: %[[i:[a-zA-Z0-9]*]]: index
 //  LINALG-SAME: %[[j:[a-zA-Z0-9]*]]: index
 func @split_vector_transfer_read_2d(%A: memref<?x8xf32>, %i: index, %j: index) -> vector<4x8xf32> {
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
 
-  //  CHECK-DAG: %[[c0:.*]] = constant 0 : index
   //  CHECK-DAG: %[[c8:.*]] = constant 8 : index
-  //  CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
+  //  CHECK-DAG: %[[c0:.*]] = constant 0 : index
   // alloca for boundary full tile
   //      CHECK: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      CHECK: %[[d0:.*]] = memref.dim %[[A]], %[[c0]] : memref<?x8xf32>
   //      CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index
   // %j + 8 <= dim(%A, 1)
   //      CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
func @split_vector_transfer_read_2d(%A: memref<?x8xf32>, %i: index, %j: index) -> vector<4x8xf32> {
   //      CHECK:   %[[cast_alloc:.*]] = vector.type_cast %[[alloc]] :
   // CHECK-SAME:     memref<4x8xf32> to memref<vector<4x8xf32>>
   //      CHECK:   store %[[slow]], %[[cast_alloc]][] : memref<vector<4x8xf32>>
   //      CHECK:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // CHECK-SAME:     memref<4x8xf32> to memref<?x8xf32>
   //      CHECK:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :
   // CHECK-SAME:     memref<?x8xf32>, index, index
   //      CHECK: }
-  //      CHECK: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %[[cst]]
+  //      CHECK: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %cst
   // CHECK_SAME:   {masked = [false, false]} : memref<?x8xf32>, vector<4x8xf32>
 
   //  LINALG-DAG: %[[c0:.*]] = constant 0 : index
   //  LINALG-DAG: %[[c4:.*]] = constant 4 : index
   //  LINALG-DAG: %[[c8:.*]] = constant 8 : index
-  //  LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
   // alloca for boundary full tile
   //      LINALG: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      LINALG: %[[d0:.*]] = memref.dim %[[A]], %[[c0]] : memref<?x8xf32>
   //      LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[d0]] : index
   // %j + 8 <= dim(%A, 1)
   //      LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      LINALG: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
   // are both conds true
   //      LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
   //      LINALG: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref<?x8xf32>, index, index) {
   //               inBounds, just yield %A
   //      LINALG:   scf.yield %[[A]], %[[i]], %[[j]] : memref<?x8xf32>, index, index
   //      LINALG: } else {
   //               slow path, fill tmp alloc and yield a memref_casted version of it
-  //      LINALG:   linalg.fill(%[[alloc]], %[[cst]]) : memref<4x8xf32>, f32
+  //      LINALG:   linalg.fill(%[[alloc]], %cst) : memref<4x8xf32>, f32
   //      LINALG:   %[[d0:.*]] = memref.dim %[[A]], %[[c0]] : memref<?x8xf32>
   //      LINALG:   %[[sv0:.*]] = affine.min #[[$bounds_map_4]](%[[d0]], %[[i]], %[[c4]])
   //      LINALG:   %[[sv1:.*]] = affine.min #[[$bounds_map_8]](%[[c8]], %[[j]], %[[c8]])
   //      LINALG:   %[[sv:.*]] = memref.subview %[[A]][%[[i]], %[[j]]] [%[[sv0]], %[[sv1]]] [1, 1]
   // LINALG-SAME:     memref<?x8xf32> to memref<?x?xf32, #[[$map_2d_stride_8x1]]>
   //      LINALG:   linalg.copy(%[[sv]], %[[alloc]]) : memref<?x?xf32, #[[$map_2d_stride_8x1]]>, memref<4x8xf32>
   //      LINALG:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // LINALG-SAME:     memref<4x8xf32> to memref<?x8xf32>
   //      LINALG:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :
   // LINALG-SAME:     memref<?x8xf32>, index, index
   //      LINALG: }
-  //      LINALG: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %[[cst]]
+  //      LINALG: %[[res:.*]] = vector.transfer_read %[[ifres]]#0[%[[ifres]]#1, %[[ifres]]#2], %cst
   // LINALG_SAME:   {masked = [false, false]} : memref<?x8xf32>, vector<4x8xf32>
   %1 = vector.transfer_read %A[%i, %j], %f0 : memref<?x8xf32>, vector<4x8xf32>
 
   // LINALG: return %[[res]] : vector<4x8xf32>
   return %1: vector<4x8xf32>
 }
 
 // CHECK-LABEL: split_vector_transfer_read_strided_2d(
 //  CHECK-SAME: %[[A:[a-zA-Z0-9]*]]: memref
 //  CHECK-SAME: %[[i:[a-zA-Z0-9]*]]: index
 //  CHECK-SAME: %[[j:[a-zA-Z0-9]*]]: index
 
 // LINALG-LABEL: split_vector_transfer_read_strided_2d(
 //  LINALG-SAME: %[[A:[a-zA-Z0-9]*]]: memref
 //  LINALG-SAME: %[[i:[a-zA-Z0-9]*]]: index
 //  LINALG-SAME: %[[j:[a-zA-Z0-9]*]]: index
 func @split_vector_transfer_read_strided_2d(
     %A: memref<7x8xf32, offset:?, strides:[?, 1]>,
     %i: index, %j: index) -> vector<4x8xf32> {
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
 
-  //  CHECK-DAG: %[[c0:.*]] = constant 0 : index
   //  CHECK-DAG: %[[c7:.*]] = constant 7 : index
   //  CHECK-DAG: %[[c8:.*]] = constant 8 : index
-  //  CHECK-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
+  //  CHECK-DAG: %[[c0:.*]] = constant 0 : index
   // alloca for boundary full tile
   //      CHECK: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      CHECK: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      CHECK: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[c7]] : index
   // %j + 8 <= dim(%A, 1)
   //      CHECK: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      CHECK: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
func @split_vector_transfer_read_strided_2d(
   //      CHECK: }
   //      CHECK: %[[res:.*]] = vector.transfer_read {{.*}} {masked = [false, false]} :
   // CHECK-SAME:   memref<?x8xf32, #[[$map_2d_stride_1]]>, vector<4x8xf32>
 
   //  LINALG-DAG: %[[c0:.*]] = constant 0 : index
   //  LINALG-DAG: %[[c4:.*]] = constant 4 : index
   //  LINALG-DAG: %[[c7:.*]] = constant 7 : index
   //  LINALG-DAG: %[[c8:.*]] = constant 8 : index
-  //  LINALG-DAG: %[[cst:.*]] = constant 0.000000e+00 : f32
   // alloca for boundary full tile
   //      LINALG: %[[alloc:.*]] = memref.alloca() {alignment = 32 : i64} : memref<4x8xf32>
   // %i + 4 <= dim(%A, 0)
   //      LINALG: %[[idx0:.*]] = affine.apply #[[$map_p4]]()[%[[i]]]
   //      LINALG: %[[cmp0:.*]] = cmpi sle, %[[idx0]], %[[c7]] : index
   // %j + 8 <= dim(%A, 1)
   //      LINALG: %[[idx1:.*]] = affine.apply #[[$map_p8]]()[%[[j]]]
   //      LINALG: %[[cmp1:.*]] = cmpi sle, %[[idx1]], %[[c8]] : index
   // are both conds true
   //      LINALG: %[[cond:.*]] = and %[[cmp0]], %[[cmp1]] : i1
   //      LINALG: %[[ifres:.*]]:3 = scf.if %[[cond]] -> (memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index) {
   //               inBounds but not cast-compatible: yield a memref_casted form of %A
   //      LINALG:   %[[casted:.*]] = memref.cast %arg0 :
   // LINALG-SAME:     memref<7x8xf32, #[[$map_2d_stride_1]]> to memref<?x8xf32, #[[$map_2d_stride_1]]>
   //      LINALG:   scf.yield %[[casted]], %[[i]], %[[j]] :
   // LINALG-SAME:     memref<?x8xf32, #[[$map_2d_stride_1]]>, index, index
   //      LINALG: } else {
   //               slow path, fill tmp alloc and yield a memref_casted version of it
-  //      LINALG:   linalg.fill(%[[alloc]], %[[cst]]) : memref<4x8xf32>, f32
+  //      LINALG:   linalg.fill(%[[alloc]], %cst) : memref<4x8xf32>, f32
   //      LINALG:   %[[sv0:.*]] = affine.min #[[$bounds_map_4]](%[[c7]], %[[i]], %[[c4]])
   //      LINALG:   %[[sv1:.*]] = affine.min #[[$bounds_map_8]](%[[c8]], %[[j]], %[[c8]])
   //      LINALG:   %[[sv:.*]] = memref.subview %[[A]][%[[i]], %[[j]]] [%[[sv0]], %[[sv1]]] [1, 1]
   // LINALG-SAME:     memref<7x8xf32, #[[$map_2d_stride_1]]> to memref<?x?xf32, #[[$map_2d_stride_1]]>
   //      LINALG:   linalg.copy(%[[sv]], %[[alloc]]) : memref<?x?xf32, #[[$map_2d_stride_1]]>, memref<4x8xf32>
   //      LINALG:   %[[yielded:.*]] = memref.cast %[[alloc]] :
   // LINALG-SAME:     memref<4x8xf32> to memref<?x8xf32, #[[$map_2d_stride_1]]>
   //      LINALG:   scf.yield %[[yielded]], %[[c0]], %[[c0]] :

mlir/test/Dialect/Vector/vector-transfer-unroll.mlir

 // RUN: mlir-opt %s -test-vector-transfer-unrolling-patterns | FileCheck %s
 
 // CHECK-LABEL: func @transfer_read_unroll
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[TUPL:.*]] = vector.tuple %[[VTR0]], %[[VTR1]], %[[VTR2]], %[[VTR3]] : vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VEC:.*]] = vector.insert_slices %[[TUPL]], [2, 2], [1, 1] : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> into vector<4x4xf32>
 //  CHECK-NEXT:   return %[[VEC]] : vector<4x4xf32>
 
 func @transfer_read_unroll(%arg0 : memref<4x4xf32>) -> vector<4x4xf32> {
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
   %0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : memref<4x4xf32>, vector<4x4xf32>
   return %0 : vector<4x4xf32>
 }
 
 // CHECK-LABEL: func @transfer_write_unroll
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[TUPL:.*]] = vector.extract_slices {{.*}}, [2, 2], [1, 1] : vector<4x4xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   %[[T0:.*]] = vector.tuple_get %[[TUPL]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   vector.transfer_write %[[T0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   %[[T1:.*]] = vector.tuple_get %[[TUPL]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   vector.transfer_write %[[T1]], {{.*}}[%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   %[[T2:.*]] = vector.tuple_get %[[TUPL]], 2 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   vector.transfer_write %[[T2]], {{.*}}[%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   %[[T3:.*]] = vector.tuple_get %[[TUPL]], 3 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   vector.transfer_write %[[T3]], {{.*}}[%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   return
 
 func @transfer_write_unroll(%arg0 : memref<4x4xf32>, %arg1 : vector<4x4xf32>) {
   %c0 = constant 0 : index
   vector.transfer_write %arg1, %arg0[%c0, %c0] : vector<4x4xf32>, memref<4x4xf32>
   return
 }
 
 // CHECK-LABEL: func @transfer_readwrite_unroll
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   vector.transfer_write %[[VTR0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   vector.transfer_write %[[VTR1]], {{.*}}[%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   vector.transfer_write %[[VTR2]], {{.*}}[%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   vector.transfer_write %[[VTR3]], {{.*}}[%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, memref<4x4xf32>
 //  CHECK-NEXT:   return
 
 func @transfer_readwrite_unroll(%arg0 : memref<4x4xf32>) {
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
   %0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : memref<4x4xf32>, vector<4x4xf32>
   vector.transfer_write %0, %arg0[%c0, %c0] : vector<4x4xf32>, memref<4x4xf32>
   return
 }
 
 // CHECK-LABEL: func @transfer_read_unroll_tensor
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[TUPL:.*]] = vector.tuple %[[VTR0]], %[[VTR1]], %[[VTR2]], %[[VTR3]] : vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VEC:.*]] = vector.insert_slices %[[TUPL]], [2, 2], [1, 1] : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>> into vector<4x4xf32>
 //  CHECK-NEXT:   return %[[VEC]] : vector<4x4xf32>
 
 func @transfer_read_unroll_tensor(%arg0 : tensor<4x4xf32>) -> vector<4x4xf32> {
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
   %0 = vector.transfer_read %arg0[%c0, %c0], %cf0 : tensor<4x4xf32>, vector<4x4xf32>
   return %0 : vector<4x4xf32>
 }
 
 // CHECK-LABEL: func @transfer_write_unroll_tensor
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[TUPL:.*]] = vector.extract_slices {{.*}}, [2, 2], [1, 1] : vector<4x4xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   %[[T0:.*]] = vector.tuple_get %[[TUPL]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   %[[VTW0:.*]] = vector.transfer_write %[[T0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   %[[T1:.*]] = vector.tuple_get %[[TUPL]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   %[[VTW1:.*]] = vector.transfer_write %[[T1]], %[[VTW0]][%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   %[[T2:.*]] = vector.tuple_get %[[TUPL]], 2 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   %[[VTW2:.*]] = vector.transfer_write %[[T2]], %[[VTW1]][%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   %[[T3:.*]] = vector.tuple_get %[[TUPL]], 3 : tuple<vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>, vector<2x2xf32>>
 //  CHECK-NEXT:   %[[VTW3:.*]] = vector.transfer_write %[[T3]], %[[VTW2]][%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   return %[[VTW3]] : tensor<4x4xf32>
 
 func @transfer_write_unroll_tensor(%arg0 : tensor<4x4xf32>,
   %arg1 : vector<4x4xf32>) -> tensor<4x4xf32> {
   %c0 = constant 0 : index
   %r = vector.transfer_write %arg1, %arg0[%c0, %c0] :
     vector<4x4xf32>, tensor<4x4xf32>
   return %r: tensor<4x4xf32>
 }
 
 // CHECK-LABEL: func @transfer_readwrite_unroll_tensor
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[VTR0:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR1:.*]] = vector.transfer_read {{.*}}[%[[C0]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR2:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C0]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTR3:.*]] = vector.transfer_read {{.*}}[%[[C2]], %[[C2]]], %{{.*}} : tensor<4x4xf32>, vector<2x2xf32>
 //  CHECK-NEXT:   %[[VTW0:.*]] = vector.transfer_write %[[VTR0]], {{.*}}[%[[C0]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   %[[VTW1:.*]] = vector.transfer_write %[[VTR1]], %[[VTW0]][%[[C0]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   %[[VTW2:.*]] = vector.transfer_write %[[VTR2]], %[[VTW1]][%[[C2]], %[[C0]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>
 //  CHECK-NEXT:   %[[VTW3:.*]] = vector.transfer_write %[[VTR3]], %[[VTW2]][%[[C2]], %[[C2]]] {{.*}} : vector<2x2xf32>, tensor<4x4xf32>

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

func @contraction4x4_ikj(%arg0 : vector<4x2xf32>, %arg1 : vector<2x4xf32>,
   %0 = vector.contract #contraction_trait1 %arg0, %arg1, %arg2, %lhsm, %rhsm
       : vector<4x2xf32>, vector<2x4xf32> into vector<4x4xf32>
 
   return %0 : vector<4x4xf32>
 }
 
 // CHECK-LABEL: func @contraction4x4_ikj_xfer_read
 
-// CHECK:      %[[C0:.*]] = constant 0 : index
-// CHECK:      %[[C2:.*]] = constant 2 : index
+// CHECK-DAG:      %[[C2:.*]] = constant 2 : index
+// CHECK-DAG:      %[[C0:.*]] = constant 0 : index
 
 // Check LHS vector.transfer read is split for each user.
 
 //      CHECK: %[[VTR0:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<4x2xf32>, vector<2x2xf32>
 // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read %{{.*}}[%[[C2]], %[[C0]]], %{{.*}} : memref<4x2xf32>, vector<2x2xf32>
 
 // CHECK-NEXT: %[[VTR2:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]]], %{{.*}} : memref<2x4xf32>, vector<2x2xf32>
 // CHECK-NEXT: %[[VTR3:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C2]]], %{{.*}} : memref<2x4xf32>, vector<2x2xf32>

 //       CHECK: return %[[A0]] : vector<2x4xf32>
 func @cancelling_shape_cast_ops(%arg0 : vector<2x4xf32>) -> vector<2x4xf32> {
   %0 = vector.shape_cast %arg0 : vector<2x4xf32> to vector<8xf32>
   %1 = vector.shape_cast %0 : vector<8xf32> to vector<2x4xf32>
   return %1 : vector<2x4xf32>
 }
 
 // CHECK-LABEL: func @vector_transfers_vector_element_type
-//      CHECK: %[[C0:.*]] = constant 0 : index
-//      CHECK: %[[C1:.*]] = constant 1 : index
+//      CHECK-DAG: %[[C1:.*]] = constant 1 : index
+//      CHECK-DAG: %[[C0:.*]] = constant 0 : index
 //      CHECK: %[[VTR0:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C0]], %[[C0]]], %{{.*}} {masked = [false, false]} : memref<6x2x1xvector<2x4xf32>>, vector<1x1x2x4xf32>
 // CHECK-NEXT: %[[VTR1:.*]] = vector.transfer_read %{{.*}}[%[[C0]], %[[C1]], %[[C0]]], %{{.*}} {masked = [false, false]} : memref<6x2x1xvector<2x4xf32>>, vector<1x1x2x4xf32>
 // CHECK-NEXT: vector.transfer_write %[[VTR0]], %{{.*}}[%[[C0]], %[[C0]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>>
 // CHECK-NEXT: vector.transfer_write %[[VTR1]], %{{.*}}[%[[C0]], %[[C1]], %[[C0]]] {masked = [false, false]} : vector<1x1x2x4xf32>, memref<6x2x1xvector<2x4xf32>>
 
 func @vector_transfers_vector_element_type() {
   %c0 = constant 0 : index
   %cf0 = constant 0.000000e+00 : f32
func @shape_cast_fold(%arg0 : vector<5x4x2xf32>, %arg1 : vector<3x4x2xf32>)
   %6 = vector.tuple_get %5, 0 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>>
   %7 = vector.tuple_get %5, 1 : tuple<vector<5x4x2xf32>, vector<3x4x2xf32>>
 
   return %6, %7 : vector<5x4x2xf32>, vector<3x4x2xf32>
 }
 
 // CHECK-LABEL: func @elementwise_unroll
 //  CHECK-SAME: (%[[ARG0:.*]]: memref<4x4xf32>, %[[ARG1:.*]]: memref<4x4xf32>)
-//       CHECK:   %[[C0:.*]] = constant 0 : index
-//       CHECK:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C2:.*]] = constant 2 : index
+//       CHECK-DAG:   %[[C0:.*]] = constant 0 : index
 //       CHECK:   %[[VT0:.*]] = vector.transfer_read %[[ARG0]][%[[C0]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT1:.*]] = vector.transfer_read %[[ARG0]][%[[C0]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT2:.*]] = vector.transfer_read %[[ARG0]][%[[C2]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT3:.*]] = vector.transfer_read %[[ARG0]][%[[C2]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT4:.*]] = vector.transfer_read %[[ARG1]][%[[C0]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT5:.*]] = vector.transfer_read %[[ARG1]][%[[C0]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT6:.*]] = vector.transfer_read %[[ARG1]][%[[C2]], %[[C0]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>
 //       CHECK:   %[[VT7:.*]] = vector.transfer_read %[[ARG1]][%[[C2]], %[[C2]]], {{.*}} : memref<4x4xf32>, vector<2x2xf32>

mlir/test/Transforms/canonicalize.mlir

 
 //
 // IMPORTANT NOTE: the operations in this test are exactly those produced by
 // lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations.  Please only
 // change these operations together with the affine lowering pass tests.
 //
 // CHECK-LABEL: @lowered_affine_mod
 func @lowered_affine_mod() -> (index, index) {
-// CHECK-NEXT: {{.*}} = constant 41 : index
+// CHECK-DAG: {{.*}} = constant 1 : index
+// CHECK-DAG: {{.*}} = constant 41 : index
   %c-43 = constant -43 : index
   %c42 = constant 42 : index
   %0 = remi_signed %c-43, %c42 : index
   %c0 = constant 0 : index
   %1 = cmpi slt, %0, %c0 : index
   %2 = addi %0, %c42 : index
   %3 = select %1, %2, %0 : index
-// CHECK-NEXT: {{.*}} = constant 1 : index
   %c43 = constant 43 : index
   %c42_0 = constant 42 : index
   %4 = remi_signed %c43, %c42_0 : index
   %c0_1 = constant 0 : index
   %5 = cmpi slt, %4, %c0_1 : index
   %6 = addi %4, %c42_0 : index
   %7 = select %5, %6, %4 : index
   return %3, %7 : index, index
 }
 
 //
 // IMPORTANT NOTE: the operations in this test are exactly those produced by
 // lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations.  Please only
 // change these operations together with the affine lowering pass tests.
 //
 // CHECK-LABEL: func @lowered_affine_floordiv
 func @lowered_affine_floordiv() -> (index, index) {
-// CHECK-NEXT: %c-2 = constant -2 : index
+// CHECK-DAG: %c1 = constant 1 : index
+// CHECK-DAG: %c-2 = constant -2 : index
   %c-43 = constant -43 : index
   %c42 = constant 42 : index
   %c0 = constant 0 : index
   %c-1 = constant -1 : index
   %0 = cmpi slt, %c-43, %c0 : index
   %1 = subi %c-1, %c-43 : index
   %2 = select %0, %1, %c-43 : index
   %3 = divi_signed %2, %c42 : index
   %4 = subi %c-1, %3 : index
   %5 = select %0, %4, %3 : index
-// CHECK-NEXT: %c1 = constant 1 : index
   %c43 = constant 43 : index
   %c42_0 = constant 42 : index
   %c0_1 = constant 0 : index
   %c-1_2 = constant -1 : index
   %6 = cmpi slt, %c43, %c0_1 : index
   %7 = subi %c-1_2, %c43 : index
   %8 = select %6, %7, %c43 : index
   %9 = divi_signed %8, %c42_0 : index

 // CHECK-DAG: #[[$SUBVIEW_MAP6:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2 * 2)>
 // CHECK-DAG: #[[$SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 4 + s0 + d1)>
 // CHECK-DAG: #[[$SUBVIEW_MAP8:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1 + 12)>
 
 
 // CHECK-LABEL: func @subview
 // CHECK-SAME: %[[ARG0:.*]]: index, %[[ARG1:.*]]: index
 func @subview(%arg0 : index, %arg1 : index) -> (index, index) {
-  // CHECK: %[[C0:.*]] = constant 0 : index
+  // Folded but reappears after subview folding into dim.
+  // CHECK-DAG: %[[C0:.*]] = constant 0 : index
+  // CHECK-DAG: %[[C7:.*]] = constant 7 : index
+  // CHECK-DAG: %[[C11:.*]] = constant 11 : index
   %c0 = constant 0 : index
   // CHECK-NOT: constant 1 : index
   %c1 = constant 1 : index
   // CHECK-NOT: constant 2 : index
   %c2 = constant 2 : index
   // Folded but reappears after subview folding into dim.
-  // CHECK: %[[C7:.*]] = constant 7 : index
   %c7 = constant 7 : index
-  // Folded but reappears after subview folding into dim.
-  // CHECK: %[[C11:.*]] = constant 11 : index
   %c11 = constant 11 : index
   // CHECK-NOT: constant 15 : index
   %c15 = constant 15 : index
 
   // CHECK: %[[ALLOC0:.*]] = memref.alloc()
   %0 = memref.alloc() : memref<8x16x4xf32, offset : 0, strides : [64, 4, 1]>
 
   // Test: subview with constant base memref and constant operands is folded.

 }
 
 // CHECK-LABEL: func @index_cast_fold
 func @index_cast_fold() -> (i16, index) {
   %c4 = constant 4 : index
   %1 = index_cast %c4 : index to i16
   %c4_i16 = constant 4 : i16
   %2 = index_cast %c4_i16 : i16 to index
-  // CHECK: %[[C4_I16:.*]] = constant 4 : i16
-  // CHECK: %[[C4:.*]] = constant 4 : index
+  // CHECK-DAG: %[[C4:.*]] = constant 4 : index
+  // CHECK-DAG: %[[C4_I16:.*]] = constant 4 : i16
   // CHECK: return %[[C4_I16]], %[[C4]] : i16, index
   return %1, %2 : i16, index
 }
 
 // CHECK-LABEL: func @remove_dead_else
 func @remove_dead_else(%M : memref<100 x i32>) {
   affine.for %i = 0 to 100 {
     affine.load %M[%i] : memref<100xi32>

mlir/test/Transforms/parallel-loop-collapsing.mlir

func @parallel_many_dims() {
   scf.parallel (%i0, %i1, %i2, %i3, %i4) = (%c0, %c3, %c6, %c9, %c12)
     to (%c2, %c5, %c8, %c26, %c14) step (%c1, %c4, %c7, %c10, %c13) {
     %result = "magic.op"(%i0, %i1, %i2, %i3, %i4)
         : (index, index, index, index, index) -> index
   }
   return
 }
 
-// CHECK: [[C3:%.*]] = constant 3 : index
-// CHECK: [[C6:%.*]] = constant 6 : index
-// CHECK: [[C9:%.*]] = constant 9 : index
-// CHECK: [[C10:%.*]] = constant 10 : index
-// CHECK: [[C4:%.*]] = constant 4 : index
-// CHECK: [[C12:%.*]] = constant 12 : index
-// CHECK: [[C0:%.*]] = constant 0 : index
-// CHECK: [[C1:%.*]] = constant 1 : index
-// CHECK: [[C2:%.*]] = constant 2 : index
+// CHECK-DAG: [[C12:%.*]] = constant 12 : index
+// CHECK-DAG: [[C10:%.*]] = constant 10 : index
+// CHECK-DAG: [[C9:%.*]] = constant 9 : index
+// CHECK-DAG: [[C6:%.*]] = constant 6 : index
+// CHECK-DAG: [[C4:%.*]] = constant 4 : index
+// CHECK-DAG: [[C3:%.*]] = constant 3 : index
+// CHECK-DAG: [[C2:%.*]] = constant 2 : index
+// CHECK-DAG: [[C1:%.*]] = constant 1 : index
+// CHECK-DAG: [[C0:%.*]] = constant 0 : index
 // CHECK: scf.parallel ([[NEW_I0:%.*]]) = ([[C0]]) to ([[C4]]) step ([[C1]]) {
 // CHECK:   [[V0:%.*]] = remi_signed [[NEW_I0]], [[C2]] : index
 // CHECK:   [[I0:%.*]] = divi_signed [[NEW_I0]], [[C2]] : index
 // CHECK:   [[V2:%.*]] = muli [[V0]], [[C10]] : index
 // CHECK:   [[I3:%.*]] = addi [[V2]], [[C9]] : index
 // CHECK:   "magic.op"([[I0]], [[C3]], [[C6]], [[I3]], [[C12]]) : (index, index, index, index, index) -> index
 // CHECK:   scf.yield

mlir/test/Transforms/single-parallel-loop-collapsing.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(parallel-loop-collapsing{collapsed-indices-0=0,1}, canonicalize)' | FileCheck %s
 
 func @collapse_to_single() {
   %c0 = constant 3 : index
   %c1 = constant 7 : index
   %c2 = constant 11 : index
   %c3 = constant 29 : index
   %c4 = constant 3 : index
   %c5 = constant 4 : index
   scf.parallel (%i0, %i1) = (%c0, %c1) to (%c2, %c3) step (%c4, %c5) {
     %result = "magic.op"(%i0, %i1): (index, index) -> index
   }
   return
 }
 
 // CHECK-LABEL: func @collapse_to_single() {
-// CHECK:         [[C7:%.*]] = constant 7 : index
-// CHECK:         [[C3:%.*]] = constant 3 : index
-// CHECK:         [[C4:%.*]] = constant 4 : index
-// CHECK:         [[C18:%.*]] = constant 18 : index
-// CHECK:         [[C6:%.*]] = constant 6 : index
-// CHECK:         [[C0:%.*]] = constant 0 : index
-// CHECK:         [[C1:%.*]] = constant 1 : index
+// CHECK-DAG:         [[C18:%.*]] = constant 18 : index
+// CHECK-DAG:         [[C6:%.*]] = constant 6 : index
+// CHECK-DAG:         [[C3:%.*]] = constant 3 : index
+// CHECK-DAG:         [[C7:%.*]] = constant 7 : index
+// CHECK-DAG:         [[C4:%.*]] = constant 4 : index
+// CHECK-DAG:         [[C1:%.*]] = constant 1 : index
+// CHECK-DAG:         [[C0:%.*]] = constant 0 : index
 // CHECK:         scf.parallel ([[NEW_I:%.*]]) = ([[C0]]) to ([[C18]]) step ([[C1]]) {
 // CHECK:           [[I0_COUNT:%.*]] = remi_signed [[NEW_I]], [[C6]] : index
 // CHECK:           [[I1_COUNT:%.*]] = divi_signed [[NEW_I]], [[C6]] : index
 // CHECK:           [[V0:%.*]] = muli [[I0_COUNT]], [[C4]] : index
 // CHECK:           [[I1:%.*]] = addi [[V0]], [[C7]] : index
 // CHECK:           [[V1:%.*]] = muli [[I1_COUNT]], [[C3]] : index
 // CHECK:           [[I0:%.*]] = addi [[V1]], [[C3]] : index
 // CHECK:           "magic.op"([[I0]], [[I1]]) : (index, index) -> index
 // CHECK:           scf.yield
 // CHECK-NEXT:    }
 // CHECK-NEXT:    return

mlir/test/Transforms/test-canonicalize.mlir

func @test_commutative_multi(%arg0: i32, %arg1: i32) -> (i32, i32) {
   %y = "test.op_commutative"(%c42_i32, %arg0, %arg1, %c43_i32) : (i32, i32, i32, i32) -> i32
 
   // CHECK-NEXT: %[[O1:.*]] = "test.op_commutative"(%[[ARG_0]], %[[ARG_1]], %[[C42]], %[[C43]]) : (i32, i32, i32, i32) -> i32
   %z = "test.op_commutative"(%arg0, %c42_i32, %c43_i32, %arg1): (i32, i32, i32, i32) -> i32
   // CHECK-NEXT: return %[[O0]], %[[O1]]
   return %y, %z: i32, i32
 }
 
+
+// CHECK-LABEL: func @test_commutative_multi_cst
+func @test_commutative_multi_cst(%arg0: i32, %arg1: i32) -> (i32, i32) {
+  // CHECK-NEXT: %c42_i32 = constant 42 : i32
+  %c42_i32 = constant 42 : i32
+  %c42_i32_2 = constant 42 : i32
+  // CHECK-NEXT: %[[O0:.*]] = "test.op_commutative"(%arg0, %arg1, %c42_i32, %c42_i32) : (i32, i32, i32, i32) -> i32
+  %y = "test.op_commutative"(%c42_i32, %arg0, %arg1, %c42_i32_2) : (i32, i32, i32, i32) -> i32
+
+  %c42_i32_3 = constant 42 : i32
+
+  // CHECK-NEXT: %[[O1:.*]] = "test.op_commutative"(%arg0, %arg1, %c42_i32, %c42_i32) : (i32, i32, i32, i32) -> i32
+  %z = "test.op_commutative"(%arg0, %c42_i32_3, %c42_i32_2, %arg1): (i32, i32, i32, i32) -> i32
+  // CHECK-NEXT: return %[[O0]], %[[O1]]
+  return %y, %z: i32, i32
+}
+
+// CHECK-LABEL: func @typemismatch
+
 func @typemismatch() -> i32 {
   %c42 = constant 42.0 : f32
 
   // The "passthrough_fold" folder will naively return its operand, but we don't
   // want to fold here because of the type mismatch.
 
   // CHECK: "test.passthrough_fold"
   %0 = "test.passthrough_fold"(%c42) : (f32) -> (i32)
   return %0 : i32
 }